diff --git a/blocks/html/html.h b/blocks/html/html.h
index a3e3bba17..69a43ff5a 100644
--- a/blocks/html/html.h
+++ b/blocks/html/html.h
@@ -150,7 +150,7 @@ struct HTMLGeneratorOStreamScope final : HTMLGeneratorScope {
 #define CURRENT_HTML_SWITCH(x, y) x y
 #define HTML(...) CURRENT_HTML_SWITCH(CURRENT_HTML_SWITCH_N(CURRENT_HTML_NARGS(__VA_ARGS__)), (__VA_ARGS__))
 
-}  // namespace current::html
+}  // namespace html
 }  // namespace current
 
 // The `htmltag` namespace is intentionally in the global scope, not within `::current`, so that it can be amended to.
@@ -168,7 +168,7 @@ struct _ final {
   }
 };
 
-}  // namespace ::htmltag
+}  // namespace htmltag
 
 #include "tags.h"
 
diff --git a/blocks/html/html_http.h b/blocks/html/html_http.h
index cc04b91c5..0979b05ac 100644
--- a/blocks/html/html_http.h
+++ b/blocks/html/html_http.h
@@ -52,7 +52,7 @@ struct HTMLGeneratorHTTPResponseScope final : HTMLGeneratorScope {
   std::ostream& OutputStream() override { return html_contents; }
 };
 
-}  // namespace current::html
+}  // namespace html
 }  // namespace current
 
 #endif  // BLOCKS_HTML_HTTP_H
diff --git a/blocks/html/tags.h b/blocks/html/tags.h
index 89c46efe0..996ebcca3 100644
--- a/blocks/html/tags.h
+++ b/blocks/html/tags.h
@@ -78,7 +78,6 @@ namespace htmltag {
 #define CURRENT_HTML_TAG(...) \
   CURRENT_HTML_TAG_SWITCH(CURRENT_HTML_TAG_SWITCH_N(CURRENT_HTML_TAG_NARGS(__VA_ARGS__)), (__VA_ARGS__))
 
-
 // clang-format off
 
 #define CURRENT_HTML_START_ONLY_TAG_COUNT_3(tag, param1, param2)                                                            \
@@ -148,6 +147,6 @@ CURRENT_HTML_TAG(table, border, cellpadding);
 CURRENT_HTML_TAG(tr);
 CURRENT_HTML_TAG(td, align, colspan, valign);
 
-}  // namespace ::htmltag
+}  // namespace htmltag
 
 #endif  // BLOCKS_HTML_TAGS_H
diff --git a/blocks/html/test.cc b/blocks/html/test.cc
index ee707598a..5865c5438 100644
--- a/blocks/html/test.cc
+++ b/blocks/html/test.cc
@@ -141,7 +141,7 @@ TEST(HTMLTest, Smoke) {
     {
       const auto scope = current::html::HTMLGeneratorOStreamScope(oss);
       HTML(table, border(0));  // Number, not a string.
-    } 
+    }
     EXPECT_EQ("<table border='0'></table>", oss.str());
   }
   {
@@ -149,7 +149,7 @@ TEST(HTMLTest, Smoke) {
     {
       const auto scope = current::html::HTMLGeneratorOStreamScope(oss);
       HTML(input, value(42));  // Number, not a string.
-    } 
+    }
     EXPECT_EQ("<input value='42'>", oss.str());
   }
 }
diff --git a/blocks/http/api.h b/blocks/http/api.h
index cb64583e3..14509a71a 100644
--- a/blocks/http/api.h
+++ b/blocks/http/api.h
@@ -78,8 +78,8 @@ inline typename current::weed::call_with_type<HTTP_IMPL, TS...> HTTP(TS&&... par
 
 using current::http::HTTP;
 using current::http::Request;
-using current::http::Response;
 using current::http::ReRegisterRoute;
+using current::http::Response;
 using HTTPRoutesScope = typename HTTP_IMPL::server_impl_t::HTTPRoutesScope;
 using HTTPRoutesScopeEntry = current::http::HTTPServerPOSIX::HTTPRoutesScopeEntry;
 
diff --git a/blocks/http/chunked_demo.cc b/blocks/http/chunked_demo.cc
index ce5c159f0..108dc5b74 100644
--- a/blocks/http/chunked_demo.cc
+++ b/blocks/http/chunked_demo.cc
@@ -105,9 +105,9 @@ y:0.183947}
 #include "../../bricks/strings/printf.h"
 #include "../../bricks/time/chrono.h"
 
-using current::time::Now;
-using current::strings::Printf;
 using current::net::http::Headers;
+using current::strings::Printf;
+using current::time::Now;
 
 DEFINE_int32(port, 8181, "The port to serve chunked response on.");
 
@@ -150,58 +150,55 @@ CURRENT_STRUCT(ExampleMeta) {
 
 // TODO(dkorolev): Finish multithreading. Need to notify active connections and wait for them to finish.
 int main() {
-  HTTP(FLAGS_port)
-      .Register("/layout",
-                [](Request r) {
-                  LayoutItem layout;
-                  LayoutItem row;
-                  layout.col.push_back(row);
-                  r(layout,
-                    // "layout",  <--  @dkorolev, remove this source file entirely, as it's obsolete.
-                    HTTPResponseCode.OK,
-                    Headers({{"Connection", "close"}, {"Access-Control-Allow-Origin", "*"}}),
-                    "application/json; charset=utf-8");
-                });
-  HTTP(FLAGS_port)
-      .Register("/meta",
-                [](Request r) {
-                  r(ExampleMeta(),
-                    // "meta",  <--  @dkorolev, remove this source file entirely, as it's obsolete.
-                    HTTPResponseCode.OK,
-                    Headers({{"Connection", "close"}, {"Access-Control-Allow-Origin", "*"}}),
-                    "application/json; charset=utf-8");
-                });
-  HTTP(FLAGS_port)
-      .Register("/data",
-                [](Request r) {
-                  std::thread([](Request&& r) {
-                    // Since we are in another thread, need to catch exceptions ourselves.
-                    try {
-                      auto response = r.connection.SendChunkedHTTPResponse(
-                          HTTPResponseCode.OK,
-                          {{"Connection", "keep-alive"}, {"Access-Control-Allow-Origin", "*"}},
-                          "application/json; charset=utf-8");
-                      std::string data;
-                      const double begin = static_cast<double>(Now().count());
-                      const double t = atof(r.url.query["t"].c_str());
-                      const double end = (t > 0) ? (begin + t * 1e3) : 1e18;
-                      double current;
-                      while ((current = static_cast<double>(Now().count())) < end) {
-                        std::this_thread::sleep_for(std::chrono::milliseconds(rand() % 100 + 100));
-                        const double x = current;
-                        const double y = sin(5e-3 * (current - begin));
-                        data += Printf("{\"x\":%lf,\"y\":%lf}\n", x, y);
-                        const double f = (rand() % 101) * (rand() % 101) * (rand() % 101) * 1e-6;
-                        const size_t n = static_cast<size_t>(data.length() * f);
-                        if (n) {
-                          response.Send(data.substr(0, n));
-                          data = data.substr(n);
-                        }
-                      }
-                    } catch (const current::Exception& e) {
-                      std::cerr << "Exception in data serving thread: " << e.what() << std::endl;
-                    }
-                  }, std::move(r)).detach();
-                });
+  HTTP(FLAGS_port).Register("/layout", [](Request r) {
+    LayoutItem layout;
+    LayoutItem row;
+    layout.col.push_back(row);
+    r(layout,
+      // "layout",  <--  @dkorolev, remove this source file entirely, as it's obsolete.
+      HTTPResponseCode.OK,
+      Headers({{"Connection", "close"}, {"Access-Control-Allow-Origin", "*"}}),
+      "application/json; charset=utf-8");
+  });
+  HTTP(FLAGS_port).Register("/meta", [](Request r) {
+    r(ExampleMeta(),
+      // "meta",  <--  @dkorolev, remove this source file entirely, as it's obsolete.
+      HTTPResponseCode.OK,
+      Headers({{"Connection", "close"}, {"Access-Control-Allow-Origin", "*"}}),
+      "application/json; charset=utf-8");
+  });
+  HTTP(FLAGS_port).Register("/data", [](Request r) {
+    std::thread(
+        [](Request&& r) {
+          // Since we are in another thread, need to catch exceptions ourselves.
+          try {
+            auto response = r.connection.SendChunkedHTTPResponse(
+                HTTPResponseCode.OK,
+                {{"Connection", "keep-alive"}, {"Access-Control-Allow-Origin", "*"}},
+                "application/json; charset=utf-8");
+            std::string data;
+            const double begin = static_cast<double>(Now().count());
+            const double t = atof(r.url.query["t"].c_str());
+            const double end = (t > 0) ? (begin + t * 1e3) : 1e18;
+            double current;
+            while ((current = static_cast<double>(Now().count())) < end) {
+              std::this_thread::sleep_for(std::chrono::milliseconds(rand() % 100 + 100));
+              const double x = current;
+              const double y = sin(5e-3 * (current - begin));
+              data += Printf("{\"x\":%lf,\"y\":%lf}\n", x, y);
+              const double f = (rand() % 101) * (rand() % 101) * (rand() % 101) * 1e-6;
+              const size_t n = static_cast<size_t>(data.length() * f);
+              if (n) {
+                response.Send(data.substr(0, n));
+                data = data.substr(n);
+              }
+            }
+          } catch (const current::Exception& e) {
+            std::cerr << "Exception in data serving thread: " << e.what() << std::endl;
+          }
+        },
+        std::move(r))
+        .detach();
+  });
   HTTP(FLAGS_port).Join();
 }
diff --git a/blocks/http/impl/posix_client.h b/blocks/http/impl/posix_client.h
index b686744b4..9cf8c8573 100644
--- a/blocks/http/impl/posix_client.h
+++ b/blocks/http/impl/posix_client.h
@@ -57,7 +57,7 @@ struct HTTPRedirectHelper : current::net::HTTPDefaultHelper {
     current::net::HTTPDefaultHelper::OnHeader(key, value);
   }
 };
-}  // namespace current::http::impl
+}  // namespace impl
 
 template <class HTTP_HELPER>
 class GenericHTTPClientPOSIX final {
@@ -94,8 +94,7 @@ class GenericHTTPClientPOSIX final {
           port = 80;
         }
       }
-      current::net::Connection connection(
-          current::net::Connection(current::net::ClientSocket(parsed_url.host, port)));
+      current::net::Connection connection(current::net::Connection(current::net::ClientSocket(parsed_url.host, port)));
       connection.BlockingWrite(
           request_method_ + ' ' + parsed_url.path + parsed_url.ComposeParameters() + " HTTP/1.1\r\n", true);
       connection.BlockingWrite("Host: " + parsed_url.host + "\r\n", true);
diff --git a/blocks/http/impl/posix_server.h b/blocks/http/impl/posix_server.h
index c98e917f2..e57ee877c 100644
--- a/blocks/http/impl/posix_server.h
+++ b/blocks/http/impl/posix_server.h
@@ -163,7 +163,9 @@ class HTTPServerPOSIX final {
   // Since instances of `HTTPServerPOSIX` are created via a singleton,
   // a listening thread will only be created once per port, on the first access to that port.
   explicit HTTPServerPOSIX(current::net::BarePort port)
-      : terminating_(false), port_(static_cast<uint16_t>(port)), thread_([this, port]() { Thread(current::net::Socket(port)); }) {}
+      : terminating_(false),
+        port_(static_cast<uint16_t>(port)),
+        thread_([this, port]() { Thread(current::net::Socket(port)); }) {}
   explicit HTTPServerPOSIX(current::net::ReservedLocalPort reserved_port)
       : terminating_(false),
         port_(reserved_port),
@@ -223,7 +225,8 @@ class HTTPServerPOSIX final {
                                 const URLPathArgs::CountMask path_args_count_mask,
                                 F& handler) {
     std::lock_guard<std::mutex> lock(mutex_);
-    return DoRegisterHandler(path, [&handler](Request r) { handler(std::move(r)); }, path_args_count_mask, POLICY);
+    return DoRegisterHandler(
+        path, [&handler](Request r) { handler(std::move(r)); }, path_args_count_mask, POLICY);
   }
 
   template <ReRegisterRoute POLICY = ReRegisterRoute::ThrowOnAttempt>
diff --git a/blocks/http/test.cc b/blocks/http/test.cc
index aebbd03cc..a9d643746 100644
--- a/blocks/http/test.cc
+++ b/blocks/http/test.cc
@@ -52,21 +52,21 @@ SOFTWARE.
 
 using std::string;
 
-using current::strings::Printf;
-using current::Singleton;
-using current::FileSystem;
 using current::FileException;
+using current::FileSystem;
+using current::Singleton;
+using current::strings::Printf;
 
 using current::net::Connection;
 using current::net::HTTPResponseCodeValue;
 using current::net::http::Headers;
 
 using current::net::DefaultInternalServerErrorMessage;
-using current::net::DefaultNotFoundMessage;
 using current::net::DefaultMethodNotAllowedMessage;
+using current::net::DefaultNotFoundMessage;
 
-using current::net::HTTPRedirectNotAllowedException;
 using current::net::HTTPRedirectLoopException;
+using current::net::HTTPRedirectNotAllowedException;
 using current::net::SocketResolveAddressException;
 
 DEFINE_string(net_api_test_tmpdir, ".current", "Local path for the test to create temporary files in.");
@@ -126,16 +126,13 @@ TEST(HTTPAPI, RegisterWithURLPathParams) {
   };
 
   const auto scope = HTTP(port).Register("/", URLPathArgs::CountMask::Any, handler) +
-                     HTTP(port)
-                         .Register("/user", URLPathArgs::CountMask::One | URLPathArgs::CountMask::Two, handler) +
+                     HTTP(port).Register("/user", URLPathArgs::CountMask::One | URLPathArgs::CountMask::Two, handler) +
                      HTTP(port).Register("/user/a", URLPathArgs::CountMask::One, handler) +
                      HTTP(port).Register("/user/a/1", URLPathArgs::CountMask::None, handler);
 
   ASSERT_THROW(HTTP(port).Register("/", handler), HandlerAlreadyExistsException);
-  ASSERT_THROW(HTTP(port).Register("/user", URLPathArgs::CountMask::Two, handler),
-               HandlerAlreadyExistsException);
-  ASSERT_THROW(HTTP(port).Register("/user/a", URLPathArgs::CountMask::One, handler),
-               HandlerAlreadyExistsException);
+  ASSERT_THROW(HTTP(port).Register("/user", URLPathArgs::CountMask::Two, handler), HandlerAlreadyExistsException);
+  ASSERT_THROW(HTTP(port).Register("/user/a", URLPathArgs::CountMask::One, handler), HandlerAlreadyExistsException);
   ASSERT_THROW(HTTP(port).Register("/user/a/1", handler), HandlerAlreadyExistsException);
 
   const auto run = [port](const std::string& path) -> std::string {
@@ -299,14 +296,10 @@ TEST(HTTPAPI, URLParameters) {
   const auto scope = http_server.Register("/query", [](Request r) { r("x=" + r.url.query["x"]); });
   EXPECT_EQ("x=", HTTP(GET(Printf("http://localhost:%d/query", port))).body);
   EXPECT_EQ("x=42", HTTP(GET(Printf("http://localhost:%d/query?x=42", port))).body);
-  EXPECT_EQ("x=test passed",
-            HTTP(GET(Printf("http://localhost:%d/query?x=test+passed", port))).body);
-  EXPECT_EQ("x=test passed",
-            HTTP(GET(Printf("http://localhost:%d/query?x=test%%20passed", port))).body);
-  EXPECT_EQ("x=test/passed",
-            HTTP(GET(Printf("http://localhost:%d/query?x=test%%2fpassed", port))).body);
-  EXPECT_EQ("x=test/passed",
-            HTTP(GET(Printf("http://localhost:%d/query?x=test%%2Fpassed", port))).body);
+  EXPECT_EQ("x=test passed", HTTP(GET(Printf("http://localhost:%d/query?x=test+passed", port))).body);
+  EXPECT_EQ("x=test passed", HTTP(GET(Printf("http://localhost:%d/query?x=test%%20passed", port))).body);
+  EXPECT_EQ("x=test/passed", HTTP(GET(Printf("http://localhost:%d/query?x=test%%2fpassed", port))).body);
+  EXPECT_EQ("x=test/passed", HTTP(GET(Printf("http://localhost:%d/query?x=test%%2Fpassed", port))).body);
 }
 
 TEST(HTTPAPI, InvalidHEXInURLParameters) {
@@ -339,21 +332,19 @@ TEST(HTTPAPI, HeadersAndCookies) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/headers_and_cookies",
-                                   [](Request r) {
-                                     EXPECT_TRUE(r.headers.Has("Header1"));
-                                     EXPECT_TRUE(r.headers.Has("Header2"));
-                                     EXPECT_EQ("foo", r.headers["Header1"].value);
-                                     EXPECT_EQ("bar", r.headers["Header2"].value);
-                                     EXPECT_EQ("x=1; y=2", r.headers.CookiesAsString());
-                                     Response response("OK");
-                                     response.headers.Set("X-Current-H1", "header1");
-                                     response.SetCookie("cookie1", "value1");
-                                     response.headers.Set("X-Current-H2", "header2");
-                                     response.SetCookie("cookie2", "value2");
-                                     r(response);
-                                   });
+  const auto scope = http_server.Register("/headers_and_cookies", [](Request r) {
+    EXPECT_TRUE(r.headers.Has("Header1"));
+    EXPECT_TRUE(r.headers.Has("Header2"));
+    EXPECT_EQ("foo", r.headers["Header1"].value);
+    EXPECT_EQ("bar", r.headers["Header2"].value);
+    EXPECT_EQ("x=1; y=2", r.headers.CookiesAsString());
+    Response response("OK");
+    response.headers.Set("X-Current-H1", "header1");
+    response.SetCookie("cookie1", "value1");
+    response.headers.Set("X-Current-H2", "header2");
+    response.SetCookie("cookie2", "value2");
+    r(response);
+  });
   const auto response = HTTP(GET(Printf("http://localhost:%d/headers_and_cookies", port))
                                  .SetHeader("Header1", "foo")
                                  .SetCookie("x", "1")
@@ -372,16 +363,14 @@ TEST(HTTPAPI, ConnectionIPAndPort) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/foo",
-                                   [port](Request r) {
-                                     const auto& c = r.connection;
-                                     EXPECT_EQ("127.0.0.1", c.LocalIPAndPort().ip);
-                                     EXPECT_EQ(port, c.LocalIPAndPort().port);
-                                     EXPECT_EQ("127.0.0.1", c.RemoteIPAndPort().ip);
-                                     EXPECT_LT(0, c.RemoteIPAndPort().port);
-                                     r("bar", HTTPResponseCode.OK);
-                                   });
+  const auto scope = http_server.Register("/foo", [port](Request r) {
+    const auto& c = r.connection;
+    EXPECT_EQ("127.0.0.1", c.LocalIPAndPort().ip);
+    EXPECT_EQ(port, c.LocalIPAndPort().port);
+    EXPECT_EQ("127.0.0.1", c.RemoteIPAndPort().ip);
+    EXPECT_LT(0, c.RemoteIPAndPort().port);
+    r("bar", HTTPResponseCode.OK);
+  });
   const string url = Printf("http://localhost:%d/foo", port);
   const auto response = HTTP(GET(url));
   EXPECT_EQ(200, static_cast<int>(response.code));
@@ -395,12 +384,9 @@ TEST(HTTPAPI, RespondsWithString) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope =
-      http_server
-          .Register("/responds_with_string",
-                    [](Request r) {
-                      r("test_string", HTTPResponseCode.OK, Headers({{"foo", "bar"}}), "application/json");
-                    });
+  const auto scope = http_server.Register("/responds_with_string", [](Request r) {
+    r("test_string", HTTPResponseCode.OK, Headers({{"foo", "bar"}}), "application/json");
+  });
   const string url = Printf("http://localhost:%d/responds_with_string", port);
   const auto response = HTTP(GET(url));
   EXPECT_EQ(200, static_cast<int>(response.code));
@@ -415,14 +401,9 @@ TEST(HTTPAPI, RespondsWithObject) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/responds_with_object",
-                                   [](Request r) {
-                                     r(HTTPAPITestObject(),
-                                       HTTPResponseCode.OK,
-                                       Headers({{"foo", "bar"}}),
-                                       "application/json");
-                                   });
+  const auto scope = http_server.Register("/responds_with_object", [](Request r) {
+    r(HTTPAPITestObject(), HTTPResponseCode.OK, Headers({{"foo", "bar"}}), "application/json");
+  });
   const string url = Printf("http://localhost:%d/responds_with_object", port);
   const auto response = HTTP(GET(url));
   EXPECT_EQ(200, static_cast<int>(response.code));
@@ -456,12 +437,10 @@ TEST(HTTPAPI, HandlesRespondTwiceWithString) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/respond_twice",
-                                   [](Request r) {
-                                     r("OK");
-                                     r("FAIL");
-                                   });
+  const auto scope = http_server.Register("/respond_twice", [](Request r) {
+    r("OK");
+    r("FAIL");
+  });
   const string url = Printf("http://localhost:%d/respond_twice", port);
   const auto response = HTTP(GET(url));
   EXPECT_EQ(200, static_cast<int>(response.code));
@@ -476,19 +455,17 @@ TEST(HTTPAPI, HandlesRespondTwiceWithResponse) {
 
   std::string result = "";
   std::atomic_bool result_ready(false);
-  const auto scope = http_server
-                         .Register("/respond_twice",
-                                   [&result, &result_ready](Request r) {
-                                     r(Response("OK", HTTPResponseCode.OK));
-                                     try {
-                                       r(Response("FAIL", HTTPResponseCode(762)));
-                                       result = "Error, second response did not throw.";
-                                       result_ready = true;
-                                     } catch (const current::net::AttemptedToSendHTTPResponseMoreThanOnce&) {
-                                       result = "OK, second response did throw.";
-                                       result_ready = true;
-                                     }
-                                   });
+  const auto scope = http_server.Register("/respond_twice", [&result, &result_ready](Request r) {
+    r(Response("OK", HTTPResponseCode.OK));
+    try {
+      r(Response("FAIL", HTTPResponseCode(762)));
+      result = "Error, second response did not throw.";
+      result_ready = true;
+    } catch (const current::net::AttemptedToSendHTTPResponseMoreThanOnce&) {
+      result = "OK, second response did throw.";
+      result_ready = true;
+    }
+  });
   const string url = Printf("http://localhost:%d/respond_twice", port);
   const auto response = HTTP(GET(url));
   EXPECT_EQ(200, static_cast<int>(response.code));
@@ -508,26 +485,16 @@ TEST(HTTPAPI, RedirectToRelativeURL) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/from",
-                                   [](Request r) {
-                                     r("",
-                                       HTTPResponseCode.Found,
-                                       Headers({{"Location", "/to"}}),
-                                       current::net::constants::kDefaultHTMLContentType);
-                                   }) +
-                     http_server.Register("/to", [](Request r) { r("Done."); });
+  const auto scope = http_server.Register("/from", [](Request r) {
+    r("", HTTPResponseCode.Found, Headers({{"Location", "/to"}}), current::net::constants::kDefaultHTMLContentType);
+  }) + http_server.Register("/to", [](Request r) { r("Done."); });
   // Redirect not allowed by default.
   ASSERT_THROW(HTTP(GET(Printf("http://localhost:%d/from", port))), HTTPRedirectNotAllowedException);
   // Redirect allowed when `.AllowRedirects()` is set.
   const auto response = HTTP(GET(Printf("http://localhost:%d/from", port)).AllowRedirects());
   EXPECT_EQ(200, static_cast<int>(response.code));
   EXPECT_EQ("Done.", response.body);
-  EXPECT_EQ((
-    port == 80
-      ? "http://localhost/to"
-      : Printf("http://localhost:%d/to", port)
-  ), response.url);
+  EXPECT_EQ((port == 80 ? "http://localhost/to" : Printf("http://localhost:%d/to", port)), response.url);
 }
 
 TEST(HTTPAPI, RedirectToFullURL) {
@@ -541,15 +508,12 @@ TEST(HTTPAPI, RedirectToFullURL) {
   // Need a live port for the redirect target because the HTTP client is following the redirect
   // and tries to connect to the redirect target, otherwise throws a `SocketConnectException`.
   const auto scope_redirect_to = HTTP(std::move(second_reserved_port)).Register("/to", [](Request r) { r("Done."); });
-  const auto scope =
-      http_server
-          .Register("/from",
-                    [second_port](Request r) {
-                      r("",
-                        HTTPResponseCode.Found,
-                        Headers({{"Location", Printf("http://localhost:%d/to", second_port)}}),
-                        current::net::constants::kDefaultHTMLContentType);
-                    });
+  const auto scope = http_server.Register("/from", [second_port](Request r) {
+    r("",
+      HTTPResponseCode.Found,
+      Headers({{"Location", Printf("http://localhost:%d/to", second_port)}}),
+      current::net::constants::kDefaultHTMLContentType);
+  });
   // Redirect not allowed by default.
   ASSERT_THROW(HTTP(GET(Printf("http://localhost:%d/from", port))), HTTPRedirectNotAllowedException);
   // Redirect allowed when `.AllowRedirects()` is set.
@@ -593,30 +557,13 @@ TEST(HTTPAPI, RedirectLoop) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/p1",
-                                   [](Request r) {
-                                     r("",
-                                       HTTPResponseCode.Found,
-                                       Headers({{"Location", "/p2"}}),
-                                       current::net::constants::kDefaultHTMLContentType);
-                                   }) +
-                     http_server
-                         .Register("/p2",
-                                   [](Request r) {
-                                     r("",
-                                       HTTPResponseCode.Found,
-                                       Headers({{"Location", "/p3"}}),
-                                       current::net::constants::kDefaultHTMLContentType);
-                                   }) +
-                     http_server
-                         .Register("/p3",
-                                   [](Request r) {
-                                     r("",
-                                       HTTPResponseCode.Found,
-                                       Headers({{"Location", "/p1"}}),
-                                       current::net::constants::kDefaultHTMLContentType);
-                                   });
+  const auto scope = http_server.Register("/p1", [](Request r) {
+    r("", HTTPResponseCode.Found, Headers({{"Location", "/p2"}}), current::net::constants::kDefaultHTMLContentType);
+  }) + http_server.Register("/p2", [](Request r) {
+    r("", HTTPResponseCode.Found, Headers({{"Location", "/p3"}}), current::net::constants::kDefaultHTMLContentType);
+  }) + http_server.Register("/p3", [](Request r) {
+    r("", HTTPResponseCode.Found, Headers({{"Location", "/p1"}}), current::net::constants::kDefaultHTMLContentType);
+  });
   {
     bool thrown = false;
     try {
@@ -647,11 +594,9 @@ TEST(HTTPAPI, ResponseDotNotation) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/response_dot_notation",
-                                   [](Request r) {
-                                     r(Response("OK").Code(HTTPResponseCode.Created).SetHeader("X-Foo", "bar"));
-                                   });
+  const auto scope = http_server.Register("/response_dot_notation", [](Request r) {
+    r(Response("OK").Code(HTTPResponseCode.Created).SetHeader("X-Foo", "bar"));
+  });
   const auto response = HTTP(GET(Printf("http://localhost:%d/response_dot_notation", port)));
   EXPECT_EQ("OK", response.body);
   EXPECT_EQ(201, static_cast<int>(response.code));
@@ -659,22 +604,15 @@ TEST(HTTPAPI, ResponseDotNotation) {
   EXPECT_EQ("bar", response.headers.Get("X-Foo"));
 }
 
-static Response BuildResponse() {
-  return Response("").Code(HTTPResponseCode.NoContent).SetHeader("X-Meh", "foo");
-}
+static Response BuildResponse() { return Response("").Code(HTTPResponseCode.NoContent).SetHeader("X-Meh", "foo"); }
 
 TEST(HTTPAPI, ResponseDotNotationReturnedFromAFunction) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/response_returned_from_function",
-                                   [](Request r) {
-                                     r(BuildResponse());
-                                   });
-  const auto response =
-      HTTP(GET(Printf("http://localhost:%d/response_returned_from_function", port)));
+  const auto scope = http_server.Register("/response_returned_from_function", [](Request r) { r(BuildResponse()); });
+  const auto response = HTTP(GET(Printf("http://localhost:%d/response_returned_from_function", port)));
   EXPECT_EQ("", response.body);
   EXPECT_EQ(204, static_cast<int>(response.code));
   EXPECT_TRUE(response.headers.Has("X-Meh"));
@@ -702,14 +640,12 @@ TEST(HTTPAPI, FourOhFiveMethodNotAllowed) {
   auto& http_server = HTTP(std::move(reserved_port));
 
   EXPECT_EQ("<h1>METHOD NOT ALLOWED</h1>\n", DefaultMethodNotAllowedMessage());
-  const auto scope = http_server
-                         .Register("/method_not_allowed",
-                                   [](Request r) {
-                                     r(DefaultMethodNotAllowedMessage(),
-                                       HTTPResponseCode.MethodNotAllowed,
-                                       current::net::http::Headers(),
-                                       current::net::constants::kDefaultHTMLContentType);
-                                   });
+  const auto scope = http_server.Register("/method_not_allowed", [](Request r) {
+    r(DefaultMethodNotAllowedMessage(),
+      HTTPResponseCode.MethodNotAllowed,
+      current::net::http::Headers(),
+      current::net::constants::kDefaultHTMLContentType);
+  });
   const string url = Printf("http://localhost:%d/method_not_allowed", port);
   const auto response = HTTP(GET(url));
   EXPECT_EQ(405, static_cast<int>(response.code));
@@ -742,12 +678,10 @@ TEST(HTTPAPI, DefaultInternalServerErrorCausedByExceptionInHandler) {
   auto& http_server = HTTP(std::move(reserved_port));
 
   EXPECT_EQ("<h1>INTERNAL SERVER ERROR</h1>\n", DefaultInternalServerErrorMessage());
-  const auto scope = http_server
-                         .Register("/oh_snap",
-                                   [](Request) {
-                                     // Only `current::Exception` is caught and handled.
-                                     CURRENT_THROW(current::Exception());
-                                   });
+  const auto scope = http_server.Register("/oh_snap", [](Request) {
+    // Only `current::Exception` is caught and handled.
+    CURRENT_THROW(current::Exception());
+  });
   const string url = Printf("http://localhost:%d/oh_snap", port);
   const auto response = HTTP(GET(url));
   EXPECT_EQ(500, static_cast<int>(response.code));
@@ -771,8 +705,7 @@ TEST(HTTPAPI, HandlerIsCapturedByReference) {
   Helper copy(helper);
   EXPECT_EQ(0u, helper.counter);
   EXPECT_EQ(0u, copy.counter);
-  const auto scope = http_server.Register("/incr", helper) +
-                     http_server.Register("/incr_same", helper) +
+  const auto scope = http_server.Register("/incr", helper) + http_server.Register("/incr_same", helper) +
                      http_server.Register("/incr_copy", copy);
   EXPECT_EQ("Incremented two.", HTTP(GET(Printf("http://localhost:%d/incr", port))).body);
   EXPECT_EQ(1u, helper.counter);
@@ -795,8 +728,7 @@ TEST(HTTPAPI, HandlerSupportsStaticMethods) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server.Register("/foo", Static::Foo) +
-                     http_server.Register("/bar", Static::Bar);
+  const auto scope = http_server.Register("/foo", Static::Foo) + http_server.Register("/bar", Static::Bar);
   EXPECT_EQ("foo", HTTP(GET(Printf("http://localhost:%d/foo", port))).body);
   EXPECT_EQ("bar", HTTP(GET(Printf("http://localhost:%d/bar", port))).body);
 }
@@ -813,33 +745,31 @@ TEST(HTTPAPI, GetToFile) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/stars",
-                                   [](Request r) {
-                                     const size_t n = atoi(r.url.query["n"].c_str());
-                                     auto response = r.connection.SendChunkedHTTPResponse();
-                                     const auto sleep = []() {
-                                       const uint64_t delay_between_chunks = []() {
-                                         bool& reduce = Singleton<ShouldReduceDelayBetweenChunksSingleton>().yes;
-                                         if (!reduce) {
-                                           reduce = true;
-                                           return 10;
-                                         } else {
-                                           return 1;
-                                         }
-                                       }();
-                                       std::this_thread::sleep_for(std::chrono::milliseconds(delay_between_chunks));
-                                     };
-                                     sleep();
-                                     for (size_t i = 0; i < n; ++i) {
-                                       response.Send("*");
-                                       sleep();
-                                       response.Send(std::vector<char>({'a', 'b'}));
-                                       sleep();
-                                       response.Send(std::vector<uint8_t>({0x31, 0x32}));
-                                       sleep();
-                                     }
-                                   });
+  const auto scope = http_server.Register("/stars", [](Request r) {
+    const size_t n = atoi(r.url.query["n"].c_str());
+    auto response = r.connection.SendChunkedHTTPResponse();
+    const auto sleep = []() {
+      const uint64_t delay_between_chunks = []() {
+        bool& reduce = Singleton<ShouldReduceDelayBetweenChunksSingleton>().yes;
+        if (!reduce) {
+          reduce = true;
+          return 10;
+        } else {
+          return 1;
+        }
+      }();
+      std::this_thread::sleep_for(std::chrono::milliseconds(delay_between_chunks));
+    };
+    sleep();
+    for (size_t i = 0; i < n; ++i) {
+      response.Send("*");
+      sleep();
+      response.Send(std::vector<char>({'a', 'b'}));
+      sleep();
+      response.Send(std::vector<uint8_t>({0x31, 0x32}));
+      sleep();
+    }
+  });
   current::FileSystem::MkDir(FLAGS_net_api_test_tmpdir, FileSystem::MkDirParameters::Silent);
   const string file_name = FLAGS_net_api_test_tmpdir + "/some_test_file_for_http_get";
   const auto test_file_scope = FileSystem::ScopedRmFile(file_name);
@@ -856,16 +786,14 @@ TEST(HTTPAPI, ChunkedResponseWithHeaders) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/chunked_with_header",
-                                   [](Request r) {
-                                     EXPECT_EQ("GET", r.method);
-                                     auto response = r.connection.SendChunkedHTTPResponse(
-                                         HTTPResponseCode.OK, Headers({{"header", "yeah"}}), "text/plain");
-                                     response.Send("A");
-                                     response.Send("B");
-                                     response.Send("C");
-                                   });
+  const auto scope = http_server.Register("/chunked_with_header", [](Request r) {
+    EXPECT_EQ("GET", r.method);
+    auto response =
+        r.connection.SendChunkedHTTPResponse(HTTPResponseCode.OK, Headers({{"header", "yeah"}}), "text/plain");
+    response.Send("A");
+    response.Send("B");
+    response.Send("C");
+  });
   const auto response = HTTP(GET(Printf("http://localhost:%d/chunked_with_header", port)));
   EXPECT_EQ(200, static_cast<int>(response.code));
   EXPECT_EQ("ABC", response.body);
@@ -881,15 +809,13 @@ TEST(HTTPAPI, GetByChunksPrototype) {
   auto& http_server = HTTP(std::move(reserved_port));
 
   // Handler returning the result chunk by chunk.
-  const auto scope = http_server
-                         .Register("/chunks",
-                                   [](Request r) {
-                                     auto response = r.connection.SendChunkedHTTPResponse(
-                                         HTTPResponseCode.OK, Headers({{"header", "oh-well"}}), "text/plain");
-                                     response.Send("1\n");
-                                     response.Send("23\n");
-                                     response.Send("456\n");
-                                   });
+  const auto scope = http_server.Register("/chunks", [](Request r) {
+    auto response =
+        r.connection.SendChunkedHTTPResponse(HTTPResponseCode.OK, Headers({{"header", "oh-well"}}), "text/plain");
+    response.Send("1\n");
+    response.Send("23\n");
+    response.Send("456\n");
+  });
   const string url = Printf("http://localhost:%d/chunks", port);
   {
     // A conventional GET, ignoring chunk boundaries and concatenating all the data together.
@@ -951,10 +877,12 @@ TEST(HTTPAPI, GetByChunksPrototype) {
 
     std::vector<std::string> headers;
     std::vector<std::string> chunk_by_chunk_response;
-    const auto header_callback =
-        [&headers](const std::string& k, const std::string& v) { headers.push_back(k + '=' + v); };
-    const auto chunk_callback =
-        [&chunk_by_chunk_response](const std::string& s) { chunk_by_chunk_response.push_back(s); };
+    const auto header_callback = [&headers](const std::string& k, const std::string& v) {
+      headers.push_back(k + '=' + v);
+    };
+    const auto chunk_callback = [&chunk_by_chunk_response](const std::string& s) {
+      chunk_by_chunk_response.push_back(s);
+    };
     const auto done_callback = [&chunk_by_chunk_response]() { chunk_by_chunk_response.push_back("DONE"); };
 
     current::http::GenericHTTPClientPOSIX<ChunkByChunkHTTPResponseReceiver> client(
@@ -972,11 +900,11 @@ TEST(HTTPAPI, GetByChunksPrototype) {
     std::vector<std::string> headers;
     std::vector<std::string> chunk_by_chunk_response;
 
-    const auto response =
-        HTTP(ChunkedGET(url,
-                        [&headers](const std::string& k, const std::string& v) { headers.push_back(k + '=' + v); },
-                        [&chunk_by_chunk_response](const std::string& s) { chunk_by_chunk_response.push_back(s); },
-                        [&chunk_by_chunk_response]() { chunk_by_chunk_response.push_back("DONE"); }));
+    const auto response = HTTP(ChunkedGET(
+        url,
+        [&headers](const std::string& k, const std::string& v) { headers.push_back(k + '=' + v); },
+        [&chunk_by_chunk_response](const std::string& s) { chunk_by_chunk_response.push_back(s); },
+        [&chunk_by_chunk_response]() { chunk_by_chunk_response.push_back("DONE"); }));
     EXPECT_EQ(200, static_cast<int>(response));
     EXPECT_EQ("1\n|23\n|456\n|DONE", current::strings::Join(chunk_by_chunk_response, '|'));
     EXPECT_EQ(4u, headers.size());
@@ -1039,72 +967,74 @@ TEST(HTTPAPI, ChunkedBodySemantics) {
     std::vector<std::string> headers;
     std::vector<std::string> chunk_by_chunk_response;
 
-    const auto response =
-        HTTP(ChunkedGET(url,
-                        [&headers](const std::string& k, const std::string& v) { headers.push_back(k + '=' + v); },
-                        [&chunk_by_chunk_response](const std::string& s) { chunk_by_chunk_response.push_back(s); },
-                        [&chunk_by_chunk_response]() { chunk_by_chunk_response.push_back("DONE"); }));
+    const auto response = HTTP(ChunkedGET(
+        url,
+        [&headers](const std::string& k, const std::string& v) { headers.push_back(k + '=' + v); },
+        [&chunk_by_chunk_response](const std::string& s) { chunk_by_chunk_response.push_back(s); },
+        [&chunk_by_chunk_response]() { chunk_by_chunk_response.push_back("DONE"); }));
     EXPECT_EQ(200, static_cast<int>(response));
-    EXPECT_EQ(
-        "{\"s\":|\"foo\"|}\n{\"s\":\"bar\"}\n|{\"s\":\"baz\"}|DONE",
-        current::strings::Join(chunk_by_chunk_response, '|'));
+    EXPECT_EQ("{\"s\":|\"foo\"|}\n{\"s\":\"bar\"}\n|{\"s\":\"baz\"}|DONE",
+              current::strings::Join(chunk_by_chunk_response, '|'));
     EXPECT_EQ(4u, headers.size());
-    EXPECT_EQ("Content-Type=application/stream+json; charset=utf-8|Connection=keep-alive"
-              "|TestHeaderName=TestHeaderValue|Transfer-Encoding=chunked",
-              current::strings::Join(headers, '|'));
+    EXPECT_EQ(
+        "Content-Type=application/stream+json; charset=utf-8|Connection=keep-alive"
+        "|TestHeaderName=TestHeaderValue|Transfer-Encoding=chunked",
+        current::strings::Join(headers, '|'));
   }
 
   {
     std::vector<std::string> headers;
     std::vector<std::string> chunk_by_chunk_response;
 
-    const auto response = HTTP(ChunkedGET(url)
-        .OnHeader([&headers](const std::string& k, const std::string& v) { headers.push_back(k + '=' + v); })
-        .OnChunk([&chunk_by_chunk_response](const std::string& s) { chunk_by_chunk_response.push_back(s); })
-        .OnDone([&chunk_by_chunk_response]() { chunk_by_chunk_response.push_back("DONE"); }));
+    const auto response =
+        HTTP(ChunkedGET(url)
+                 .OnHeader([&headers](const std::string& k, const std::string& v) { headers.push_back(k + '=' + v); })
+                 .OnChunk([&chunk_by_chunk_response](const std::string& s) { chunk_by_chunk_response.push_back(s); })
+                 .OnDone([&chunk_by_chunk_response]() { chunk_by_chunk_response.push_back("DONE"); }));
     EXPECT_EQ(200, static_cast<int>(response));
-    EXPECT_EQ(
-        "{\"s\":|\"foo\"|}\n{\"s\":\"bar\"}\n|{\"s\":\"baz\"}|DONE",
-        current::strings::Join(chunk_by_chunk_response, '|'));
+    EXPECT_EQ("{\"s\":|\"foo\"|}\n{\"s\":\"bar\"}\n|{\"s\":\"baz\"}|DONE",
+              current::strings::Join(chunk_by_chunk_response, '|'));
     EXPECT_EQ(4u, headers.size());
-    EXPECT_EQ("Content-Type=application/stream+json; charset=utf-8|Connection=keep-alive"
-              "|TestHeaderName=TestHeaderValue|Transfer-Encoding=chunked",
-              current::strings::Join(headers, '|'));
+    EXPECT_EQ(
+        "Content-Type=application/stream+json; charset=utf-8|Connection=keep-alive"
+        "|TestHeaderName=TestHeaderValue|Transfer-Encoding=chunked",
+        current::strings::Join(headers, '|'));
   }
 
   {
     std::vector<std::string> headers;
     std::vector<std::string> chunk_by_chunk_response;
 
-    const auto response = HTTP(ChunkedPOST(url, "test")
-        .OnHeader([&headers](const std::string& k, const std::string& v) { headers.push_back(k + '=' + v); })
-        .OnChunk([&chunk_by_chunk_response](const std::string& s) { chunk_by_chunk_response.push_back(s); })
-        .OnDone([&chunk_by_chunk_response]() { chunk_by_chunk_response.push_back("DONE"); }));
+    const auto response =
+        HTTP(ChunkedPOST(url, "test")
+                 .OnHeader([&headers](const std::string& k, const std::string& v) { headers.push_back(k + '=' + v); })
+                 .OnChunk([&chunk_by_chunk_response](const std::string& s) { chunk_by_chunk_response.push_back(s); })
+                 .OnDone([&chunk_by_chunk_response]() { chunk_by_chunk_response.push_back("DONE"); }));
     EXPECT_EQ(200, static_cast<int>(response));
-    EXPECT_EQ(
-        "{\"s\":|\"foo\"|}\n{\"s\":\"test\"}\n|{\"s\":\"baz\"}|DONE",
-        current::strings::Join(chunk_by_chunk_response, '|'));
+    EXPECT_EQ("{\"s\":|\"foo\"|}\n{\"s\":\"test\"}\n|{\"s\":\"baz\"}|DONE",
+              current::strings::Join(chunk_by_chunk_response, '|'));
     EXPECT_EQ(4u, headers.size());
-    EXPECT_EQ("Content-Type=application/stream+json; charset=utf-8|Connection=keep-alive"
-              "|TestHeaderName=TestHeaderValue|Transfer-Encoding=chunked",
-              current::strings::Join(headers, '|'));
+    EXPECT_EQ(
+        "Content-Type=application/stream+json; charset=utf-8|Connection=keep-alive"
+        "|TestHeaderName=TestHeaderValue|Transfer-Encoding=chunked",
+        current::strings::Join(headers, '|'));
   }
 
   {
     std::vector<std::string> headers;
     std::vector<std::string> line_by_line_response;
 
-    const auto response = HTTP(ChunkedPOST(url, "passed")
-        .OnHeader([&headers](const std::string& k, const std::string& v) { headers.push_back(k + '=' + v); })
-        .OnLine([&line_by_line_response](const std::string& s) { line_by_line_response.push_back(s); }));
+    const auto response =
+        HTTP(ChunkedPOST(url, "passed")
+                 .OnHeader([&headers](const std::string& k, const std::string& v) { headers.push_back(k + '=' + v); })
+                 .OnLine([&line_by_line_response](const std::string& s) { line_by_line_response.push_back(s); }));
     EXPECT_EQ(200, static_cast<int>(response));
-    EXPECT_EQ(
-        "{\"s\":\"foo\"}|{\"s\":\"passed\"}|{\"s\":\"baz\"}",
-        current::strings::Join(line_by_line_response, '|'));
+    EXPECT_EQ("{\"s\":\"foo\"}|{\"s\":\"passed\"}|{\"s\":\"baz\"}", current::strings::Join(line_by_line_response, '|'));
     EXPECT_EQ(4u, headers.size());
-    EXPECT_EQ("Content-Type=application/stream+json; charset=utf-8|Connection=keep-alive"
-              "|TestHeaderName=TestHeaderValue|Transfer-Encoding=chunked",
-              current::strings::Join(headers, '|'));
+    EXPECT_EQ(
+        "Content-Type=application/stream+json; charset=utf-8|Connection=keep-alive"
+        "|TestHeaderName=TestHeaderValue|Transfer-Encoding=chunked",
+        current::strings::Join(headers, '|'));
   }
 
   {
@@ -1125,14 +1055,11 @@ TEST(HTTPAPI, PostFromBufferToBuffer) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/post",
-                                   [](Request r) {
-                                     ASSERT_FALSE(r.body.empty());
-                                     r("Data: " + r.body);
-                                   });
-  const auto response =
-      HTTP(POST(Printf("http://localhost:%d/post", port), "No shit!", "application/octet-stream"));
+  const auto scope = http_server.Register("/post", [](Request r) {
+    ASSERT_FALSE(r.body.empty());
+    r("Data: " + r.body);
+  });
+  const auto response = HTTP(POST(Printf("http://localhost:%d/post", port), "No shit!", "application/octet-stream"));
   EXPECT_EQ("Data: No shit!", response.body);
 }
 
@@ -1141,17 +1068,13 @@ TEST(HTTPAPI, PostAStringAsString) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/post_string",
-                                   [](Request r) {
-                                     ASSERT_FALSE(r.body.empty());
-                                     EXPECT_EQ("POST", r.method);
-                                     r(r.body);
-                                   });
+  const auto scope = http_server.Register("/post_string", [](Request r) {
+    ASSERT_FALSE(r.body.empty());
+    EXPECT_EQ("POST", r.method);
+    r(r.body);
+  });
   EXPECT_EQ("std::string",
-            HTTP(POST(Printf("http://localhost:%d/post_string", port),
-                      std::string("std::string"),
-                      "text/plain")).body);
+            HTTP(POST(Printf("http://localhost:%d/post_string", port), std::string("std::string"), "text/plain")).body);
 }
 
 TEST(HTTPAPI, PostAStringAsConstCharPtr) {
@@ -1159,17 +1082,16 @@ TEST(HTTPAPI, PostAStringAsConstCharPtr) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/post_const_char_ptr",
-                                   [](Request r) {
-                                     ASSERT_FALSE(r.body.empty());
-                                     EXPECT_EQ("POST", r.method);
-                                     r(r.body);
-                                   });
+  const auto scope = http_server.Register("/post_const_char_ptr", [](Request r) {
+    ASSERT_FALSE(r.body.empty());
+    EXPECT_EQ("POST", r.method);
+    r(r.body);
+  });
   EXPECT_EQ("const char*",
             HTTP(POST(Printf("http://localhost:%d/post_const_char_ptr", port),
                       static_cast<const char*>("const char*"),
-                      "text/plain")).body);
+                      "text/plain"))
+                .body);
 }
 
 TEST(HTTPAPI, PostWithEmptyBodyMustSetZeroContentLength) {
@@ -1177,12 +1099,10 @@ TEST(HTTPAPI, PostWithEmptyBodyMustSetZeroContentLength) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/post",
-                                   [](Request r) {
-                                     ASSERT_TRUE(r.body.empty());
-                                     r("Yo!\n");
-                                   });
+  const auto scope = http_server.Register("/post", [](Request r) {
+    ASSERT_TRUE(r.body.empty());
+    r("Yo!\n");
+  });
   const auto response = HTTP(POST(Printf("http://localhost:%d/post", port), ""));
   EXPECT_EQ("Yo!\n", response.body);
 }
@@ -1192,15 +1112,12 @@ TEST(HTTPAPI, RespondWithStringAsString) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/respond_with_std_string",
-                                   [](Request r) {
-                                     EXPECT_EQ("POST", r.method);
-                                     EXPECT_EQ("", r.body);
-                                     r.connection.SendHTTPResponse(std::string("std::string"), HTTPResponseCode.OK);
-                                   });
-  EXPECT_EQ("std::string",
-            HTTP(POST(Printf("http://localhost:%d/respond_with_std_string", port), "")).body);
+  const auto scope = http_server.Register("/respond_with_std_string", [](Request r) {
+    EXPECT_EQ("POST", r.method);
+    EXPECT_EQ("", r.body);
+    r.connection.SendHTTPResponse(std::string("std::string"), HTTPResponseCode.OK);
+  });
+  EXPECT_EQ("std::string", HTTP(POST(Printf("http://localhost:%d/respond_with_std_string", port), "")).body);
 }
 
 TEST(HTTPAPI, RespondWithStringAsConstCharPtr) {
@@ -1208,15 +1125,11 @@ TEST(HTTPAPI, RespondWithStringAsConstCharPtr) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope =
-      http_server
-          .Register("/respond_with_const_char_ptr",
-                    [](Request r) {
-                      EXPECT_EQ("", r.body);
-                      r.connection.SendHTTPResponse(static_cast<const char*>("const char*"), HTTPResponseCode.OK);
-                    });
-  EXPECT_EQ("const char*",
-            HTTP(POST(Printf("http://localhost:%d/respond_with_const_char_ptr", port), "")).body);
+  const auto scope = http_server.Register("/respond_with_const_char_ptr", [](Request r) {
+    EXPECT_EQ("", r.body);
+    r.connection.SendHTTPResponse(static_cast<const char*>("const char*"), HTTPResponseCode.OK);
+  });
+  EXPECT_EQ("const char*", HTTP(POST(Printf("http://localhost:%d/respond_with_const_char_ptr", port), "")).body);
 }
 
 TEST(HTTPAPI, RespondWithStringAsStringViaRequestDirectly) {
@@ -1224,16 +1137,12 @@ TEST(HTTPAPI, RespondWithStringAsStringViaRequestDirectly) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/respond_with_std_string_via_request_directly",
-                                   [](Request r) {
-                                     EXPECT_EQ("", r.body);
-                                     r(std::string("std::string"), HTTPResponseCode.OK);
-                                   });
-  EXPECT_EQ(
-      "std::string",
-      HTTP(POST(Printf("http://localhost:%d/respond_with_std_string_via_request_directly", port),
-                "")).body);
+  const auto scope = http_server.Register("/respond_with_std_string_via_request_directly", [](Request r) {
+    EXPECT_EQ("", r.body);
+    r(std::string("std::string"), HTTPResponseCode.OK);
+  });
+  EXPECT_EQ("std::string",
+            HTTP(POST(Printf("http://localhost:%d/respond_with_std_string_via_request_directly", port), "")).body);
 }
 
 TEST(HTTPAPI, RespondWithStringAsConstCharPtrViaRequestDirectly) {
@@ -1241,16 +1150,12 @@ TEST(HTTPAPI, RespondWithStringAsConstCharPtrViaRequestDirectly) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/respond_with_const_char_ptr_via_request_directly",
-                                   [](Request r) {
-                                     EXPECT_EQ("", r.body);
-                                     r(static_cast<const char*>("const char*"), HTTPResponseCode.OK);
-                                   });
-  EXPECT_EQ(
-      "const char*",
-      HTTP(POST(Printf("http://localhost:%d/respond_with_const_char_ptr_via_request_directly", port),
-                "")).body);
+  const auto scope = http_server.Register("/respond_with_const_char_ptr_via_request_directly", [](Request r) {
+    EXPECT_EQ("", r.body);
+    r(static_cast<const char*>("const char*"), HTTPResponseCode.OK);
+  });
+  EXPECT_EQ("const char*",
+            HTTP(POST(Printf("http://localhost:%d/respond_with_const_char_ptr_via_request_directly", port), "")).body);
 }
 
 CURRENT_STRUCT(SerializableObject) {
@@ -1259,9 +1164,7 @@ CURRENT_STRUCT(SerializableObject) {
   std::string AsString() const { return Printf("%d:%s", static_cast<int>(x), s.c_str()); }
 };
 
-CURRENT_STRUCT(AnotherSerializableObject) {
-  CURRENT_FIELD(z, uint32_t, 42u);
-};
+CURRENT_STRUCT(AnotherSerializableObject) { CURRENT_FIELD(z, uint32_t, 42u); };
 
 CURRENT_VARIANT(SerializableVariant, SerializableObject, AnotherSerializableObject);
 
@@ -1278,8 +1181,7 @@ TEST(HTTPAPI, PostFromInvalidFile) {
     return port;
   }();
 
-  ASSERT_THROW(HTTP(POSTFromFile(
-                   Printf("http://localhost:%d/foo", port), non_existent_file_name, "text/plain")),
+  ASSERT_THROW(HTTP(POSTFromFile(Printf("http://localhost:%d/foo", port), non_existent_file_name, "text/plain")),
                FileException);
 }
 #endif
@@ -1289,12 +1191,10 @@ TEST(HTTPAPI, PostFromFileToBuffer) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/post",
-                                   [](Request r) {
-                                     ASSERT_FALSE(r.body.empty());
-                                     r("Voila: " + r.body);
-                                   });
+  const auto scope = http_server.Register("/post", [](Request r) {
+    ASSERT_FALSE(r.body.empty());
+    r("Voila: " + r.body);
+  });
   current::FileSystem::MkDir(FLAGS_net_api_test_tmpdir, FileSystem::MkDirParameters::Silent);
   const string file_name = FLAGS_net_api_test_tmpdir + "/some_input_test_file_for_http_post";
   const auto test_file_scope = FileSystem::ScopedRmFile(file_name);
@@ -1312,12 +1212,10 @@ TEST(HTTPAPI, PostFromBufferToFile) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/post",
-                                   [](Request r) {
-                                     ASSERT_FALSE(r.body.empty());
-                                     r("Meh: " + r.body);
-                                   });
+  const auto scope = http_server.Register("/post", [](Request r) {
+    ASSERT_FALSE(r.body.empty());
+    r("Meh: " + r.body);
+  });
   current::FileSystem::MkDir(FLAGS_net_api_test_tmpdir, FileSystem::MkDirParameters::Silent);
   const string file_name = FLAGS_net_api_test_tmpdir + "/some_output_test_file_for_http_post";
   const auto test_file_scope = FileSystem::ScopedRmFile(file_name);
@@ -1334,12 +1232,10 @@ TEST(HTTPAPI, PostFromFileToFile) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/post",
-                                   [](Request r) {
-                                     ASSERT_FALSE(r.body.empty());
-                                     r("Phew: " + r.body);
-                                   });
+  const auto scope = http_server.Register("/post", [](Request r) {
+    ASSERT_FALSE(r.body.empty());
+    r("Phew: " + r.body);
+  });
   current::FileSystem::MkDir(FLAGS_net_api_test_tmpdir, FileSystem::MkDirParameters::Silent);
   const string request_file_name = FLAGS_net_api_test_tmpdir + "/some_complex_request_test_file_for_http_post";
   const string response_file_name = FLAGS_net_api_test_tmpdir + "/some_complex_response_test_file_for_http_post";
@@ -1360,13 +1256,11 @@ TEST(HTTPAPI, HeadRequest) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/head",
-                                   [](Request r) {
-                                     EXPECT_EQ("HEAD", r.method);
-                                     ASSERT_TRUE(r.body.empty());
-                                     r("", HTTPResponseCode.OK, Headers({{"foo", "bar"}}), "text/html");
-                                   });
+  const auto scope = http_server.Register("/head", [](Request r) {
+    EXPECT_EQ("HEAD", r.method);
+    ASSERT_TRUE(r.body.empty());
+    r("", HTTPResponseCode.OK, Headers({{"foo", "bar"}}), "text/html");
+  });
   const auto response = HTTP(HEAD(Printf("http://localhost:%d/head", port)));
   EXPECT_EQ(200, static_cast<int>(response.code));
   EXPECT_TRUE(response.body.empty());
@@ -1379,14 +1273,12 @@ TEST(HTTPAPI, DeleteRequest) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/delete",
-                                   [](Request r) {
-                                     EXPECT_EQ("DELETE", r.method);
-                                     ASSERT_TRUE(r.body.empty());
-                                     SerializableObject object;
-                                     r(object);
-                                   });
+  const auto scope = http_server.Register("/delete", [](Request r) {
+    EXPECT_EQ("DELETE", r.method);
+    ASSERT_TRUE(r.body.empty());
+    SerializableObject object;
+    r(object);
+  });
   const auto response = HTTP(DELETE(Printf("http://localhost:%d/delete", port)));
   EXPECT_EQ("42:foo", ParseJSON<SerializableObject>(response.body).AsString());
   EXPECT_EQ(200, static_cast<int>(response.code));
@@ -1397,13 +1289,11 @@ TEST(HTTPAPI, PatchRequest) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/patch",
-                                   [](Request r) {
-                                     EXPECT_EQ("PATCH", r.method);
-                                     EXPECT_EQ("test", r.body);
-                                     r("Patch OK.");
-                                   });
+  const auto scope = http_server.Register("/patch", [](Request r) {
+    EXPECT_EQ("PATCH", r.method);
+    EXPECT_EQ("test", r.body);
+    r("Patch OK.");
+  });
   const auto response = HTTP(PATCH(Printf("http://localhost:%d/patch", port), "test"));
   EXPECT_EQ("Patch OK.", response.body);
   EXPECT_EQ(200, static_cast<int>(response.code));
@@ -1414,8 +1304,8 @@ TEST(HTTPAPI, UserAgent) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/ua", [](Request r) { r("TODO(dkorolev): Actually get passed in user agent."); });
+  const auto scope =
+      http_server.Register("/ua", [](Request r) { r("TODO(dkorolev): Actually get passed in user agent."); });
   const string url = Printf("http://localhost:%d/ua", port);
   const auto response = HTTP(GET(url).UserAgent("Blah"));
   EXPECT_EQ(url, response.url);
@@ -1513,98 +1403,68 @@ TEST(HTTPAPI, ServeStaticFilesFrom) {
 
   // Redirect from directory without trailing slash to directory with trailing slash.
   {
-    ASSERT_THROW(HTTP(GET(Printf("http://localhost:%d/sub_dir", port))),
-                 HTTPRedirectNotAllowedException);
-    const auto sub_dir_response =
-        HTTP(GET(Printf("http://localhost:%d/sub_dir", port)).AllowRedirects());
+    ASSERT_THROW(HTTP(GET(Printf("http://localhost:%d/sub_dir", port))), HTTPRedirectNotAllowedException);
+    const auto sub_dir_response = HTTP(GET(Printf("http://localhost:%d/sub_dir", port)).AllowRedirects());
     EXPECT_EQ(200, static_cast<int>(sub_dir_response.code));
-    EXPECT_EQ((
-      port == 80
-        ? "http://localhost/sub_dir/"
-        : Printf("http://localhost:%d/sub_dir/", port)
-    ), sub_dir_response.url);
+    EXPECT_EQ((port == 80 ? "http://localhost/sub_dir/" : Printf("http://localhost:%d/sub_dir/", port)),
+              sub_dir_response.url);
     ASSERT_TRUE(sub_dir_response.headers.Has("Content-Type"));
     EXPECT_EQ("text/html", sub_dir_response.headers.Get("Content-Type"));
     EXPECT_EQ("<h1>HTML sub_dir index</h1>", sub_dir_response.body);
   }
   {
-    ASSERT_THROW(HTTP(GET(Printf("http://localhost:%d/sub_dir/sub_sub_dir", port))),
-                 HTTPRedirectNotAllowedException);
+    ASSERT_THROW(HTTP(GET(Printf("http://localhost:%d/sub_dir/sub_sub_dir", port))), HTTPRedirectNotAllowedException);
     const auto sub_sub_dir_response =
         HTTP(GET(Printf("http://localhost:%d/sub_dir/sub_sub_dir", port)).AllowRedirects());
     EXPECT_EQ(200, static_cast<int>(sub_sub_dir_response.code));
-    EXPECT_EQ((
-      port == 80
-        ? "http://localhost/sub_dir/sub_sub_dir/"
-        : Printf("http://localhost:%d/sub_dir/sub_sub_dir/", port)
-    ), sub_sub_dir_response.url);
+    EXPECT_EQ((port == 80 ? "http://localhost/sub_dir/sub_sub_dir/"
+                          : Printf("http://localhost:%d/sub_dir/sub_sub_dir/", port)),
+              sub_sub_dir_response.url);
     ASSERT_TRUE(sub_sub_dir_response.headers.Has("Content-Type"));
     EXPECT_EQ("text/html", sub_sub_dir_response.headers.Get("Content-Type"));
     EXPECT_EQ("<h1>HTML sub_sub_dir index</h1>", sub_sub_dir_response.body);
   }
 
   // Subdirectory index file.
-  EXPECT_EQ("<h1>HTML sub_dir index</h1>",
-            HTTP(GET(Printf("http://localhost:%d/sub_dir/", port))).body);
-  EXPECT_EQ("<h1>HTML sub_dir index</h1>",
-            HTTP(GET(Printf("http://localhost:%d/sub_dir/index.htm", port))).body);
+  EXPECT_EQ("<h1>HTML sub_dir index</h1>", HTTP(GET(Printf("http://localhost:%d/sub_dir/", port))).body);
+  EXPECT_EQ("<h1>HTML sub_dir index</h1>", HTTP(GET(Printf("http://localhost:%d/sub_dir/index.htm", port))).body);
 
   // File in subdirectory.
-  EXPECT_EQ("alert('JavaScript')",
-            HTTP(GET(Printf("http://localhost:%d/sub_dir/file_in_sub_dir.js", port))).body);
+  EXPECT_EQ("alert('JavaScript')", HTTP(GET(Printf("http://localhost:%d/sub_dir/file_in_sub_dir.js", port))).body);
 
   // Trailing slash for files should result in HTTP 404.
-  EXPECT_EQ(DefaultNotFoundMessage(),
-            HTTP(GET(Printf("http://localhost:%d/index.html/", port))).body);
-  EXPECT_EQ(DefaultNotFoundMessage(),
-            HTTP(GET(Printf("http://localhost:%d/sub_dir/index.htm/", port))).body);
+  EXPECT_EQ(DefaultNotFoundMessage(), HTTP(GET(Printf("http://localhost:%d/index.html/", port))).body);
+  EXPECT_EQ(DefaultNotFoundMessage(), HTTP(GET(Printf("http://localhost:%d/sub_dir/index.htm/", port))).body);
 
   // Hidden files should result in HTTP 404.
   EXPECT_EQ(DefaultNotFoundMessage(), HTTP(GET(Printf("http://localhost:%d/.DS_Store", port))).body);
-  EXPECT_EQ(DefaultNotFoundMessage(),
-            HTTP(GET(Printf("http://localhost:%d/sub_dir/.file_hidden", port))).body);
+  EXPECT_EQ(DefaultNotFoundMessage(), HTTP(GET(Printf("http://localhost:%d/sub_dir/.file_hidden", port))).body);
 
   // Missing index file should result in HTTP 404.
-  EXPECT_EQ(DefaultNotFoundMessage(),
-            HTTP(GET(Printf("http://localhost:%d/sub_dir_no_index", port))).body);
-  EXPECT_EQ(DefaultNotFoundMessage(),
-            HTTP(GET(Printf("http://localhost:%d/sub_dir_no_index/", port))).body);
+  EXPECT_EQ(DefaultNotFoundMessage(), HTTP(GET(Printf("http://localhost:%d/sub_dir_no_index", port))).body);
+  EXPECT_EQ(DefaultNotFoundMessage(), HTTP(GET(Printf("http://localhost:%d/sub_dir_no_index/", port))).body);
 
   // Hidden directory should result in HTTP 404.
-  EXPECT_EQ(DefaultNotFoundMessage(),
-            HTTP(GET(Printf("http://localhost:%d/.sub_dir_hidden", port))).body);
-  EXPECT_EQ(DefaultNotFoundMessage(),
-            HTTP(GET(Printf("http://localhost:%d/.sub_dir_hidden/", port))).body);
-  EXPECT_EQ(DefaultNotFoundMessage(),
-            HTTP(GET(Printf("http://localhost:%d/.sub_dir_hidden/index.html", port))).body);
-  EXPECT_EQ(404,
-            static_cast<int>(HTTP(GET(Printf("http://localhost:%d/.sub_dir_hidden", port))).code));
-  EXPECT_EQ(
-      404,
-      static_cast<int>(
-          HTTP(POST(Printf("http://localhost:%d/.sub_dir_hidden/index.html", port), "")).code));
+  EXPECT_EQ(DefaultNotFoundMessage(), HTTP(GET(Printf("http://localhost:%d/.sub_dir_hidden", port))).body);
+  EXPECT_EQ(DefaultNotFoundMessage(), HTTP(GET(Printf("http://localhost:%d/.sub_dir_hidden/", port))).body);
+  EXPECT_EQ(DefaultNotFoundMessage(), HTTP(GET(Printf("http://localhost:%d/.sub_dir_hidden/index.html", port))).body);
+  EXPECT_EQ(404, static_cast<int>(HTTP(GET(Printf("http://localhost:%d/.sub_dir_hidden", port))).code));
+  EXPECT_EQ(404, static_cast<int>(HTTP(POST(Printf("http://localhost:%d/.sub_dir_hidden/index.html", port), "")).code));
 
   // POST to file URL.
-  EXPECT_EQ(DefaultMethodNotAllowedMessage(),
-            HTTP(POST(Printf("http://localhost:%d/file.html", port), "")).body);
-  EXPECT_EQ(405,
-            static_cast<int>(HTTP(POST(Printf("http://localhost:%d/file.html", port), "")).code));
+  EXPECT_EQ(DefaultMethodNotAllowedMessage(), HTTP(POST(Printf("http://localhost:%d/file.html", port), "")).body);
+  EXPECT_EQ(405, static_cast<int>(HTTP(POST(Printf("http://localhost:%d/file.html", port), "")).code));
 
   // PUT to file URL.
-  EXPECT_EQ(DefaultMethodNotAllowedMessage(),
-            HTTP(PUT(Printf("http://localhost:%d/file.html", port), "")).body);
-  EXPECT_EQ(405,
-            static_cast<int>(HTTP(PUT(Printf("http://localhost:%d/file.html", port), "")).code));
+  EXPECT_EQ(DefaultMethodNotAllowedMessage(), HTTP(PUT(Printf("http://localhost:%d/file.html", port), "")).body);
+  EXPECT_EQ(405, static_cast<int>(HTTP(PUT(Printf("http://localhost:%d/file.html", port), "")).code));
 
   // PATCH to file URL.
-  EXPECT_EQ(DefaultMethodNotAllowedMessage(),
-            HTTP(PATCH(Printf("http://localhost:%d/file.html", port), "")).body);
-  EXPECT_EQ(405,
-            static_cast<int>(HTTP(PATCH(Printf("http://localhost:%d/file.html", port), "")).code));
+  EXPECT_EQ(DefaultMethodNotAllowedMessage(), HTTP(PATCH(Printf("http://localhost:%d/file.html", port), "")).body);
+  EXPECT_EQ(405, static_cast<int>(HTTP(PATCH(Printf("http://localhost:%d/file.html", port), "")).code));
 
   // DELETE to file URL.
-  EXPECT_EQ(DefaultMethodNotAllowedMessage(),
-            HTTP(DELETE(Printf("http://localhost:%d/file.html", port))).body);
+  EXPECT_EQ(DefaultMethodNotAllowedMessage(), HTTP(DELETE(Printf("http://localhost:%d/file.html", port))).body);
   EXPECT_EQ(405, static_cast<int>(HTTP(DELETE(Printf("http://localhost:%d/file.html", port))).code));
 }
 
@@ -1628,25 +1488,19 @@ TEST(HTTPAPI, ServeStaticFilesFromOptionsCustomRoutePrefix) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope =
-      http_server.ServeStaticFilesFrom(dir, ServeStaticFilesFromOptions{"/static/something"});
+  const auto scope = http_server.ServeStaticFilesFrom(dir, ServeStaticFilesFromOptions{"/static/something"});
 
   // Root index file.
-  EXPECT_EQ("<h1>HTML index</h1>",
-            HTTP(GET(Printf("http://localhost:%d/static/something/", port))).body);
+  EXPECT_EQ("<h1>HTML index</h1>", HTTP(GET(Printf("http://localhost:%d/static/something/", port))).body);
 
   // Redirect from directory without trailing slash to directory with trailing slash.
   {
-    ASSERT_THROW(HTTP(GET(Printf("http://localhost:%d/static/something", port))),
-                 HTTPRedirectNotAllowedException);
-    const auto dir_response =
-        HTTP(GET(Printf("http://localhost:%d/static/something", port)).AllowRedirects());
+    ASSERT_THROW(HTTP(GET(Printf("http://localhost:%d/static/something", port))), HTTPRedirectNotAllowedException);
+    const auto dir_response = HTTP(GET(Printf("http://localhost:%d/static/something", port)).AllowRedirects());
     EXPECT_EQ(200, static_cast<int>(dir_response.code));
-    EXPECT_EQ((
-      port == 80
-        ? "http://localhost/static/something/"
-        : Printf("http://localhost:%d/static/something/", port)
-    ), dir_response.url);
+    EXPECT_EQ(
+        (port == 80 ? "http://localhost/static/something/" : Printf("http://localhost:%d/static/something/", port)),
+        dir_response.url);
     EXPECT_EQ("<h1>HTML index</h1>", dir_response.body);
   }
 
@@ -1661,31 +1515,26 @@ TEST(HTTPAPI, ServeStaticFilesFromOptionsCustomRoutePrefix) {
     const auto sub_dir_response =
         HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir", port)).AllowRedirects());
     EXPECT_EQ(200, static_cast<int>(sub_dir_response.code));
-    EXPECT_EQ((
-      port == 80
-        ? "http://localhost/static/something/sub_dir/"
-        : Printf("http://localhost:%d/static/something/sub_dir/", port)
-    ), sub_dir_response.url);
+    EXPECT_EQ((port == 80 ? "http://localhost/static/something/sub_dir/"
+                          : Printf("http://localhost:%d/static/something/sub_dir/", port)),
+              sub_dir_response.url);
     EXPECT_EQ("<h1>HTML sub_dir index</h1>", sub_dir_response.body);
   }
 
   // Subsubdirectory index file.
-  EXPECT_EQ(
-      "<h1>HTML sub_sub_dir index</h1>",
-      HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir/sub_sub_dir/", port))).body);
+  EXPECT_EQ("<h1>HTML sub_sub_dir index</h1>",
+            HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir/sub_sub_dir/", port))).body);
 
   // Redirect from subsubdirectory without trailing slash to subsubdirectory with trailing slash.
   {
     ASSERT_THROW(HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir/sub_sub_dir", port))),
                  HTTPRedirectNotAllowedException);
-    const auto sub_sub_dir_response = HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir/sub_sub_dir",
-                                                      port)).AllowRedirects());
+    const auto sub_sub_dir_response =
+        HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir/sub_sub_dir", port)).AllowRedirects());
     EXPECT_EQ(200, static_cast<int>(sub_sub_dir_response.code));
-    EXPECT_EQ((
-      port == 80
-        ? "http://localhost/static/something/sub_dir/sub_sub_dir/"
-        : Printf("http://localhost:%d/static/something/sub_dir/sub_sub_dir/", port)
-    ), sub_sub_dir_response.url);
+    EXPECT_EQ((port == 80 ? "http://localhost/static/something/sub_dir/sub_sub_dir/"
+                          : Printf("http://localhost:%d/static/something/sub_dir/sub_sub_dir/", port)),
+              sub_sub_dir_response.url);
     EXPECT_EQ("<h1>HTML sub_sub_dir index</h1>", sub_sub_dir_response.body);
   }
 }
@@ -1717,25 +1566,19 @@ TEST(HTTPAPI, ServeStaticFilesFromOptionsCustomRoutePrefixAndPublicUrlPrefixRela
   const auto scope_redirect_to =
       http_server.Register("/anything", URLPathArgs::CountMask::Any, [](Request r) { r("Done."); });
 
-  const auto scope = http_server
-                         .ServeStaticFilesFrom(dir, ServeStaticFilesFromOptions{"/static/something", "/anything"});
+  const auto scope =
+      http_server.ServeStaticFilesFrom(dir, ServeStaticFilesFromOptions{"/static/something", "/anything"});
 
   // Root index file.
-  EXPECT_EQ("<h1>HTML index</h1>",
-            HTTP(GET(Printf("http://localhost:%d/static/something/", port))).body);
+  EXPECT_EQ("<h1>HTML index</h1>", HTTP(GET(Printf("http://localhost:%d/static/something/", port))).body);
 
   // Redirect from directory without trailing slash to directory with trailing slash.
   {
-    ASSERT_THROW(HTTP(GET(Printf("http://localhost:%d/static/something", port))),
-                 HTTPRedirectNotAllowedException);
-    const auto dir_response =
-        HTTP(GET(Printf("http://localhost:%d/static/something", port)).AllowRedirects());
+    ASSERT_THROW(HTTP(GET(Printf("http://localhost:%d/static/something", port))), HTTPRedirectNotAllowedException);
+    const auto dir_response = HTTP(GET(Printf("http://localhost:%d/static/something", port)).AllowRedirects());
     EXPECT_EQ(200, static_cast<int>(dir_response.code));
-    EXPECT_EQ((
-      port == 80
-        ? "http://localhost/anything/"
-        : Printf("http://localhost:%d/anything/", port)
-    ), dir_response.url);
+    EXPECT_EQ((port == 80 ? "http://localhost/anything/" : Printf("http://localhost:%d/anything/", port)),
+              dir_response.url);
     EXPECT_EQ("Done.", dir_response.body);
   }
 
@@ -1750,31 +1593,26 @@ TEST(HTTPAPI, ServeStaticFilesFromOptionsCustomRoutePrefixAndPublicUrlPrefixRela
     const auto sub_dir_response =
         HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir", port)).AllowRedirects());
     EXPECT_EQ(200, static_cast<int>(sub_dir_response.code));
-    EXPECT_EQ((
-      port == 80
-        ? "http://localhost/anything/sub_dir/"
-        : Printf("http://localhost:%d/anything/sub_dir/", port)
-    ), sub_dir_response.url);
+    EXPECT_EQ(
+        (port == 80 ? "http://localhost/anything/sub_dir/" : Printf("http://localhost:%d/anything/sub_dir/", port)),
+        sub_dir_response.url);
     EXPECT_EQ("Done.", sub_dir_response.body);
   }
 
   // Subsubdirectory index file.
-  EXPECT_EQ(
-      "<h1>HTML sub_sub_dir index</h1>",
-      HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir/sub_sub_dir/", port))).body);
+  EXPECT_EQ("<h1>HTML sub_sub_dir index</h1>",
+            HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir/sub_sub_dir/", port))).body);
 
   // Redirect from subsubdirectory without trailing slash to subsubdirectory with trailing slash.
   {
     ASSERT_THROW(HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir/sub_sub_dir", port))),
                  HTTPRedirectNotAllowedException);
-    const auto sub_sub_dir_response = HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir/sub_sub_dir",
-                                                      port)).AllowRedirects());
+    const auto sub_sub_dir_response =
+        HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir/sub_sub_dir", port)).AllowRedirects());
     EXPECT_EQ(200, static_cast<int>(sub_sub_dir_response.code));
-    EXPECT_EQ((
-      port == 80
-        ? "http://localhost/anything/sub_dir/sub_sub_dir/"
-        : Printf("http://localhost:%d/anything/sub_dir/sub_sub_dir/", port)
-    ), sub_sub_dir_response.url);
+    EXPECT_EQ((port == 80 ? "http://localhost/anything/sub_dir/sub_sub_dir/"
+                          : Printf("http://localhost:%d/anything/sub_dir/sub_sub_dir/", port)),
+              sub_sub_dir_response.url);
     EXPECT_EQ("Done.", sub_sub_dir_response.body);
   }
 }
@@ -1809,29 +1647,19 @@ TEST(HTTPAPI, ServeStaticFilesFromOptionsCustomRoutePrefixAndPublicUrlPrefixAbso
   const auto scope_redirect_to =
       HTTP(std::move(second_reserved_port)).Register("/", URLPathArgs::CountMask::Any, [](Request r) { r("Done."); });
 
-  const auto scope =
-      http_server
-          .ServeStaticFilesFrom(
-              dir,
-              ServeStaticFilesFromOptions{"/static/something",
-                                          Printf("http://localhost:%d/anything", second_port)});
+  const auto scope = http_server.ServeStaticFilesFrom(
+      dir, ServeStaticFilesFromOptions{"/static/something", Printf("http://localhost:%d/anything", second_port)});
 
   // Root index file.
-  EXPECT_EQ("<h1>HTML index</h1>",
-            HTTP(GET(Printf("http://localhost:%d/static/something/", port))).body);
+  EXPECT_EQ("<h1>HTML index</h1>", HTTP(GET(Printf("http://localhost:%d/static/something/", port))).body);
 
   // Redirect from directory without trailing slash to directory with trailing slash.
   {
-    ASSERT_THROW(HTTP(GET(Printf("http://localhost:%d/static/something", port))),
-                 HTTPRedirectNotAllowedException);
-    const auto dir_response =
-        HTTP(GET(Printf("http://localhost:%d/static/something", port)).AllowRedirects());
+    ASSERT_THROW(HTTP(GET(Printf("http://localhost:%d/static/something", port))), HTTPRedirectNotAllowedException);
+    const auto dir_response = HTTP(GET(Printf("http://localhost:%d/static/something", port)).AllowRedirects());
     EXPECT_EQ(200, static_cast<int>(dir_response.code));
-    EXPECT_EQ((
-      second_port == 80
-        ? "http://localhost/anything/"
-        : Printf("http://localhost:%d/anything/", second_port)
-    ), dir_response.url);
+    EXPECT_EQ((second_port == 80 ? "http://localhost/anything/" : Printf("http://localhost:%d/anything/", second_port)),
+              dir_response.url);
     EXPECT_EQ("Done.", dir_response.body);
   }
 
@@ -1846,31 +1674,26 @@ TEST(HTTPAPI, ServeStaticFilesFromOptionsCustomRoutePrefixAndPublicUrlPrefixAbso
     const auto sub_dir_response =
         HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir", port)).AllowRedirects());
     EXPECT_EQ(200, static_cast<int>(sub_dir_response.code));
-    EXPECT_EQ((
-      second_port == 80
-        ? "http://localhost/anything/sub_dir/"
-        : Printf("http://localhost:%d/anything/sub_dir/", second_port)
-    ), sub_dir_response.url);
+    EXPECT_EQ((second_port == 80 ? "http://localhost/anything/sub_dir/"
+                                 : Printf("http://localhost:%d/anything/sub_dir/", second_port)),
+              sub_dir_response.url);
     EXPECT_EQ("Done.", sub_dir_response.body);
   }
 
   // Subsubdirectory index file.
-  EXPECT_EQ(
-      "<h1>HTML sub_sub_dir index</h1>",
-      HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir/sub_sub_dir/", port))).body);
+  EXPECT_EQ("<h1>HTML sub_sub_dir index</h1>",
+            HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir/sub_sub_dir/", port))).body);
 
   // Redirect from subsubdirectory without trailing slash to subsubdirectory with trailing slash.
   {
     ASSERT_THROW(HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir/sub_sub_dir", port))),
                  HTTPRedirectNotAllowedException);
-    const auto sub_sub_dir_response = HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir/sub_sub_dir",
-                                                      port)).AllowRedirects());
+    const auto sub_sub_dir_response =
+        HTTP(GET(Printf("http://localhost:%d/static/something/sub_dir/sub_sub_dir", port)).AllowRedirects());
     EXPECT_EQ(200, static_cast<int>(sub_sub_dir_response.code));
-    EXPECT_EQ((
-      second_port == 80
-        ? "http://localhost/anything/sub_dir/sub_sub_dir/"
-        : Printf("http://localhost:%d/anything/sub_dir/sub_sub_dir/", second_port)
-    ), sub_sub_dir_response.url);
+    EXPECT_EQ((second_port == 80 ? "http://localhost/anything/sub_dir/sub_sub_dir/"
+                                 : Printf("http://localhost:%d/anything/sub_dir/sub_sub_dir/", second_port)),
+              sub_sub_dir_response.url);
     EXPECT_EQ("Done.", sub_sub_dir_response.body);
   }
 }
@@ -1882,8 +1705,7 @@ TEST(HTTPAPI, ServeStaticFilesFromOptionsCustomRoutePrefixWithTrailingSlash) {
   auto& http_server = HTTP(std::move(reserved_port));
 
   const std::string dir = FileSystem::JoinPath(FLAGS_net_api_test_tmpdir, "static");
-  ASSERT_THROW(http_server.ServeStaticFilesFrom(dir, ServeStaticFilesFromOptions{"/static/"}),
-               PathEndsWithSlash);
+  ASSERT_THROW(http_server.ServeStaticFilesFrom(dir, ServeStaticFilesFromOptions{"/static/"}), PathEndsWithSlash);
 }
 
 TEST(HTTPAPI, ServeStaticFilesFromOptionsEmptyPublicRoutePrefix) {
@@ -1893,8 +1715,7 @@ TEST(HTTPAPI, ServeStaticFilesFromOptionsEmptyPublicRoutePrefix) {
   auto& http_server = HTTP(std::move(reserved_port));
 
   const std::string dir = FileSystem::JoinPath(FLAGS_net_api_test_tmpdir, "static");
-  ASSERT_THROW(http_server.ServeStaticFilesFrom(dir, ServeStaticFilesFromOptions{""}),
-               PathDoesNotStartWithSlash);
+  ASSERT_THROW(http_server.ServeStaticFilesFrom(dir, ServeStaticFilesFromOptions{""}), PathDoesNotStartWithSlash);
 }
 
 TEST(HTTPAPI, ServeStaticFilesFromOptionsCustomIndexFiles) {
@@ -1909,8 +1730,7 @@ TEST(HTTPAPI, ServeStaticFilesFromOptionsCustomIndexFiles) {
   const auto dir_remover = current::FileSystem::ScopedRmDir(dir);
   FileSystem::MkDir(dir, FileSystem::MkDirParameters::Silent);
   FileSystem::WriteStringToFile("TXT index", FileSystem::JoinPath(dir, "index.txt").c_str());
-  const auto scope =
-      http_server.ServeStaticFilesFrom(dir, ServeStaticFilesFromOptions{"/", "", {"index.txt"}});
+  const auto scope = http_server.ServeStaticFilesFrom(dir, ServeStaticFilesFromOptions{"/", "", {"index.txt"}});
   EXPECT_EQ("TXT index", HTTP(GET(Printf("http://localhost:%d/", port))).body);
   EXPECT_EQ("TXT index", HTTP(GET(Printf("http://localhost:%d/index.txt", port))).body);
 }
@@ -1927,8 +1747,7 @@ TEST(HTTPAPI, ServeStaticFilesFromOnlyServesOneIndexFilePerDirectory) {
   FileSystem::MkDir(dir, FileSystem::MkDirParameters::Silent);
   FileSystem::WriteStringToFile("<h1>HTML index 1</h1>", FileSystem::JoinPath(dir, "index.html").c_str());
   FileSystem::WriteStringToFile("<h1>HTML index 2</h1>", FileSystem::JoinPath(dir, "index.htm").c_str());
-  ASSERT_THROW(http_server.ServeStaticFilesFrom(dir),
-               ServeStaticFilesFromCannotServeMoreThanOneIndexFile);
+  ASSERT_THROW(http_server.ServeStaticFilesFrom(dir), ServeStaticFilesFromCannotServeMoreThanOneIndexFile);
 }
 
 TEST(HTTPAPI, ServeStaticFilesFromOnlyServesFilesOfKnownMIMEType) {
@@ -1943,8 +1762,7 @@ TEST(HTTPAPI, ServeStaticFilesFromOnlyServesFilesOfKnownMIMEType) {
   FileSystem::MkDir(dir, FileSystem::MkDirParameters::Silent);
   FileSystem::WriteStringToFile("TXT is okay.", FileSystem::JoinPath(dir, "file.txt").c_str());
   FileSystem::WriteStringToFile("FOO is not! ", FileSystem::JoinPath(dir, "file.foo").c_str());
-  ASSERT_THROW(http_server.ServeStaticFilesFrom(dir),
-               ServeStaticFilesFromCanNotServeStaticFilesOfUnknownMIMEType);
+  ASSERT_THROW(http_server.ServeStaticFilesFrom(dir), ServeStaticFilesFromCanNotServeStaticFilesOfUnknownMIMEType);
 }
 
 TEST(HTTPAPI, ResponseSmokeTest) {
@@ -1954,62 +1772,34 @@ TEST(HTTPAPI, ResponseSmokeTest) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope =
-      http_server
-          .Register("/response1", [send_response](Request r) { send_response(Response("foo"), std::move(r)); }) +
-      http_server
-          .Register(
-              "/response2",
-              [send_response](Request r) { send_response(Response("bar", HTTPResponseCode.Accepted), std::move(r)); }) +
-      http_server
-          .Register("/response3",
-                    [send_response](Request r) {
-                      send_response(Response("baz", HTTPResponseCode.NotFound, "text/blah"), std::move(r));
-                    }) +
-      http_server
-          .Register("/response4",
-                    [send_response](Request r) {
-                      send_response(Response(SerializableObject(), HTTPResponseCode.Accepted), std::move(r));
-                    }) +
-      http_server
-          .Register("/response5",
-                    [send_response](Request r) {
-                      send_response(Response(SerializableObject(), "meh").Code(HTTPResponseCode.Created), std::move(r));
-                    }) +
-      http_server
-          .Register("/response6",
-                    [send_response](Request r) {
-                      send_response(Response().Body("OK").Code(HTTPResponseCode.OK), std::move(r));
-                    }) +
-      http_server
-          .Register("/response7",
-                    [send_response](Request r) {
-                      send_response(Response().JSON(SerializableObject(), "magic").Code(HTTPResponseCode.OK),
-                                    std::move(r));
-                    }) +
-      http_server
-          .Register("/response8",
-                    [send_response](Request r) { send_response(Response(HTTPResponseCode.Created), std::move(r)); }) +
-      http_server
-          .Register("/response9",
-                    [send_response](Request r) {
-                      send_response(Response(), std::move(r));  // Will result in a 500 "INTERNAL SERVER ERROR".
-                    }) +
-      http_server
-          .Register("/response10",
-                    [](Request r) {
-                      SerializableVariant v;
-                      v.template Construct<SerializableObject>();
-                      r(v);
-                    }) +
-      http_server
-          .Register("/response11",
-                    [send_response](Request r) {
-                      // Test both a direct response (`Request::operator()`) and a response via `Respose`.
-                      SerializableVariant v;
-                      v.template Construct<SerializableObject>();
-                      send_response(v, std::move(r));
-                    });
+  const auto scope = http_server.Register("/response1", [send_response](Request r) {
+    send_response(Response("foo"), std::move(r));
+  }) + http_server.Register("/response2", [send_response](Request r) {
+    send_response(Response("bar", HTTPResponseCode.Accepted), std::move(r));
+  }) + http_server.Register("/response3", [send_response](Request r) {
+    send_response(Response("baz", HTTPResponseCode.NotFound, "text/blah"), std::move(r));
+  }) + http_server.Register("/response4", [send_response](Request r) {
+    send_response(Response(SerializableObject(), HTTPResponseCode.Accepted), std::move(r));
+  }) + http_server.Register("/response5", [send_response](Request r) {
+    send_response(Response(SerializableObject(), "meh").Code(HTTPResponseCode.Created), std::move(r));
+  }) + http_server.Register("/response6", [send_response](Request r) {
+    send_response(Response().Body("OK").Code(HTTPResponseCode.OK), std::move(r));
+  }) + http_server.Register("/response7", [send_response](Request r) {
+    send_response(Response().JSON(SerializableObject(), "magic").Code(HTTPResponseCode.OK), std::move(r));
+  }) + http_server.Register("/response8", [send_response](Request r) {
+    send_response(Response(HTTPResponseCode.Created), std::move(r));
+  }) + http_server.Register("/response9", [send_response](Request r) {
+    send_response(Response(), std::move(r));  // Will result in a 500 "INTERNAL SERVER ERROR".
+  }) + http_server.Register("/response10", [](Request r) {
+    SerializableVariant v;
+    v.template Construct<SerializableObject>();
+    r(v);
+  }) + http_server.Register("/response11", [send_response](Request r) {
+    // Test both a direct response (`Request::operator()`) and a response via `Respose`.
+    SerializableVariant v;
+    v.template Construct<SerializableObject>();
+    send_response(v, std::move(r));
+  });
 
   const auto response1 = HTTP(GET(Printf("http://localhost:%d/response1", port)));
   EXPECT_EQ(200, static_cast<int>(response1.code));
@@ -2068,20 +1858,17 @@ TEST(HTTPAPI, PayloadTooLarge) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope = http_server
-                         .Register("/enough_is_enough",
-                                   [](Request r) {
-                                     ASSERT_FALSE(r.body.empty());
-                                     EXPECT_EQ("POST", r.method);
-                                     r("Fits.\n");
-                                   });
+  const auto scope = http_server.Register("/enough_is_enough", [](Request r) {
+    ASSERT_FALSE(r.body.empty());
+    EXPECT_EQ("POST", r.method);
+    r("Fits.\n");
+  });
 
   {
     const size_t size_ok = 16 * 1024 * 1024;
     ASSERT_EQ(current::net::constants::kMaxHTTPPayloadSizeInBytes, size_ok);
 
-    const auto response =
-        HTTP(POST(Printf("http://localhost:%d/enough_is_enough", port), std::string(size_ok, '.')));
+    const auto response = HTTP(POST(Printf("http://localhost:%d/enough_is_enough", port), std::string(size_ok, '.')));
     EXPECT_EQ(200, static_cast<int>(response.code));
     EXPECT_EQ("Fits.\n", response.body);
   }
@@ -2089,8 +1876,8 @@ TEST(HTTPAPI, PayloadTooLarge) {
     const size_t size_too_much = 16 * 1024 * 1024 + 1;
     ASSERT_GT(size_too_much, current::net::constants::kMaxHTTPPayloadSizeInBytes);
 
-    const auto response = HTTP(
-        POST(Printf("http://localhost:%d/enough_is_enough", port), std::string(size_too_much, '.')));
+    const auto response =
+        HTTP(POST(Printf("http://localhost:%d/enough_is_enough", port), std::string(size_too_much, '.')));
     EXPECT_EQ(413, static_cast<int>(response.code));
     EXPECT_EQ("<h1>ENTITY TOO LARGE</h1>\n", response.body);
   }
@@ -2108,23 +1895,18 @@ TEST(HTTPAPI, ResponseGeneratorForSerializableAndNonSerializableTypes) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  const auto scope =
-      http_server
-          .Register(
-              "/maybe_json",
-              [](Request r) {
-                if (r.url.query.has("json")) {
-                  static_assert(current::serialization::json::IsJSONSerializable<HTTPAPITestObject>::value, "");
-                  r(current::http::GenerateResponseFromMaybeSerializableObject<
-                      HTTPAPITemplatedTestObject<HTTPAPITestObject>>(HTTPAPITemplatedTestObject<HTTPAPITestObject>()));
-                } else {
-                  static_assert(!current::serialization::json::IsJSONSerializable<HTTPAPINonSerializableObject>::value,
-                                "");
-                  r(current::http::GenerateResponseFromMaybeSerializableObject<
-                      HTTPAPITemplatedTestObject<HTTPAPINonSerializableObject>>(
-                      HTTPAPITemplatedTestObject<HTTPAPINonSerializableObject>()));
-                }
-              });
+  const auto scope = http_server.Register("/maybe_json", [](Request r) {
+    if (r.url.query.has("json")) {
+      static_assert(current::serialization::json::IsJSONSerializable<HTTPAPITestObject>::value, "");
+      r(current::http::GenerateResponseFromMaybeSerializableObject<HTTPAPITemplatedTestObject<HTTPAPITestObject>>(
+          HTTPAPITemplatedTestObject<HTTPAPITestObject>()));
+    } else {
+      static_assert(!current::serialization::json::IsJSONSerializable<HTTPAPINonSerializableObject>::value, "");
+      r(current::http::GenerateResponseFromMaybeSerializableObject<
+          HTTPAPITemplatedTestObject<HTTPAPINonSerializableObject>>(
+          HTTPAPITemplatedTestObject<HTTPAPINonSerializableObject>()));
+    }
+  });
   {
     const auto response = HTTP(GET(Printf("http://localhost:%d/maybe_json?json", port)));
     EXPECT_EQ("{\"text\":\"OK\",\"data\":{\"number\":42,\"text\":\"text\",\"array\":[1,2,3]}}\n", response.body);
@@ -2178,8 +1960,7 @@ TEST(HTTPAPI, JSONDoesHaveCORSHeaderByDefault) {
   auto& http_server = HTTP(std::move(reserved_port));
 
   {
-    const auto scope =
-        http_server.Register("/json1", [](Request r) { r(Response(SerializableObject())); });
+    const auto scope = http_server.Register("/json1", [](Request r) { r(Response(SerializableObject())); });
 
     const auto response = HTTP(GET(Printf("http://localhost:%d/json1", port)));
     EXPECT_EQ(200, static_cast<int>(response.code));
@@ -2188,9 +1969,8 @@ TEST(HTTPAPI, JSONDoesHaveCORSHeaderByDefault) {
     EXPECT_EQ("*", response.headers.Get("Access-Control-Allow-Origin"));
   }
   {
-    const auto scope = http_server.Register("/json2", [](Request r) {
-      r(Response(SerializableObject()).DisableCORS());
-    });
+    const auto scope =
+        http_server.Register("/json2", [](Request r) { r(Response(SerializableObject()).DisableCORS()); });
 
     const auto response = HTTP(GET(Printf("http://localhost:%d/json2", port)));
     EXPECT_EQ(200, static_cast<int>(response.code));
@@ -2198,9 +1978,8 @@ TEST(HTTPAPI, JSONDoesHaveCORSHeaderByDefault) {
     EXPECT_FALSE(response.headers.Has("Access-Control-Allow-Origin"));
   }
   {
-    const auto scope = http_server.Register("/json3", [](Request r) {
-      r(Response(SerializableObject()).DisableCORS().EnableCORS());
-    });
+    const auto scope =
+        http_server.Register("/json3", [](Request r) { r(Response(SerializableObject()).DisableCORS().EnableCORS()); });
 
     const auto response = HTTP(GET(Printf("http://localhost:%d/json3", port)));
     EXPECT_EQ(200, static_cast<int>(response.code));
diff --git a/blocks/http/types.h b/blocks/http/types.h
index f6dc9ac7f..2ea97d2c4 100644
--- a/blocks/http/types.h
+++ b/blocks/http/types.h
@@ -103,15 +103,16 @@ struct ChunkedBase {
   std::function<void()> done_callback_impl;
 
   explicit ChunkedBase(std::string url)
-    : url(std::move(url)),
-      header_callback([this](const std::string& k, const std::string& v) { header_callback_wrapper(k, v); }),
-      chunk_callback([this](const std::string& c) { chunk_callback_wrapper(c); }),
-      done_callback([this]() { done_callback_wrapper(); }) {}
-
-  explicit ChunkedBase(std::string url,
-                       std::function<void(const std::string&, const std::string&)> header_callback,
-                       std::function<void(const std::string&)> chunk_callback,
-                       std::function<void()> done_callback = []() {})
+      : url(std::move(url)),
+        header_callback([this](const std::string& k, const std::string& v) { header_callback_wrapper(k, v); }),
+        chunk_callback([this](const std::string& c) { chunk_callback_wrapper(c); }),
+        done_callback([this]() { done_callback_wrapper(); }) {}
+
+  explicit ChunkedBase(
+      std::string url,
+      std::function<void(const std::string&, const std::string&)> header_callback,
+      std::function<void(const std::string&)> chunk_callback,
+      std::function<void()> done_callback = []() {})
       : ChunkedBase(std::move(url)) {
     header_callback_impl = header_callback;
     chunk_callback_impl = chunk_callback;
@@ -135,7 +136,7 @@ struct ChunkedBase {
   // TODO(dkorolev): Move this to `Chunk`-s if performance becomes the bottleneck.
   T& OnLine(std::function<void(const std::string&)> line_callback) {
     group_by_lines_.emplace_back(std::make_unique<current::strings::StatefulGroupByLines>(
-          [line_callback](const std::string& line) { line_callback(line); }));
+        [line_callback](const std::string& line) { line_callback(line); }));
     return static_cast<T&>(*this);
   }
 
@@ -168,12 +169,13 @@ struct ChunkedGET final : ChunkedBase<ChunkedGET> {
 struct ChunkedPOST final : ChunkedBase<ChunkedPOST> {
   const std::string body;
   const std::string content_type;
-  explicit ChunkedPOST(std::string url,
-                       std::string body,
-                       std::string content_type,
-                       std::function<void(const std::string&, const std::string&)> header_callback,
-                       std::function<void(const std::string&)> chunk_callback,
-                       std::function<void()> done_callback = []() {})
+  explicit ChunkedPOST(
+      std::string url,
+      std::string body,
+      std::string content_type,
+      std::function<void(const std::string&, const std::string&)> header_callback,
+      std::function<void(const std::string&)> chunk_callback,
+      std::function<void()> done_callback = []() {})
       : ChunkedBase(std::move(url), header_callback, chunk_callback, done_callback),
         body(std::move(body)),
         content_type(std::move(content_type)) {}
@@ -202,8 +204,9 @@ struct FillBody<REQUEST, true> {
 template <typename REQUEST>
 struct FillBody<REQUEST, false> {
   template <typename T>
-  static std::enable_if_t<IS_CURRENT_STRUCT_OR_VARIANT(current::decay_t<T>)> Fill(
-      REQUEST& request, T&& object, const std::string& content_type) {
+  static std::enable_if_t<IS_CURRENT_STRUCT_OR_VARIANT(current::decay_t<T>)> Fill(REQUEST& request,
+                                                                                  T&& object,
+                                                                                  const std::string& content_type) {
     request.body = JSON(std::forward<T>(object));
     request.content_type = !content_type.empty() ? content_type : net::constants::kDefaultJSONContentType;
   }
@@ -214,8 +217,7 @@ struct POST : HTTPRequestBase<POST> {
   std::string content_type;
 
   template <typename T>
-  POST(const std::string& url, T&& body, const std::string& content_type = "")
-      : HTTPRequestBase(url) {
+  POST(const std::string& url, T&& body, const std::string& content_type = "") : HTTPRequestBase(url) {
     FillBody<POST, current::strings::is_string_type<T>::value>::Fill(*this, std::forward<T>(body), content_type);
   }
 };
@@ -233,8 +235,7 @@ struct PUT : HTTPRequestBase<PUT> {
   std::string content_type;
 
   template <typename T>
-  PUT(const std::string& url, T&& body, const std::string& content_type = "")
-      : HTTPRequestBase(url) {
+  PUT(const std::string& url, T&& body, const std::string& content_type = "") : HTTPRequestBase(url) {
     FillBody<PUT, current::strings::is_string_type<T>::value>::Fill(*this, std::forward<T>(body), content_type);
   }
 };
@@ -244,8 +245,7 @@ struct PATCH : HTTPRequestBase<PATCH> {
   std::string content_type;
 
   template <typename T>
-  PATCH(const std::string& url, T&& body, const std::string& content_type = "")
-      : HTTPRequestBase(url) {
+  PATCH(const std::string& url, T&& body, const std::string& content_type = "") : HTTPRequestBase(url) {
     FillBody<PATCH, current::strings::is_string_type<T>::value>::Fill(*this, std::forward<T>(body), content_type);
   }
 };
@@ -398,13 +398,13 @@ struct HTTPImpl {
 }  // namespace http
 }  // namespace current
 
+using current::http::DELETE;
 using current::http::GET;
 using current::http::HEAD;
+using current::http::PATCH;
 using current::http::POST;
 using current::http::POSTFromFile;
 using current::http::PUT;
-using current::http::PATCH;
-using current::http::DELETE;
 
 using current::http::ChunkedGET;
 using current::http::ChunkedPOST;
diff --git a/blocks/json/json.h b/blocks/json/json.h
index c282c9aec..6ad0f55fd 100644
--- a/blocks/json/json.h
+++ b/blocks/json/json.h
@@ -75,14 +75,14 @@ CURRENT_STRUCT(JSONString) {
   CURRENT_FIELD(string, std::string);
   CURRENT_CONSTRUCTOR(JSONString)(std::string string = "") : string(std::move(string)) {}
   operator std::string() const { return string; }
-  void DoAppendToJSON(std::ostream& os) const { os << JSON(string); }
+  void DoAppendToJSON(std::ostream & os) const { os << JSON(string); }
 };
 
 CURRENT_STRUCT(JSONNumber) {
   CURRENT_FIELD(number, double);
   CURRENT_CONSTRUCTOR(JSONNumber)(double number = 0) : number(number) {}
   operator double() const { return number; }
-  void DoAppendToJSON(std::ostream& os) const {
+  void DoAppendToJSON(std::ostream & os) const {
     if (number == std::floor(number)) {
       if (number < 0) {
         os << JSON(static_cast<int64_t>(number));
@@ -99,7 +99,7 @@ CURRENT_STRUCT(JSONBoolean) {
   CURRENT_FIELD(boolean, bool);
   CURRENT_CONSTRUCTOR(JSONBoolean)(bool boolean = false) : boolean(boolean) {}
   operator bool() const { return boolean; }
-  void DoAppendToJSON(std::ostream& os) const { os << JSON(boolean); }
+  void DoAppendToJSON(std::ostream & os) const { os << JSON(boolean); }
 };
 
 // clang-format off
@@ -119,7 +119,7 @@ CURRENT_STRUCT(JSONArray) {
     static JSONValue null((JSONNull()));
     return i < elements.size() ? elements[i] : null;
   }
-  void DoAppendToJSON(std::ostream& os) const {
+  void DoAppendToJSON(std::ostream & os) const {
     os << '[';
     bool first = true;
     for (const JSONValue& element : elements) {
@@ -133,19 +133,11 @@ CURRENT_STRUCT(JSONArray) {
     os << ']';
   }
   using iterator = typename std::vector<JSONValue>::iterator;
-  iterator begin() {
-    return elements.begin();
-  }
-  iterator end() {
-    return elements.end();
-  }
+  iterator begin() { return elements.begin(); }
+  iterator end() { return elements.end(); }
   using const_iterator = typename std::vector<JSONValue>::const_iterator;
-  const_iterator begin() const {
-    return elements.begin();
-  }
-  const_iterator end() const {
-    return elements.end();
-  }
+  const_iterator begin() const { return elements.begin(); }
+  const_iterator end() const { return elements.end(); }
 };
 
 CURRENT_STRUCT(JSONObject) {
@@ -176,7 +168,7 @@ CURRENT_STRUCT(JSONObject) {
     fields.erase(name);
     return *this;
   }
-  void DoAppendToJSON(std::ostream& os) const {
+  void DoAppendToJSON(std::ostream & os) const {
     os << '{';
     bool first = true;
     for (const std::string& key : keys) {
@@ -201,19 +193,11 @@ CURRENT_STRUCT(JSONObject) {
     const_iterator(const JSONObject& self, std::vector<std::string>::const_iterator cit) : self(self), cit(cit) {}
     bool operator==(const const_iterator& rhs) const { return cit == rhs.cit; }
     bool operator!=(const const_iterator& rhs) const { return cit != rhs.cit; }
-    const_element operator*() const {
-      return const_element(*cit, self.fields.at(*cit));
-    }
-    void operator++() {
-      ++cit;
-    }
+    const_element operator*() const { return const_element(*cit, self.fields.at(*cit)); }
+    void operator++() { ++cit; }
   };
-  const_iterator begin() const {
-    return const_iterator(*this, keys.begin());
-  }
-  const_iterator end() const {
-    return const_iterator(*this, keys.end());
-  }
+  const_iterator begin() const { return const_iterator(*this, keys.begin()); }
+  const_iterator end() const { return const_iterator(*this, keys.end()); }
 };
 
 inline JSONValue ParseJSONUniversally(rapidjson::Value& value) {
diff --git a/blocks/json/test.cc b/blocks/json/test.cc
index b1eb76b3e..8402b8e52 100644
--- a/blocks/json/test.cc
+++ b/blocks/json/test.cc
@@ -121,9 +121,8 @@ TEST(UniversalJSON, Object) {
 
   using JO = JSONObject;
   using JN = JSONNumber;
-  EXPECT_EQ(
-      "{\"x\":42,\"y\":{\"a\":1,\"b\":2}}",
-      AsJSON(JO().push_back("x", JN(42)).push_back("y", JO().push_back("a", JN(1)).push_back("b", JN(2)))));
+  EXPECT_EQ("{\"x\":42,\"y\":{\"a\":1,\"b\":2}}",
+            AsJSON(JO().push_back("x", JN(42)).push_back("y", JO().push_back("a", JN(1)).push_back("b", JN(2)))));
 }
 
 TEST(UniversalJSON, FloatingPoint) {
diff --git a/blocks/mmq/mmpq.h b/blocks/mmq/mmpq.h
index 395110460..879ff749f 100644
--- a/blocks/mmq/mmpq.h
+++ b/blocks/mmq/mmpq.h
@@ -108,11 +108,9 @@ class MMPQImpl {
     while (true) {
       std::unique_lock<std::mutex> lock(mutex_);
 
-      condition_variable_.wait(lock,
-                               [this] {
-                                 return (!queue_.empty() && queue_.begin()->index_timestamp.us <= last_idx_ts_.us) ||
-                                        destructing_;
-                               });
+      condition_variable_.wait(lock, [this] {
+        return (!queue_.empty() && queue_.begin()->index_timestamp.us <= last_idx_ts_.us) || destructing_;
+      });
 
       if (destructing_) {
         return;  // LCOV_EXCL_LINE
diff --git a/blocks/mmq/test.cc b/blocks/mmq/test.cc
index 109e9129d..7d79e58c3 100644
--- a/blocks/mmq/test.cc
+++ b/blocks/mmq/test.cc
@@ -37,8 +37,8 @@ SOFTWARE.
 
 #include "../../3rdparty/gtest/gtest-main.h"
 
-using current::mmq::MMQ;
 using current::mmq::MMPQ;
+using current::mmq::MMQ;
 using current::ss::EntryResponse;
 
 TEST(InMemoryMQ, SmokeTest) {
diff --git a/blocks/persistence/exceptions.h b/blocks/persistence/exceptions.h
index 3cd59cc84..d27d3a563 100644
--- a/blocks/persistence/exceptions.h
+++ b/blocks/persistence/exceptions.h
@@ -70,7 +70,7 @@ struct UnsafePublishBadIndexTimestampException : PersistenceException {
             "Expecting index %lld, seeing %lld.", static_cast<long long>(expected), static_cast<long long>(found))) {}
 };
 
-}  // namespace peristence
+}  // namespace persistence
 }  // namespace current
 
 #endif  // BLOCKS_PERSISTENCE_EXCEPTIONS_H
diff --git a/blocks/persistence/file.h b/blocks/persistence/file.h
index b971a39bd..f74387d41 100644
--- a/blocks/persistence/file.h
+++ b/blocks/persistence/file.h
@@ -61,7 +61,7 @@ constexpr char kDirectiveMarker = '#';
 constexpr char kSignatureDirective[] = "#signature";
 constexpr char kHeadDirective[] = "#head";
 constexpr char kHeadFormatString[] = "%020lld";
-}  // namespace current::persistence::impl::constants
+}  // namespace constants
 
 typedef int64_t head_value_t;
 
@@ -460,7 +460,8 @@ class FilePersister {
     // would be serialized in an unwrapped way when passed directly.
     file_persister_impl_->file_appender_ << JSON(idxts) << '\t'
                                          << JSON(MakeSureTheRightTypeIsSerialized<ENTRY, decay_t<E>>::DoIt(
-                                                std::forward<E>(entry))) << std::endl;
+                                                std::forward<E>(entry)))
+                                         << std::endl;
     ++iterator.next_index;
     file_persister_impl_->head_offset_ = 0;
     file_persister_impl_->end_.store(iterator);
@@ -630,7 +631,10 @@ class FilePersister {
     // ">" is OK, as this call is multithreading-friendly, and more entries could have been added during this call.
     CURRENT_ASSERT(file_persister_impl_->record_offset_.size() >= current_size);
 
-    return ITERABLE(file_persister_impl_, static_cast<size_t>(begin_index), static_cast<size_t>(end_index), file_persister_impl_->record_offset_[static_cast<size_t>(begin_index)]);
+    return ITERABLE(file_persister_impl_,
+                    static_cast<size_t>(begin_index),
+                    static_cast<size_t>(end_index),
+                    file_persister_impl_->record_offset_[static_cast<size_t>(begin_index)]);
   }
 
   template <current::locks::MutexLockStatus MLS, typename ITERABLE>
@@ -651,12 +655,12 @@ class FilePersister {
   Owned<FilePersisterImpl> file_persister_impl_;  // `Owned`, as iterators borrow it.
 };
 
-}  // namespace current::persistence::impl
+}  // namespace impl
 
 template <typename ENTRY>
 using File = ss::EntryPersister<impl::FilePersister<ENTRY>, ENTRY>;
 
-}  // namespace current::persistence
+}  // namespace persistence
 }  // namespace current
 
 #endif  // BLOCKS_PERSISTENCE_FILE_H
diff --git a/blocks/persistence/memory.h b/blocks/persistence/memory.h
index 735a58619..a7c45fa4f 100644
--- a/blocks/persistence/memory.h
+++ b/blocks/persistence/memory.h
@@ -334,12 +334,12 @@ class MemoryPersister {
   Owned<Container> container_;  // `Owned`, as iterators borrow it.
 };
 
-}  // namespace current::persistence::impl
+}  // namespace impl
 
 template <typename ENTRY>
 using Memory = ss::EntryPersister<impl::MemoryPersister<ENTRY>, ENTRY>;
 
-}  // namespace current::persistence
+}  // namespace persistence
 }  // namespace current
 
 #endif  // BLOCKS_PERSISTENCE_MEMORY_H
diff --git a/blocks/persistence/test.cc b/blocks/persistence/test.cc
index e781c1bda..9e19dde81 100644
--- a/blocks/persistence/test.cc
+++ b/blocks/persistence/test.cc
@@ -845,21 +845,18 @@ void IteratorPerformanceTest(IMPL& impl, bool publish = true) {
     EXPECT_EQ(10ull, (*impl.Iterate(10, 11).begin()).idx_ts.index);
     EXPECT_EQ(10000ll, (*impl.Iterate(10, 11).begin()).idx_ts.us.count());
     EXPECT_EQ("0000010 kkkkkk", (*impl.Iterate(10, 11).begin()).entry.s);
-    EXPECT_EQ("{\"index\":10,\"us\":10000}\t{\"s\":\"0000010 kkkkkk\"}",
-              (*impl.IterateUnsafe(10, 11).begin()));
+    EXPECT_EQ("{\"index\":10,\"us\":10000}\t{\"s\":\"0000010 kkkkkk\"}", (*impl.IterateUnsafe(10, 11).begin()));
     EXPECT_EQ(100ull, (*impl.Iterate(100, 101).begin()).idx_ts.index);
     EXPECT_EQ(100000ll, (*impl.Iterate(100, 101).begin()).idx_ts.us.count());
     EXPECT_EQ("0000100 wwwww", (*impl.Iterate(100, 101).begin()).entry.s);
-    EXPECT_EQ("{\"index\":100,\"us\":100000}\t{\"s\":\"0000100 wwwww\"}",
-              (*impl.IterateUnsafe(100, 101).begin()));
+    EXPECT_EQ("{\"index\":100,\"us\":100000}\t{\"s\":\"0000100 wwwww\"}", (*impl.IterateUnsafe(100, 101).begin()));
   }
   {
     // By timestamp.
     EXPECT_EQ(0ull, (*impl.Iterate(us_t(0), us_t(1000)).begin()).idx_ts.index);
     EXPECT_EQ(0ll, (*impl.Iterate(us_t(0), us_t(1000)).begin()).idx_ts.us.count());
     EXPECT_EQ("0000000 aaa", (*impl.Iterate(us_t(0), us_t(1000)).begin()).entry.s);
-    EXPECT_EQ("{\"index\":0,\"us\":0}\t{\"s\":\"0000000 aaa\"}",
-              (*impl.IterateUnsafe(us_t(0), us_t(1000)).begin()));
+    EXPECT_EQ("{\"index\":0,\"us\":0}\t{\"s\":\"0000000 aaa\"}", (*impl.IterateUnsafe(us_t(0), us_t(1000)).begin()));
     EXPECT_EQ(10ull, (*impl.Iterate(us_t(10000), us_t(11000)).begin()).idx_ts.index);
     EXPECT_EQ(10000ll, (*impl.Iterate(us_t(10000), us_t(11000)).begin()).idx_ts.us.count());
     EXPECT_EQ("0000010 kkkkkk", (*impl.Iterate(us_t(10000), us_t(11000)).begin()).entry.s);
@@ -990,10 +987,10 @@ TEST(PersistenceLayer, FileIteratorCanNotOutliveFile) {
 TEST(PersistenceLayer, Exceptions) {
   using namespace persistence_test;
   using IMPL = current::persistence::File<StorableString>;
-  using current::ss::IndexAndTimestamp;
-  using current::ss::InconsistentTimestampException;
-  using current::ss::InconsistentIndexException;
   using current::persistence::MalformedEntryException;
+  using current::ss::InconsistentIndexException;
+  using current::ss::InconsistentTimestampException;
+  using current::ss::IndexAndTimestamp;
 
   const auto namespace_name = current::ss::StreamNamespaceName("namespace", "entry_name");
   const std::string persistence_file_name = current::FileSystem::JoinPath(FLAGS_persistence_test_tmpdir, "data");
diff --git a/blocks/self_modifying_config/test.cc b/blocks/self_modifying_config/test.cc
index bc8fdc62b..a1ab04c31 100644
--- a/blocks/self_modifying_config/test.cc
+++ b/blocks/self_modifying_config/test.cc
@@ -88,8 +88,9 @@ TEST(SelfModifyingConfig, ReadFileException) {
   current::time::SetNow(
       current::IMFFixDateTimeStringToTimestamp("Tue, 16 Aug 1983 00:00:00 GMT"));  // I was born. -- D.K.
 
-  ASSERT_THROW(static_cast<void>(std::make_unique<current::SelfModifyingConfig<UnitTestSelfModifyingConfig>>(config_filename)),
-               current::SelfModifyingConfigReadFileException);
+  ASSERT_THROW(
+      static_cast<void>(std::make_unique<current::SelfModifyingConfig<UnitTestSelfModifyingConfig>>(config_filename)),
+      current::SelfModifyingConfigReadFileException);
   try {
     static_cast<void>(std::make_unique<current::SelfModifyingConfig<UnitTestSelfModifyingConfig>>(config_filename));
   } catch (const current::SelfModifyingConfigReadFileException& e) {
@@ -115,8 +116,9 @@ TEST(SelfModifyingConfig, ParseJSONException) {
 
   current::FileSystem::WriteStringToFile("De Louboutin.", config_filename.c_str());
 
-  ASSERT_THROW(static_cast<void>(std::make_unique<current::SelfModifyingConfig<UnitTestSelfModifyingConfig>>(config_filename)),
-               current::SelfModifyingConfigParseJSONException);
+  ASSERT_THROW(
+      static_cast<void>(std::make_unique<current::SelfModifyingConfig<UnitTestSelfModifyingConfig>>(config_filename)),
+      current::SelfModifyingConfigParseJSONException);
   try {
     static_cast<void>(std::make_unique<current::SelfModifyingConfig<UnitTestSelfModifyingConfig>>(config_filename));
   } catch (const current::SelfModifyingConfigParseJSONException& e) {
@@ -144,8 +146,9 @@ TEST(SelfModifyingConfig, WriteFileException) {
 
   current::FileSystem::WriteStringToFile(JSON(UnitTestSelfModifyingConfig(4)), config_filename.c_str());
 
-  ASSERT_THROW(static_cast<void>(std::make_unique<current::SelfModifyingConfig<UnitTestSelfModifyingConfig>>(config_filename)),
-               current::SelfModifyingConfigWriteFileException);
+  ASSERT_THROW(
+      static_cast<void>(std::make_unique<current::SelfModifyingConfig<UnitTestSelfModifyingConfig>>(config_filename)),
+      current::SelfModifyingConfigWriteFileException);
   try {
     static_cast<void>(std::make_unique<current::SelfModifyingConfig<UnitTestSelfModifyingConfig>>(config_filename));
   } catch (const current::SelfModifyingConfigWriteFileException& e) {
diff --git a/blocks/ss/exceptions.h b/blocks/ss/exceptions.h
index a05da964e..e17bd587d 100644
--- a/blocks/ss/exceptions.h
+++ b/blocks/ss/exceptions.h
@@ -52,7 +52,7 @@ struct InconsistentTimestampException : InconsistentIndexOrTimestampException {
                                                                        static_cast<long long>(found.count()))) {}
 };
 
-}  // namespace current::ss
+}  // namespace ss
 }  // namespace current
 
 #endif  // BLOCKS_SS_EXCEPTIONS_H
diff --git a/blocks/ss/idx_ts.h b/blocks/ss/idx_ts.h
index 9a9773100..ac87258bc 100644
--- a/blocks/ss/idx_ts.h
+++ b/blocks/ss/idx_ts.h
@@ -81,12 +81,12 @@ CURRENT_STRUCT(HeadAndOptionalIndexAndTimestamp) {
   CURRENT_USE_FIELD_AS_TIMESTAMP(head);
   CURRENT_DEFAULT_CONSTRUCTOR(HeadAndOptionalIndexAndTimestamp) : head(0) {}
   CURRENT_CONSTRUCTOR(HeadAndOptionalIndexAndTimestamp)(std::chrono::microseconds head) : head(head) {}
-  CURRENT_CONSTRUCTOR(HeadAndOptionalIndexAndTimestamp)(std::chrono::microseconds head, IndexAndTimestamp idxts)
-      : head(head), idxts(idxts) {
+  CURRENT_CONSTRUCTOR(HeadAndOptionalIndexAndTimestamp)
+  (std::chrono::microseconds head, IndexAndTimestamp idxts) : head(head), idxts(idxts) {
     CURRENT_ASSERT(head >= idxts.us);
   }
-  CURRENT_CONSTRUCTOR(HeadAndOptionalIndexAndTimestamp)(
-      std::chrono::microseconds head, uint64_t index, std::chrono::microseconds us)
+  CURRENT_CONSTRUCTOR(HeadAndOptionalIndexAndTimestamp)
+  (std::chrono::microseconds head, uint64_t index, std::chrono::microseconds us)
       : head(head), idxts(IndexAndTimestamp(index, us)) {
 #ifndef CURRENT_BUILD_WITH_PARANOIC_RUNTIME_CHECKS
     CURRENT_ASSERT(head >= us);
@@ -99,7 +99,7 @@ CURRENT_STRUCT(HeadAndOptionalIndexAndTimestamp) {
   }
 };
 
-}  // namespace current::ss
+}  // namespace ss
 }  // namespace current
 
 using idxts_t = current::ss::IndexAndTimestamp;
diff --git a/blocks/ss/persister.h b/blocks/ss/persister.h
index f1610abdc..4eb4a69c6 100644
--- a/blocks/ss/persister.h
+++ b/blocks/ss/persister.h
@@ -53,8 +53,7 @@ class EntryPersister : public GenericEntryPersister<ENTRY>, public IMPL {
   using IterableRangeUnsafe = typename IMPL::IterableRangeUnsafe;
 
   template <typename... ARGS>
-  explicit EntryPersister(std::mutex& mutex, ARGS&&... args)
-      : IMPL(mutex, std::forward<ARGS>(args)...) {}
+  explicit EntryPersister(std::mutex& mutex, ARGS&&... args) : IMPL(mutex, std::forward<ARGS>(args)...) {}
   virtual ~EntryPersister() {}
 
   template <current::locks::MutexLockStatus MLS = current::locks::MutexLockStatus::NeedToLock,
@@ -162,7 +161,7 @@ struct IsEntryPersister {
   static constexpr bool value = std::is_base_of_v<GenericEntryPersister<E>, T>;
 };
 
-}  // namespace current::ss
+}  // namespace ss
 }  // namespace current
 
 #endif  // BLOCKS_SS_PERSISTER_H
diff --git a/blocks/ss/pubsub.h b/blocks/ss/pubsub.h
index 9426082ed..da250a47e 100644
--- a/blocks/ss/pubsub.h
+++ b/blocks/ss/pubsub.h
@@ -52,8 +52,7 @@ class EntryPublisher : public GenericEntryPublisher<ENTRY>, public IMPL {
 
  public:
   template <typename... ARGS>
-  explicit EntryPublisher(ARGS&&... args)
-      : IMPL(std::forward<ARGS>(args)...) {}
+  explicit EntryPublisher(ARGS&&... args) : IMPL(std::forward<ARGS>(args)...) {}
 
   virtual ~EntryPublisher() {}
 
@@ -133,8 +132,7 @@ template <typename IMPL, typename ENTRY>
 class EntrySubscriber : public GenericEntrySubscriber<ENTRY>, public IMPL {
  public:
   template <typename... ARGS>
-  EntrySubscriber(ARGS&&... args)
-      : IMPL(std::forward<ARGS>(args)...) {}
+  EntrySubscriber(ARGS&&... args) : IMPL(std::forward<ARGS>(args)...) {}
   virtual ~EntrySubscriber() {}
 
   EntryResponse operator()(const ENTRY& e, idxts_t current, idxts_t last) { return IMPL::operator()(e, current, last); }
@@ -211,7 +209,7 @@ struct PassEntryToSubscriberIfTypeMatchesImpl<T, T> {
   }
 };
 
-}  // namespace current::ss::impl
+}  // namespace impl
 
 template <typename TYPE_SUBSCRIBED_TO, typename STREAM_UNDERLYING_VARIANT, typename F, typename G, typename E>
 EntryResponse PassEntryToSubscriberIfTypeMatches(F&& f, G&& fallback, E&& entry, idxts_t current, idxts_t last) {
@@ -219,7 +217,7 @@ EntryResponse PassEntryToSubscriberIfTypeMatches(F&& f, G&& fallback, E&& entry,
       std::forward<F>(f), std::forward<G>(fallback), std::forward<E>(entry), current, last);
 }
 
-}  // namespace current::ss
+}  // namespace ss
 }  // namespace current
 
 #endif  // BLOCKS_SS_PUBSUB_H
diff --git a/blocks/ss/signature.h b/blocks/ss/signature.h
index 75d713fa4..44dc620da 100644
--- a/blocks/ss/signature.h
+++ b/blocks/ss/signature.h
@@ -35,17 +35,19 @@ CURRENT_STRUCT(StreamNamespaceName) {
   CURRENT_FIELD(namespace_name, std::string);
   CURRENT_FIELD(entry_name, std::string);
   CURRENT_DEFAULT_CONSTRUCTOR(StreamNamespaceName) {}
-  CURRENT_CONSTRUCTOR(StreamNamespaceName)(const std::string& namespace_name, const std::string& entry_name)
+  CURRENT_CONSTRUCTOR(StreamNamespaceName)
+  (const std::string& namespace_name, const std::string& entry_name)
       : namespace_name(namespace_name), entry_name(entry_name) {}
 };
 
 CURRENT_STRUCT(StreamSignature, StreamNamespaceName) {
   CURRENT_FIELD(schema, reflection::SchemaInfo);
   CURRENT_DEFAULT_CONSTRUCTOR(StreamSignature) {}
-  CURRENT_CONSTRUCTOR(StreamSignature)(
-      const std::string& namespace_name, const std::string& entry_name, const reflection::SchemaInfo& schema)
+  CURRENT_CONSTRUCTOR(StreamSignature)
+  (const std::string& namespace_name, const std::string& entry_name, const reflection::SchemaInfo& schema)
       : SUPER(namespace_name, entry_name), schema(schema) {}
-  CURRENT_CONSTRUCTOR(StreamSignature)(const StreamNamespaceName& namespace_name, const reflection::SchemaInfo& schema)
+  CURRENT_CONSTRUCTOR(StreamSignature)
+  (const StreamNamespaceName& namespace_name, const reflection::SchemaInfo& schema)
       : SUPER(namespace_name), schema(std::move(schema)) {}
 };
 
diff --git a/blocks/ss/types.h b/blocks/ss/types.h
index bafb0184c..413b92666 100644
--- a/blocks/ss/types.h
+++ b/blocks/ss/types.h
@@ -37,10 +37,9 @@ template <typename ENTRY, typename STREAM_ENTRY>
 #ifndef CURRENT_FOR_CPP14
 inline
 #endif  // CURRENT_FOR_CPP14
-constexpr
-bool can_publish_v = std::is_constructible_v<STREAM_ENTRY, ENTRY>;
+    constexpr bool can_publish_v = std::is_constructible_v<STREAM_ENTRY, ENTRY>;
 
-}  // namespace current::ss
+}  // namespace ss
 }  // namespace current
 
 #endif  // BLOCKS_SS_TYPES_H
diff --git a/blocks/url/exceptions.h b/blocks/url/exceptions.h
index 15e66ee27..887e99544 100644
--- a/blocks/url/exceptions.h
+++ b/blocks/url/exceptions.h
@@ -64,7 +64,7 @@ struct URLParseSpecificObjectAsURLParameterException : URLParseObjectAsURLParame
       : URLParseObjectAsURLParameterException(key, error, DescribeT()) {}
 };
 
-}  // namespace current::url
+}  // namespace url
 }  // namespace current
 
 #endif  // BLOCKS_URL_EXCEPTIONS_H
diff --git a/blocks/url/url.h b/blocks/url/url.h
index 59ba6eacf..4ca959da7 100644
--- a/blocks/url/url.h
+++ b/blocks/url/url.h
@@ -72,7 +72,7 @@ namespace impl {
 namespace {
 const char* const kDefaultScheme = "http";
 const char* const kDefaultHost = "localhost";
-}
+}  // namespace
 
 struct URLWithoutParametersParser {
   std::string host = "";
@@ -318,7 +318,8 @@ struct URLParametersExtractor {
         using super_t = current::reflection::SuperType<decayed_t>;
         FillObjectImpl<super_t, MODE>::DoIt(parameters, static_cast<super_t&>(object));
         QueryParametersObjectFiller<T, MODE> parser{parameters};
-        current::reflection::VisitAllFields<T, current::reflection::FieldNameAndMutableValue>::WithObject(object, parser);
+        current::reflection::VisitAllFields<T, current::reflection::FieldNameAndMutableValue>::WithObject(object,
+                                                                                                          parser);
       }
     };
 
@@ -475,10 +476,9 @@ struct URL : URLParametersExtractor, URLWithoutParametersParser {
   static bool IsPathValidToRegister(const std::string& path) {
     const std::set<char> valid_nonalnum_chars{
         '/', '-', '.', '_', '~', '!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=', ':', '@'};
-    return find_if(path.begin(),
-                   path.end(),
-                   [&valid_nonalnum_chars](char c) { return !(isalnum(c) || valid_nonalnum_chars.count(c)); }) ==
-           path.end();
+    return find_if(path.begin(), path.end(), [&valid_nonalnum_chars](char c) {
+             return !(isalnum(c) || valid_nonalnum_chars.count(c));
+           }) == path.end();
   }
 };
 
diff --git a/blocks/xterm/example.cc b/blocks/xterm/example.cc
index b73e494fa..e86f70746 100644
--- a/blocks/xterm/example.cc
+++ b/blocks/xterm/example.cc
@@ -19,8 +19,7 @@ int main(int argc, char** argv) {
     // Basic VT100 demo.
     using namespace current::vt100;
 
-    std::cout << "Default, " << bold << "bold" << normal << ", " << dim << "dim" << normal << ", done."
-              << std::endl;
+    std::cout << "Default, " << bold << "bold" << normal << ", " << dim << "dim" << normal << ", done." << std::endl;
 #ifndef CURRENT_WINDOWS
     std::cout << "Default, " << italic << "italic" << noitalic << '.' << std::endl;
 #endif  // CURRENT_WINDOWS
@@ -48,10 +47,9 @@ int main(int argc, char** argv) {
     std::cout << "Default, " << background(red) << blue << bold << "blue on red " << reverse << " reversed "
               << noreverse << " back to blue on red" << reset << '.' << std::endl;
 
-    std::cout << "Default, " << strikeout << "no " << red << "red" << bold << " bold" << italic << " italic"
-              << noitalic << ' ' << underlined << "underlined" << nounderlined << ' ' << doubleunderlined
-              << "doubleunderlined" << nounderlined << normal << default_color << " style" << nostrikeout
-              << '.' << reset << std::endl;
+    std::cout << "Default, " << strikeout << "no " << red << "red" << bold << " bold" << italic << " italic" << noitalic
+              << ' ' << underlined << "underlined" << nounderlined << ' ' << doubleunderlined << "doubleunderlined"
+              << nounderlined << normal << default_color << " style" << nostrikeout << '.' << reset << std::endl;
   }
 
   {
@@ -86,7 +84,7 @@ int main(int argc, char** argv) {
     }
     std::cout << "Done." << std::endl;
   }
-  #endif
+#endif
 
   if (false) {
     // NOTE(dkorolev): This fails on my Linux. :/ Prints `Test3> tttesting ... OK`, then `Test3> ttDone.` at the end.
diff --git a/blocks/xterm/multiline.cc b/blocks/xterm/multiline.cc
index d3d723bdc..d4c8d1faa 100644
--- a/blocks/xterm/multiline.cc
+++ b/blocks/xterm/multiline.cc
@@ -11,18 +11,22 @@ int main() {
   std::vector<std::thread> threads;
   int index = 0u;
   do {
-    threads.emplace_back([&multiline_progress](int index) {
-        current::ProgressLine line = multiline_progress();
-        const double k = current::random::RandomDouble(0.01, 0.04);
-        const double b = current::random::RandomDouble(0.0, 6.28);
-        const double a = current::random::RandomDouble(20, 45);
-        const auto t0 = current::time::Now();
-        while (true) {
-          line << "Line" << index << ": " << std::string(static_cast<size_t>(
-            0.5 * (std::sin((current::time::Now() - t0).count() * 1e-3 * k + b) + 1.0) * a), '*');
-          std::this_thread::sleep_for(std::chrono::milliseconds(current::random::RandomInt(1, 25)));
-        }
-    }, ++index);
+    threads.emplace_back(
+        [&multiline_progress](int index) {
+          current::ProgressLine line = multiline_progress();
+          const double k = current::random::RandomDouble(0.01, 0.04);
+          const double b = current::random::RandomDouble(0.0, 6.28);
+          const double a = current::random::RandomDouble(20, 45);
+          const auto t0 = current::time::Now();
+          while (true) {
+            line << "Line" << index << ": "
+                 << std::string(static_cast<size_t>(
+                                    0.5 * (std::sin((current::time::Now() - t0).count() * 1e-3 * k + b) + 1.0) * a),
+                                '*');
+            std::this_thread::sleep_for(std::chrono::milliseconds(current::random::RandomInt(1, 25)));
+          }
+        },
+        ++index);
     std::this_thread::sleep_for(std::chrono::milliseconds(current::random::RandomInt(500, 2500 * index)));
   } while (true);
 }
diff --git a/blocks/xterm/progress.h b/blocks/xterm/progress.h
index a59cf526b..f76bb603b 100644
--- a/blocks/xterm/progress.h
+++ b/blocks/xterm/progress.h
@@ -64,7 +64,8 @@ class ProgressLine final {
   ProgressLine(DoConstruct,
                std::ostream& os = std::cout,
                std::function<int()> up = nullptr,
-               std::mutex* maybe_mutex = nullptr) : os_(os), up_(up), maybe_mutex_(maybe_mutex) {
+               std::mutex* maybe_mutex = nullptr)
+      : os_(os), up_(up), maybe_mutex_(maybe_mutex) {
     if (up_) {
       // Move to the next line right away to "allocate" a new line for this "multiline" "progress instance".
       const auto maybe_lock = MaybeLock();
@@ -128,9 +129,7 @@ class ProgressLine final {
     return status;
   }
 
-  std::string GetUndecoratedString() const {
-    return current_undecorated_status_;
-  }
+  std::string GetUndecoratedString() const { return current_undecorated_status_; }
 
  protected:
   void DoUpdate(Status& status) {
@@ -139,7 +138,7 @@ class ProgressLine final {
 
     if (new_status != current_status_) {
       const size_t new_status_length =
-        current::strings::UTF8StringLength(status.oss_text_with_no_vt100_escape_sequences.str());
+          current::strings::UTF8StringLength(status.oss_text_with_no_vt100_escape_sequences.str());
       if (!up_) {
         const auto maybe_lock = MaybeLock();
         DoClearString(os_);
@@ -153,8 +152,8 @@ class ProgressLine final {
           os_ << vt100::up(n + 1) << new_status << vt100::reset << '\n' << vt100::down(n) << std::flush;
         } else {
           const size_t d = current_status_length_ - new_status_length;
-          os_ << vt100::up(n + 1) << new_status << vt100::reset
-              << std::string(d, ' ') << '\n' << vt100::down(n) << std::flush;
+          os_ << vt100::up(n + 1) << new_status << vt100::reset << std::string(d, ' ') << '\n'
+              << vt100::down(n) << std::flush;
         }
       }
       current_status_ = new_status;
@@ -172,7 +171,8 @@ class MultilineProgress final {
   current::ProgressLine operator()(std::ostream& os = std::cout) {
     ++total_;
     int index = total_;
-    return current::ProgressLine(os, [index, this]() { return total_ - index; }, mutex_);
+    return current::ProgressLine(
+        os, [index, this]() { return total_ - index; }, mutex_);
   }
 };
 
diff --git a/blocks/xterm/vt100.h b/blocks/xterm/vt100.h
index e0b0374a1..a02cc9083 100644
--- a/blocks/xterm/vt100.h
+++ b/blocks/xterm/vt100.h
@@ -102,15 +102,11 @@ struct UD final {
   explicit UD(int by) : down(by) {}
 };
 
-inline UD up(int d) {
-  return UD(-d);
-}
+inline UD up(int d) { return UD(-d); }
 
-inline UD down(int d) {
-  return UD(+d);
-}
+inline UD down(int d) { return UD(+d); }
 
-}  // namespace current::vt100
+}  // namespace vt100
 }  // namespace current
 
 inline void EnableVirtualTerminalProcessing() {
diff --git a/bricks/c++17/test.cc b/bricks/c++17/test.cc
index f3ca48387..f44f8978d 100644
--- a/bricks/c++17/test.cc
+++ b/bricks/c++17/test.cc
@@ -28,7 +28,9 @@ SOFTWARE.
 
 #if __cplusplus >= 201703L
 TEST(CPlusPlus17, Enabled) {
-  auto const generic_lambda = [](auto const x) { return current::reflection::TypeName<current::decay_t<decltype(x)>>(); };
+  auto const generic_lambda = [](auto const x) {
+    return current::reflection::TypeName<current::decay_t<decltype(x)>>();
+  };
 
   EXPECT_STREQ("uint32_t", generic_lambda(static_cast<uint32_t>(42)));
   EXPECT_STREQ("bool", generic_lambda(true));
diff --git a/bricks/dflags/test.cc b/bricks/dflags/test.cc
index 732278bed..1c7e7bcbd 100644
--- a/bricks/dflags/test.cc
+++ b/bricks/dflags/test.cc
@@ -276,17 +276,17 @@ TEST(DFlags, PrintsHelpDeathTest) {
   char p2[] = "--help";
   char* pp[] = {p1, p2};
   char** argv = pp;
-  EXPECT_DEATH(ParseDFlags(&argc, &argv), DFLAGS_TEST_REGEX(
-               "3 flags registered.\n"
-               "\t--bar , bool\n"
-               "\t\tBar\\.\n"
-               "\t\tDefault value\\: True\n"
-               "\t--foo , std\\:\\:string\n"
-               "\t\tFoo\\.\n"
-               "\t\tDefault value: 'TRUE THIS'\n"
-               "\t--meh , int32_t\n"
-               "\t\tMeh\\.\n"
-               "\t\tDefault value: 42\n"));
+  EXPECT_DEATH(ParseDFlags(&argc, &argv),
+               DFLAGS_TEST_REGEX("3 flags registered.\n"
+                                 "\t--bar , bool\n"
+                                 "\t\tBar\\.\n"
+                                 "\t\tDefault value\\: True\n"
+                                 "\t--foo , std\\:\\:string\n"
+                                 "\t\tFoo\\.\n"
+                                 "\t\tDefault value: 'TRUE THIS'\n"
+                                 "\t--meh , int32_t\n"
+                                 "\t\tMeh\\.\n"
+                                 "\t\tDefault value: 42\n"));
 }
 
 TEST(DFlags, UndefinedFlagDeathTest) {
@@ -319,7 +319,8 @@ TEST(DFlags, TooManyDashesDeathTest) {
   char p2[] = "---whatever42";
   char* pp[] = {p1, p2};
   char** argv = pp;
-  EXPECT_DEATH(ParseDFlags(&argc, &argv), DFLAGS_TEST_REGEX("Parameter: '---whatever42' has too many dashes in front\\."));
+  EXPECT_DEATH(ParseDFlags(&argc, &argv),
+               DFLAGS_TEST_REGEX("Parameter: '---whatever42' has too many dashes in front\\."));
 }
 
 TEST(DFlags, NoValueDeathTest) {
diff --git a/bricks/dot/graphviz.h b/bricks/dot/graphviz.h
index a824b47a2..2b64e59d7 100644
--- a/bricks/dot/graphviz.h
+++ b/bricks/dot/graphviz.h
@@ -259,8 +259,8 @@ struct GenericGraph {
     const auto output_file_deleter = current::FileSystem::ScopedRmFile(output_file_name);
 
     current::FileSystem::WriteStringToFile(AsDOT(), input_file_name.c_str());
-    CURRENT_ASSERT(!bricks::system::SystemCall(current::strings::Printf(
-        "dot -T svg %s -o %s", input_file_name.c_str(), output_file_name.c_str()).c_str()));
+    CURRENT_ASSERT(!bricks::system::SystemCall(
+        current::strings::Printf("dot -T svg %s -o %s", input_file_name.c_str(), output_file_name.c_str()).c_str()));
     return current::FileSystem::ReadFileAsString(output_file_name.c_str());
   }
 };
diff --git a/bricks/file/file.h b/bricks/file/file.h
index d3c832a5c..d93f7c8e0 100644
--- a/bricks/file/file.h
+++ b/bricks/file/file.h
@@ -326,26 +326,27 @@ struct FileSystem {
       // Inner lambdas have distinct types thus creating template instantiation limit,
       // which is fixed by casting the lambda to its canonical type.
       ScanDirUntil(directory,
-                   static_cast<const std::function<bool(const ScanDirItemInfo&)>>([&item_handler, parameters, &context](
-                       const ScanDirItemInfo& item_info) {
-                     const ScanDirParameters mask =
-                         item_info.is_directory ? ScanDirParameters::ListDirsOnly : ScanDirParameters::ListFilesOnly;
-                     if (static_cast<int>(parameters) & static_cast<int>(mask)) {
-                       if (!item_handler(item_info)) {
-                         return false;
-                       }
-                     }
-                     if (item_info.is_directory) {
-                       context.path_components.push_back(item_info.basename);
-                       const auto guard = current::MakeScopeGuard([&context]() { context.path_components.pop_back(); });
-                       ScanDirUntil<ITEM_HANDLER>(item_info.pathname,
-                                                  std::forward<ITEM_HANDLER>(item_handler),
-                                                  parameters,
-                                                  ScanDirRecursive::Yes,
-                                                  context);
-                     }
-                     return true;
-                   }),
+                   static_cast<const std::function<bool(const ScanDirItemInfo&)>>(
+                       [&item_handler, parameters, &context](const ScanDirItemInfo& item_info) {
+                         const ScanDirParameters mask = item_info.is_directory ? ScanDirParameters::ListDirsOnly
+                                                                               : ScanDirParameters::ListFilesOnly;
+                         if (static_cast<int>(parameters) & static_cast<int>(mask)) {
+                           if (!item_handler(item_info)) {
+                             return false;
+                           }
+                         }
+                         if (item_info.is_directory) {
+                           context.path_components.push_back(item_info.basename);
+                           const auto guard =
+                               current::MakeScopeGuard([&context]() { context.path_components.pop_back(); });
+                           ScanDirUntil<ITEM_HANDLER>(item_info.pathname,
+                                                      std::forward<ITEM_HANDLER>(item_handler),
+                                                      parameters,
+                                                      ScanDirRecursive::Yes,
+                                                      context);
+                         }
+                         return true;
+                       }),
                    ScanDirParameters::ListFilesAndDirs,
                    ScanDirRecursive::No,
                    context);
@@ -357,13 +358,14 @@ struct FileSystem {
                              ITEM_HANDLER&& item_handler,
                              ScanDirParameters parameters = ScanDirParameters::ListFilesOnly,
                              ScanDirRecursive recursive = ScanDirRecursive::No) {
-    ScanDirUntil(directory,
-                 [&item_handler](const ScanDirItemInfo& item_info) {
-                   item_handler(item_info);
-                   return true;
-                 },
-                 parameters,
-                 recursive);
+    ScanDirUntil(
+        directory,
+        [&item_handler](const ScanDirItemInfo& item_info) {
+          item_handler(item_info);
+          return true;
+        },
+        parameters,
+        recursive);
   }
 
   enum class RmFileParameters { ThrowExceptionOnError, Silent };
@@ -416,18 +418,18 @@ struct FileSystem {
       }
     } else {
       try {
-        ScanDir(directory,
-                [parameters](const ScanDirItemInfo& item_info) {
-                  if (item_info.is_directory) {
-                    RmDir(item_info.pathname, parameters, RmDirRecursive::Yes);
-                  } else {
-                    RmFile(item_info.pathname,
-                           (parameters == RmDirParameters::ThrowExceptionOnError)
-                               ? RmFileParameters::ThrowExceptionOnError
-                               : RmFileParameters::Silent);
-                  }
-                },
-                ScanDirParameters::ListFilesAndDirs);
+        ScanDir(
+            directory,
+            [parameters](const ScanDirItemInfo& item_info) {
+              if (item_info.is_directory) {
+                RmDir(item_info.pathname, parameters, RmDirRecursive::Yes);
+              } else {
+                RmFile(item_info.pathname,
+                       (parameters == RmDirParameters::ThrowExceptionOnError) ? RmFileParameters::ThrowExceptionOnError
+                                                                              : RmFileParameters::Silent);
+              }
+            },
+            ScanDirParameters::ListFilesAndDirs);
         RmDir(directory, parameters, RmDirRecursive::No);
       } catch (const current::Exception&) {
         if (parameters == RmDirParameters::ThrowExceptionOnError) {
diff --git a/bricks/file/test.cc b/bricks/file/test.cc
index f81b2c33a..a5dc215d3 100644
--- a/bricks/file/test.cc
+++ b/bricks/file/test.cc
@@ -33,11 +33,11 @@ SOFTWARE.
 #include "../strings/join.h"
 #include "../../3rdparty/gtest/gtest-main-with-dflags.h"
 
-using current::FileSystem;
-using current::FileException;
 using current::DirDoesNotExistException;
-using current::PathNotDirException;
 using current::DirNotEmptyException;
+using current::FileException;
+using current::FileSystem;
+using current::PathNotDirException;
 
 DEFINE_string(file_test_tmpdir, ".current", "Local path for the test to create temporary files in.");
 
@@ -302,11 +302,10 @@ TEST(File, ScanDirParameters) {
   {
     std::set<std::string> names;
     std::map<std::string, FileSystem::ScanDirItemInfo> item_infos;
-    FileSystem::ScanDir(base_dir,
-                        [&names, &item_infos](const FileSystem::ScanDirItemInfo& x) {
-                          names.insert(x.basename);
-                          item_infos.insert(std::make_pair(x.basename, x));
-                        });
+    FileSystem::ScanDir(base_dir, [&names, &item_infos](const FileSystem::ScanDirItemInfo& x) {
+      names.insert(x.basename);
+      item_infos.insert(std::make_pair(x.basename, x));
+    });
     EXPECT_EQ("f", current::strings::Join(names, ','));
     EXPECT_EQ(f, item_infos.at("f").pathname);
     EXPECT_EQ(base_dir, item_infos.at("f").dirname);
@@ -316,12 +315,13 @@ TEST(File, ScanDirParameters) {
   {
     std::set<std::string> names;
     std::map<std::string, FileSystem::ScanDirItemInfo> item_infos;
-    FileSystem::ScanDir(base_dir,
-                        [&names, &item_infos](const FileSystem::ScanDirItemInfo& x) {
-                          names.insert(x.basename);
-                          item_infos.insert(std::make_pair(x.basename, x));
-                        },
-                        FileSystem::ScanDirParameters::ListFilesOnly);
+    FileSystem::ScanDir(
+        base_dir,
+        [&names, &item_infos](const FileSystem::ScanDirItemInfo& x) {
+          names.insert(x.basename);
+          item_infos.insert(std::make_pair(x.basename, x));
+        },
+        FileSystem::ScanDirParameters::ListFilesOnly);
     EXPECT_EQ("f", current::strings::Join(names, ','));
     EXPECT_EQ(f, item_infos.at("f").pathname);
     EXPECT_EQ(base_dir, item_infos.at("f").dirname);
@@ -331,12 +331,13 @@ TEST(File, ScanDirParameters) {
   {
     std::set<std::string> names;
     std::map<std::string, FileSystem::ScanDirItemInfo> item_infos;
-    FileSystem::ScanDir(base_dir,
-                        [&names, &item_infos](const FileSystem::ScanDirItemInfo& x) {
-                          names.insert(x.basename);
-                          item_infos.insert(std::make_pair(x.basename, x));
-                        },
-                        FileSystem::ScanDirParameters::ListDirsOnly);
+    FileSystem::ScanDir(
+        base_dir,
+        [&names, &item_infos](const FileSystem::ScanDirItemInfo& x) {
+          names.insert(x.basename);
+          item_infos.insert(std::make_pair(x.basename, x));
+        },
+        FileSystem::ScanDirParameters::ListDirsOnly);
     EXPECT_EQ("d", current::strings::Join(names, ','));
     EXPECT_EQ(d, item_infos.at("d").pathname);
     EXPECT_EQ(base_dir, item_infos.at("d").dirname);
@@ -346,12 +347,13 @@ TEST(File, ScanDirParameters) {
   {
     std::set<std::string> names;
     std::map<std::string, FileSystem::ScanDirItemInfo> item_infos;
-    FileSystem::ScanDir(base_dir,
-                        [&names, &item_infos](const FileSystem::ScanDirItemInfo& x) {
-                          names.insert(x.basename);
-                          item_infos.insert(std::make_pair(x.basename, x));
-                        },
-                        FileSystem::ScanDirParameters::ListFilesAndDirs);
+    FileSystem::ScanDir(
+        base_dir,
+        [&names, &item_infos](const FileSystem::ScanDirItemInfo& x) {
+          names.insert(x.basename);
+          item_infos.insert(std::make_pair(x.basename, x));
+        },
+        FileSystem::ScanDirParameters::ListFilesAndDirs);
     EXPECT_EQ("d,f", current::strings::Join(names, ','));
     EXPECT_EQ(d, item_infos.at("d").pathname);
     EXPECT_EQ(base_dir, item_infos.at("d").dirname);
@@ -388,13 +390,14 @@ TEST(File, ScanDirRecursive) {
     std::set<std::string> basenames;
     std::map<std::string, FileSystem::ScanDirItemInfo> item_infos;
 
-    FileSystem::ScanDir(base_dir,
-                        [&basenames, &item_infos](const FileSystem::ScanDirItemInfo& x) {
-                          basenames.insert(x.basename);
-                          item_infos.insert(std::make_pair(x.basename, x));
-                        },
-                        FileSystem::ScanDirParameters::ListFilesOnly,
-                        FileSystem::ScanDirRecursive::Yes);
+    FileSystem::ScanDir(
+        base_dir,
+        [&basenames, &item_infos](const FileSystem::ScanDirItemInfo& x) {
+          basenames.insert(x.basename);
+          item_infos.insert(std::make_pair(x.basename, x));
+        },
+        FileSystem::ScanDirParameters::ListFilesOnly,
+        FileSystem::ScanDirRecursive::Yes);
 
     EXPECT_EQ("base_dir_file,sub_dir_file,sub_sub_dir_file,sub_sub_dir_file_2", current::strings::Join(basenames, ','));
 
@@ -413,13 +416,14 @@ TEST(File, ScanDirRecursive) {
     std::set<std::string> basenames;
     std::map<std::string, FileSystem::ScanDirItemInfo> item_infos;
 
-    FileSystem::ScanDir(base_dir,
-                        [&basenames, &item_infos](const FileSystem::ScanDirItemInfo& x) {
-                          basenames.insert(x.basename);
-                          item_infos.insert(std::make_pair(x.basename, x));
-                        },
-                        FileSystem::ScanDirParameters::ListDirsOnly,
-                        FileSystem::ScanDirRecursive::Yes);
+    FileSystem::ScanDir(
+        base_dir,
+        [&basenames, &item_infos](const FileSystem::ScanDirItemInfo& x) {
+          basenames.insert(x.basename);
+          item_infos.insert(std::make_pair(x.basename, x));
+        },
+        FileSystem::ScanDirParameters::ListDirsOnly,
+        FileSystem::ScanDirRecursive::Yes);
 
     EXPECT_EQ("sub_dir,sub_sub_dir,sub_sub_dir_2", current::strings::Join(basenames, ','));
 
@@ -436,13 +440,14 @@ TEST(File, ScanDirRecursive) {
     std::set<std::string> basenames;
     std::map<std::string, FileSystem::ScanDirItemInfo> item_infos;
 
-    FileSystem::ScanDir(base_dir,
-                        [&basenames, &item_infos](const FileSystem::ScanDirItemInfo& x) {
-                          basenames.insert(x.basename);
-                          item_infos.insert(std::make_pair(x.basename, x));
-                        },
-                        FileSystem::ScanDirParameters::ListFilesAndDirs,
-                        FileSystem::ScanDirRecursive::Yes);
+    FileSystem::ScanDir(
+        base_dir,
+        [&basenames, &item_infos](const FileSystem::ScanDirItemInfo& x) {
+          basenames.insert(x.basename);
+          item_infos.insert(std::make_pair(x.basename, x));
+        },
+        FileSystem::ScanDirParameters::ListFilesAndDirs,
+        FileSystem::ScanDirRecursive::Yes);
 
     EXPECT_EQ("base_dir_file,sub_dir,sub_dir_file,sub_sub_dir,sub_sub_dir_2,sub_sub_dir_file,sub_sub_dir_file_2",
               current::strings::Join(basenames, ','));
diff --git a/bricks/graph/gnuplot.h b/bricks/graph/gnuplot.h
index b85ecfd69..8cc9f3f8d 100644
--- a/bricks/graph/gnuplot.h
+++ b/bricks/graph/gnuplot.h
@@ -236,7 +236,7 @@ struct GNUPlot {
     }
     if (output_format_ != "gnuplot") {
       CURRENT_ASSERT(!bricks::system::SystemCall(
-                         strings::Printf("gnuplot <%s >%s", input_file_name.c_str(), output_file_name.c_str())));
+          strings::Printf("gnuplot <%s >%s", input_file_name.c_str(), output_file_name.c_str())));
       return current::FileSystem::ReadFileAsString(output_file_name.c_str());
     } else {
       // For unit tests, just compare the inputs.
diff --git a/bricks/net/http/headers/headers.h b/bricks/net/http/headers/headers.h
index 6a310384b..dff875a94 100644
--- a/bricks/net/http/headers/headers.h
+++ b/bricks/net/http/headers/headers.h
@@ -193,9 +193,9 @@ struct Headers final {
 
   Headers(const std::string& header, const std::string& value) { Set(header, value); }
   Headers(std::initializer_list<std::pair<std::string, std::string>> initializer) {
-    std::for_each(initializer.begin(),
-                  initializer.end(),
-                  [this](const std::pair<std::string, std::string>& h) { Set(h.first, h.second); });
+    std::for_each(initializer.begin(), initializer.end(), [this](const std::pair<std::string, std::string>& h) {
+      Set(h.first, h.second);
+    });
   }
 
   // An instance of `Headers` can `Set()` / `Get()` / `Has()` / `Remove()` headers.
diff --git a/bricks/net/http/test.cc b/bricks/net/http/test.cc
index 921a9163c..489ce1894 100644
--- a/bricks/net/http/test.cc
+++ b/bricks/net/http/test.cc
@@ -37,19 +37,19 @@ SOFTWARE.
 
 #include "../../../3rdparty/gtest/gtest-main-with-dflags.h"
 
-using current::net::Socket;
+using current::net::AttemptedToSendHTTPResponseMoreThanOnce;
+using current::net::ChunkSizeNotAValidHEXValue;
 using current::net::ClientSocket;
 using current::net::Connection;
-using current::net::HTTPServerConnection;
+using current::net::ConnectionResetByPeer;
+using current::net::DefaultInternalServerErrorMessage;
+using current::net::GetFileMimeType;
 using current::net::HTTPRequestData;
-using current::net::HTTPResponseCodeValue;
 using current::net::HTTPResponseCodeAsString;
-using current::net::GetFileMimeType;
-using current::net::DefaultInternalServerErrorMessage;
+using current::net::HTTPResponseCodeValue;
+using current::net::HTTPServerConnection;
+using current::net::Socket;
 using current::net::SocketException;
-using current::net::ConnectionResetByPeer;
-using current::net::ChunkSizeNotAValidHEXValue;
-using current::net::AttemptedToSendHTTPResponseMoreThanOnce;
 
 static void ExpectToReceive(const std::string& golden, Connection& connection) {
   std::vector<char> response(golden.length());
@@ -71,16 +71,18 @@ CURRENT_STRUCT(HTTPTestObject) {
 TEST(PosixHTTPServerTest, Smoke) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([port](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    EXPECT_EQ("127.0.0.1", c.LocalIPAndPort().ip);
-    EXPECT_EQ(port, c.LocalIPAndPort().port);
-    EXPECT_EQ("127.0.0.1", c.RemoteIPAndPort().ip);
-    EXPECT_LT(0, c.RemoteIPAndPort().port);
-    EXPECT_EQ("POST", c.HTTPRequest().Method());
-    EXPECT_EQ("/", c.HTTPRequest().RawPath());
-    c.SendHTTPResponse("Data: " + c.HTTPRequest().Body());
-  }, std::move(reserved_port));
+  std::thread t(
+      [port](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        EXPECT_EQ("127.0.0.1", c.LocalIPAndPort().ip);
+        EXPECT_EQ(port, c.LocalIPAndPort().port);
+        EXPECT_EQ("127.0.0.1", c.RemoteIPAndPort().ip);
+        EXPECT_LT(0, c.RemoteIPAndPort().port);
+        EXPECT_EQ("POST", c.HTTPRequest().Method());
+        EXPECT_EQ("/", c.HTTPRequest().RawPath());
+        c.SendHTTPResponse("Data: " + c.HTTPRequest().Body());
+      },
+      std::move(reserved_port));
   Connection connection(ClientSocket("localhost", port));
   EXPECT_EQ("127.0.0.1", connection.LocalIPAndPort().ip);
   EXPECT_LT(0, connection.LocalIPAndPort().port);
@@ -106,16 +108,18 @@ TEST(PosixHTTPServerTest, Smoke) {
 TEST(PosixHTTPServerTest, SmokeWithTrailingSpaces) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([port](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    EXPECT_EQ("127.0.0.1", c.LocalIPAndPort().ip);
-    EXPECT_EQ(port, c.LocalIPAndPort().port);
-    EXPECT_EQ("127.0.0.1", c.RemoteIPAndPort().ip);
-    EXPECT_LT(0, c.RemoteIPAndPort().port);
-    EXPECT_EQ("POST", c.HTTPRequest().Method());
-    EXPECT_EQ("/", c.HTTPRequest().RawPath());
-    c.SendHTTPResponse("Data: " + c.HTTPRequest().Body());
-  }, std::move(reserved_port));
+  std::thread t(
+      [port](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        EXPECT_EQ("127.0.0.1", c.LocalIPAndPort().ip);
+        EXPECT_EQ(port, c.LocalIPAndPort().port);
+        EXPECT_EQ("127.0.0.1", c.RemoteIPAndPort().ip);
+        EXPECT_LT(0, c.RemoteIPAndPort().port);
+        EXPECT_EQ("POST", c.HTTPRequest().Method());
+        EXPECT_EQ("/", c.HTTPRequest().RawPath());
+        c.SendHTTPResponse("Data: " + c.HTTPRequest().Body());
+      },
+      std::move(reserved_port));
   Connection connection(ClientSocket("localhost", port));
   EXPECT_EQ("127.0.0.1", connection.LocalIPAndPort().ip);
   EXPECT_LT(0, connection.LocalIPAndPort().port);
@@ -141,12 +145,14 @@ TEST(PosixHTTPServerTest, SmokeWithTrailingSpaces) {
 TEST(PosixHTTPServerTest, SmokeWithArray) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    EXPECT_EQ("GET", c.HTTPRequest().Method());
-    EXPECT_EQ("/vector_char", c.HTTPRequest().RawPath());
-    c.SendHTTPResponse(std::vector<char>({'S', 't', 'r', 'i', 'n', 'g'}));
-  }, std::move(reserved_port));
+  std::thread t(
+      [](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        EXPECT_EQ("GET", c.HTTPRequest().Method());
+        EXPECT_EQ("/vector_char", c.HTTPRequest().RawPath());
+        c.SendHTTPResponse(std::vector<char>({'S', 't', 'r', 'i', 'n', 'g'}));
+      },
+      std::move(reserved_port));
   Connection connection(ClientSocket("localhost", port));
   connection.BlockingWrite("GET /vector_char HTTP/1.1\r\n", true);
   connection.BlockingWrite("Host: localhost\r\n", true);
@@ -166,12 +172,14 @@ TEST(PosixHTTPServerTest, SmokeWithArray) {
 TEST(PosixHTTPServerTest, SmokeWithObject) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    EXPECT_EQ("GET", c.HTTPRequest().Method());
-    EXPECT_EQ("/test_object", c.HTTPRequest().RawPath());
-    c.SendHTTPResponse(HTTPTestObject());
-  }, std::move(reserved_port));
+  std::thread t(
+      [](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        EXPECT_EQ("GET", c.HTTPRequest().Method());
+        EXPECT_EQ("/test_object", c.HTTPRequest().RawPath());
+        c.SendHTTPResponse(HTTPTestObject());
+      },
+      std::move(reserved_port));
   Connection connection(ClientSocket("localhost", port));
   connection.BlockingWrite("GET /test_object HTTP/1.1\r\n", true);
   connection.BlockingWrite("Host: localhost\r\n", true);
@@ -191,12 +199,14 @@ TEST(PosixHTTPServerTest, SmokeWithObject) {
 TEST(PosixHTTPServerTest, SmokeWithObjectWithCORSHeader) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    EXPECT_EQ("GET", c.HTTPRequest().Method());
-    EXPECT_EQ("/test_object", c.HTTPRequest().RawPath());
-    c.SendHTTPResponse(HTTPTestObject(), HTTPResponseCode.OK, current::net::http::Headers().SetCORSHeader());
-  }, std::move(reserved_port));
+  std::thread t(
+      [](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        EXPECT_EQ("GET", c.HTTPRequest().Method());
+        EXPECT_EQ("/test_object", c.HTTPRequest().RawPath());
+        c.SendHTTPResponse(HTTPTestObject(), HTTPResponseCode.OK, current::net::http::Headers().SetCORSHeader());
+      },
+      std::move(reserved_port));
   Connection connection(ClientSocket("localhost", port));
   connection.BlockingWrite("GET /test_object HTTP/1.1\r\n", true);
   connection.BlockingWrite("Host: localhost\r\n", true);
@@ -217,15 +227,17 @@ TEST(PosixHTTPServerTest, SmokeWithObjectWithCORSHeader) {
 TEST(PosixHTTPServerTest, SmokeChunkedResponse) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    EXPECT_EQ("GET", c.HTTPRequest().Method());
-    EXPECT_EQ("/chunked", c.HTTPRequest().RawPath());
-    auto r = c.SendChunkedHTTPResponse();
-    r.Send("onetwothree");
-    r.Send(std::vector<char>({'f', 'o', 'o'}));
-    r.Send(HTTPTestObject());
-  }, std::move(reserved_port));
+  std::thread t(
+      [](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        EXPECT_EQ("GET", c.HTTPRequest().Method());
+        EXPECT_EQ("/chunked", c.HTTPRequest().RawPath());
+        auto r = c.SendChunkedHTTPResponse();
+        r.Send("onetwothree");
+        r.Send(std::vector<char>({'f', 'o', 'o'}));
+        r.Send(HTTPTestObject());
+      },
+      std::move(reserved_port));
   Connection connection(ClientSocket("localhost", port));
   connection.BlockingWrite("GET /chunked HTTP/1.1\r\n", true);
   connection.BlockingWrite("Host: localhost\r\n", true);
@@ -250,15 +262,17 @@ TEST(PosixHTTPServerTest, SmokeChunkedResponse) {
 TEST(PosixHTTPServerTest, SmokeChunkedResponseWithCORSHeader) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    EXPECT_EQ("GET", c.HTTPRequest().Method());
-    EXPECT_EQ("/chunked", c.HTTPRequest().RawPath());
-    auto r = c.SendChunkedHTTPResponse(HTTPResponseCode.OK, current::net::http::Headers().SetCORSHeader());
-    r.Send("onetwothree");
-    r.Send(std::vector<char>({'f', 'o', 'o'}));
-    r.Send(HTTPTestObject());
-  }, std::move(reserved_port));
+  std::thread t(
+      [](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        EXPECT_EQ("GET", c.HTTPRequest().Method());
+        EXPECT_EQ("/chunked", c.HTTPRequest().RawPath());
+        auto r = c.SendChunkedHTTPResponse(HTTPResponseCode.OK, current::net::http::Headers().SetCORSHeader());
+        r.Send("onetwothree");
+        r.Send(std::vector<char>({'f', 'o', 'o'}));
+        r.Send(HTTPTestObject());
+      },
+      std::move(reserved_port));
   Connection connection(ClientSocket("localhost", port));
   connection.BlockingWrite("GET /chunked HTTP/1.1\r\n", true);
   connection.BlockingWrite("Host: localhost\r\n", true);
@@ -284,15 +298,17 @@ TEST(PosixHTTPServerTest, SmokeChunkedResponseWithCORSHeader) {
 TEST(PosixHTTPServerTest, SmokeWithHeaders) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    EXPECT_EQ("POST", c.HTTPRequest().Method());
-    EXPECT_EQ("/header", c.HTTPRequest().RawPath());
-    c.SendHTTPResponse("OK",
-                       HTTPResponseCode.OK,
-                       current::net::http::Headers({{"foo", "bar"}, {"baz", "meh"}}),
-                       "here_is_" + c.HTTPRequest().Body());
-  }, std::move(reserved_port));
+  std::thread t(
+      [](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        EXPECT_EQ("POST", c.HTTPRequest().Method());
+        EXPECT_EQ("/header", c.HTTPRequest().RawPath());
+        c.SendHTTPResponse("OK",
+                           HTTPResponseCode.OK,
+                           current::net::http::Headers({{"foo", "bar"}, {"baz", "meh"}}),
+                           "here_is_" + c.HTTPRequest().Body());
+      },
+      std::move(reserved_port));
   Connection connection(ClientSocket("localhost", port));
   connection.BlockingWrite("POST /header HTTP/1.1\r\n", true);
   connection.BlockingWrite("Host: localhost\r\n", true);
@@ -316,16 +332,18 @@ TEST(PosixHTTPServerTest, SmokeWithHeaders) {
 TEST(PosixHTTPServerTest, SmokeWithLowercaseContentLength) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([port](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    EXPECT_EQ("127.0.0.1", c.LocalIPAndPort().ip);
-    EXPECT_EQ(port, c.LocalIPAndPort().port);
-    EXPECT_EQ("127.0.0.1", c.RemoteIPAndPort().ip);
-    EXPECT_LT(0, c.RemoteIPAndPort().port);
-    EXPECT_EQ("POST", c.HTTPRequest().Method());
-    EXPECT_EQ("/", c.HTTPRequest().RawPath());
-    c.SendHTTPResponse("Data: " + c.HTTPRequest().Body());
-  }, std::move(reserved_port));
+  std::thread t(
+      [port](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        EXPECT_EQ("127.0.0.1", c.LocalIPAndPort().ip);
+        EXPECT_EQ(port, c.LocalIPAndPort().port);
+        EXPECT_EQ("127.0.0.1", c.RemoteIPAndPort().ip);
+        EXPECT_LT(0, c.RemoteIPAndPort().port);
+        EXPECT_EQ("POST", c.HTTPRequest().Method());
+        EXPECT_EQ("/", c.HTTPRequest().RawPath());
+        c.SendHTTPResponse("Data: " + c.HTTPRequest().Body());
+      },
+      std::move(reserved_port));
   Connection connection(ClientSocket("localhost", port));
   EXPECT_EQ("127.0.0.1", connection.LocalIPAndPort().ip);
   EXPECT_LT(0, connection.LocalIPAndPort().port);
@@ -350,13 +368,15 @@ TEST(PosixHTTPServerTest, SmokeWithLowercaseContentLength) {
 TEST(PosixHTTPServerTest, SmokeWithMethodInHeader) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    EXPECT_EQ("PATCH", c.HTTPRequest().Method());
-    EXPECT_EQ("/ugly", c.HTTPRequest().RawPath());
-    EXPECT_EQ("YES", c.HTTPRequest().Body());
-    c.SendHTTPResponse("PASS");
-  }, std::move(reserved_port));
+  std::thread t(
+      [](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        EXPECT_EQ("PATCH", c.HTTPRequest().Method());
+        EXPECT_EQ("/ugly", c.HTTPRequest().RawPath());
+        EXPECT_EQ("YES", c.HTTPRequest().Body());
+        c.SendHTTPResponse("PASS");
+      },
+      std::move(reserved_port));
   Connection connection(ClientSocket("localhost", port));
   connection.BlockingWrite("POST /ugly HTTP/1.1\r\n", true);
   connection.BlockingWrite("Host: localhost\r\n", true);
@@ -379,13 +399,15 @@ TEST(PosixHTTPServerTest, SmokeWithMethodInHeader) {
 TEST(PosixHTTPServerTest, SmokeWithLowercaseMethodInLowercaseHeader) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    EXPECT_EQ("PATCH", c.HTTPRequest().Method());
-    EXPECT_EQ("/ugly2", c.HTTPRequest().RawPath());
-    EXPECT_EQ("yes", c.HTTPRequest().Body());
-    c.SendHTTPResponse("Pass");
-  }, std::move(reserved_port));
+  std::thread t(
+      [](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        EXPECT_EQ("PATCH", c.HTTPRequest().Method());
+        EXPECT_EQ("/ugly2", c.HTTPRequest().RawPath());
+        EXPECT_EQ("yes", c.HTTPRequest().Body());
+        c.SendHTTPResponse("Pass");
+      },
+      std::move(reserved_port));
   Connection connection(ClientSocket("localhost", port));
   connection.BlockingWrite("POST /ugly2 HTTP/1.1\r\n", true);
   connection.BlockingWrite("Host: localhost\r\n", true);
@@ -409,14 +431,16 @@ TEST(PosixHTTPServerTest, SmokeNoBodyForPOST) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
   std::atomic_bool thrown(false);
-  std::thread t([&thrown](Socket s) {
-    try {
-      HTTPServerConnection c(s.Accept());
-      ASSERT_TRUE(false);
-    } catch (const current::net::HTTPRequestBodyLengthNotProvided&) {
-      thrown = true;
-    }
-  }, std::move(reserved_port));
+  std::thread t(
+      [&thrown](Socket s) {
+        try {
+          HTTPServerConnection c(s.Accept());
+          ASSERT_TRUE(false);
+        } catch (const current::net::HTTPRequestBodyLengthNotProvided&) {
+          thrown = true;
+        }
+      },
+      std::move(reserved_port));
   Connection connection(ClientSocket("localhost", port));
   connection.BlockingWrite("POST / HTTP/1.1\r\n", true);
   connection.BlockingWrite("Host: localhost\r\n", true);
@@ -438,14 +462,16 @@ TEST(PosixHTTPServerTest, SmokePOSTBodyTooLong) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
   std::atomic_bool thrown(false);
-  std::thread t([&thrown](Socket s) {
-    try {
-      HTTPServerConnection c(s.Accept());
-      ASSERT_TRUE(false);
-    } catch (const current::net::HTTPPayloadTooLarge&) {
-      thrown = true;
-    }
-  }, std::move(reserved_port));
+  std::thread t(
+      [&thrown](Socket s) {
+        try {
+          HTTPServerConnection c(s.Accept());
+          ASSERT_TRUE(false);
+        } catch (const current::net::HTTPPayloadTooLarge&) {
+          thrown = true;
+        }
+      },
+      std::move(reserved_port));
   Connection connection(ClientSocket("localhost", port));
   try {
     connection.BlockingWrite("POST / HTTP/1.1\r\n", true);
@@ -478,12 +504,14 @@ TEST(PosixHTTPServerTest, SmokePOSTBodyTooLong) {
 TEST(PosixHTTPServerTest, LargeBody) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    EXPECT_EQ("POST", c.HTTPRequest().Method());
-    EXPECT_EQ("/", c.HTTPRequest().RawPath());
-    c.SendHTTPResponse(std::string("Data: ") + c.HTTPRequest().Body());
-  }, std::move(reserved_port));
+  std::thread t(
+      [](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        EXPECT_EQ("POST", c.HTTPRequest().Method());
+        EXPECT_EQ("/", c.HTTPRequest().RawPath());
+        c.SendHTTPResponse(std::string("Data: ") + c.HTTPRequest().Body());
+      },
+      std::move(reserved_port));
   std::string body(1000000, '.');
   for (size_t i = 0; i < body.length(); ++i) {
     body[i] = 'A' + (i % 26);
@@ -509,12 +537,14 @@ TEST(PosixHTTPServerTest, LargeBody) {
 TEST(PosixHTTPServerTest, ChunkedLargeBodyManyChunks) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    EXPECT_EQ("POST", c.HTTPRequest().Method());
-    EXPECT_EQ("/", c.HTTPRequest().RawPath());
-    c.SendHTTPResponse(c.HTTPRequest().Body());
-  }, std::move(reserved_port));
+  std::thread t(
+      [](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        EXPECT_EQ("POST", c.HTTPRequest().Method());
+        EXPECT_EQ("/", c.HTTPRequest().RawPath());
+        c.SendHTTPResponse(c.HTTPRequest().Body());
+      },
+      std::move(reserved_port));
   Connection connection(ClientSocket("localhost", port));
   connection.BlockingWrite("POST / HTTP/1.1\r\n", true);
   connection.BlockingWrite("Host: localhost\r\n", true);
@@ -532,13 +562,12 @@ TEST(PosixHTTPServerTest, ChunkedLargeBodyManyChunks) {
     connection.BlockingWrite("\r\n", true);
   }
   connection.BlockingWrite("0\r\n", false);
-  ExpectToReceive(current::strings::Printf(
-                      "HTTP/1.1 200 OK\r\n"
-                      "Content-Type: text/plain\r\n"
-                      "Connection: close\r\n"
-                      "Content-Length: %d\r\n"
-                      "\r\n",
-                      static_cast<int>(body.length())) +
+  ExpectToReceive(current::strings::Printf("HTTP/1.1 200 OK\r\n"
+                                           "Content-Type: text/plain\r\n"
+                                           "Connection: close\r\n"
+                                           "Content-Length: %d\r\n"
+                                           "\r\n",
+                                           static_cast<int>(body.length())) +
                       body,
                   connection);
   t.join();
@@ -572,8 +601,8 @@ TEST(PosixHTTPServerTest, ChunkedSmoke)
       for (uint64_t i = 0; i < chunks; ++i) {
         const uint64_t start = offset + length * i / chunks;
         const uint64_t end = offset + length * (i + 1) / chunks;
-        chunked_body +=
-            current::strings::Printf("%llX\r\n", static_cast<long long>(end - start)) + body.substr(static_cast<size_t>(start), static_cast<size_t>(end - start));
+        chunked_body += current::strings::Printf("%llX\r\n", static_cast<long long>(end - start)) +
+                        body.substr(static_cast<size_t>(start), static_cast<size_t>(end - start));
       }
 
       auto local_reserved_port = current::net::ReserveLocalPort();
@@ -586,13 +615,12 @@ TEST(PosixHTTPServerTest, ChunkedSmoke)
       connection.BlockingWrite("\r\n", true);
       connection.BlockingWrite(chunked_body, true);
       connection.BlockingWrite("0\r\n", false);
-      ExpectToReceive(current::strings::Printf(
-                          "HTTP/1.1 200 OK\r\n"
-                          "Content-Type: text/plain\r\n"
-                          "Connection: close\r\n"
-                          "Content-Length: %d\r\n"
-                          "\r\n",
-                          static_cast<int>(length)) +
+      ExpectToReceive(current::strings::Printf("HTTP/1.1 200 OK\r\n"
+                                               "Content-Type: text/plain\r\n"
+                                               "Connection: close\r\n"
+                                               "Content-Length: %d\r\n"
+                                               "\r\n",
+                                               static_cast<int>(length)) +
                           body.substr(static_cast<size_t>(offset)),
                       connection);
       t.join();
@@ -816,13 +844,15 @@ TEST(PosixHTTPServerTest, DISABLED_InvalidHEXAsChunkSizeDoesNotKillServer)
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
   std::atomic_bool wrong_chunk_size_exception_thrown(false);
-  std::thread t([&wrong_chunk_size_exception_thrown](Socket s) {
-    try {
-      HTTPServerConnection c(s.Accept());
-    } catch (const ChunkSizeNotAValidHEXValue&) {
-      wrong_chunk_size_exception_thrown = true;
-    }
-  }, std::move(reserved_port));
+  std::thread t(
+      [&wrong_chunk_size_exception_thrown](Socket s) {
+        try {
+          HTTPServerConnection c(s.Accept());
+        } catch (const ChunkSizeNotAValidHEXValue&) {
+          wrong_chunk_size_exception_thrown = true;
+        }
+      },
+      std::move(reserved_port));
 
   Connection connection(ClientSocket("localhost", port));
   connection.BlockingWrite("POST / HTTP/1.1\r\n", true);
@@ -848,12 +878,14 @@ TEST(PosixHTTPServerTest, DISABLED_InvalidHEXAsChunkSizeDoesNotKillServer)
 TEST(PosixHTTPServerTest, ChunkedBodyLargeFirstChunk) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    EXPECT_EQ("POST", c.HTTPRequest().Method());
-    EXPECT_EQ("/", c.HTTPRequest().RawPath());
-    c.SendHTTPResponse(c.HTTPRequest().Body());
-  }, std::move(reserved_port));
+  std::thread t(
+      [](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        EXPECT_EQ("POST", c.HTTPRequest().Method());
+        EXPECT_EQ("/", c.HTTPRequest().RawPath());
+        c.SendHTTPResponse(c.HTTPRequest().Body());
+      },
+      std::move(reserved_port));
   Connection connection(ClientSocket("localhost", port));
   connection.BlockingWrite("POST / HTTP/1.1\r\n", true);
   connection.BlockingWrite("Host: localhost\r\n", true);
@@ -870,13 +902,12 @@ TEST(PosixHTTPServerTest, ChunkedBodyLargeFirstChunk) {
     body += chunk;
   }
   connection.BlockingWrite("0\r\n", false);
-  ExpectToReceive(current::strings::Printf(
-                      "HTTP/1.1 200 OK\r\n"
-                      "Content-Type: text/plain\r\n"
-                      "Connection: close\r\n"
-                      "Content-Length: %d\r\n"
-                      "\r\n",
-                      static_cast<int>(body.length())) +
+  ExpectToReceive(current::strings::Printf("HTTP/1.1 200 OK\r\n"
+                                           "Content-Type: text/plain\r\n"
+                                           "Connection: close\r\n"
+                                           "Content-Length: %d\r\n"
+                                           "\r\n",
+                                           static_cast<int>(body.length())) +
                       body,
                   connection);
   t.join();
@@ -885,7 +916,7 @@ TEST(PosixHTTPServerTest, ChunkedBodyLargeFirstChunk) {
 #ifndef CURRENT_WINDOWS
 struct HTTPClientImplCURL {
   static std::string MakeGetRequest(std::thread& server_thread, int port, const std::string& url) {
-    const auto cmd = current::strings::Printf( "curl -s localhost:%d%s", port, url.c_str());
+    const auto cmd = current::strings::Printf("curl -s localhost:%d%s", port, url.c_str());
     const std::string result = current::bricks::system::SystemCallReadPipe(cmd).ReadLine();
     server_thread.join();
     return result;
@@ -895,8 +926,7 @@ struct HTTPClientImplCURL {
                                      int port,
                                      const std::string& url,
                                      const std::string& data) {
-    const auto cmd = current::strings::Printf(
-        "curl -s -d '%s' localhost:%d%s", data.c_str(), port, url.c_str());
+    const auto cmd = current::strings::Printf("curl -s -d '%s' localhost:%d%s", data.c_str(), port, url.c_str());
     const std::string result = current::bricks::system::SystemCallReadPipe(cmd).ReadLine();
     server_thread.join();
     return result;
@@ -955,53 +985,61 @@ TYPED_TEST_CASE(HTTPTest, HTTPClientImplsTypeList);
 TYPED_TEST(HTTPTest, GET) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    EXPECT_EQ("GET", c.HTTPRequest().Method());
-    EXPECT_EQ("/unittest?foo=bar", c.HTTPRequest().RawPath());
-    EXPECT_EQ("/unittest", c.HTTPRequest().URL().path);
-    EXPECT_EQ("bar", c.HTTPRequest().URL().query["foo"]);
-    c.SendHTTPResponse("PASSED");
-  }, std::move(reserved_port));
+  std::thread t(
+      [](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        EXPECT_EQ("GET", c.HTTPRequest().Method());
+        EXPECT_EQ("/unittest?foo=bar", c.HTTPRequest().RawPath());
+        EXPECT_EQ("/unittest", c.HTTPRequest().URL().path);
+        EXPECT_EQ("bar", c.HTTPRequest().URL().query["foo"]);
+        c.SendHTTPResponse("PASSED");
+      },
+      std::move(reserved_port));
   EXPECT_EQ("PASSED", TypeParam::MakeGetRequest(t, port, "/unittest?foo=bar"));
 }
 
 TYPED_TEST(HTTPTest, POST) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    EXPECT_EQ("POST", c.HTTPRequest().Method());
-    EXPECT_EQ("/unittest_post", c.HTTPRequest().RawPath());
-    EXPECT_EQ(7u, c.HTTPRequest().BodyLength());
-    EXPECT_EQ("BAZINGA", c.HTTPRequest().Body());
-    c.SendHTTPResponse("POSTED");
-  }, std::move(reserved_port));
+  std::thread t(
+      [](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        EXPECT_EQ("POST", c.HTTPRequest().Method());
+        EXPECT_EQ("/unittest_post", c.HTTPRequest().RawPath());
+        EXPECT_EQ(7u, c.HTTPRequest().BodyLength());
+        EXPECT_EQ("BAZINGA", c.HTTPRequest().Body());
+        c.SendHTTPResponse("POSTED");
+      },
+      std::move(reserved_port));
   EXPECT_EQ("POSTED", TypeParam::MakePostRequest(t, port, "/unittest_post", "BAZINGA"));
 }
 
 TYPED_TEST(HTTPTest, NoBodyPOST) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    EXPECT_EQ("POST", c.HTTPRequest().Method());
-    EXPECT_EQ("/unittest_empty_post", c.HTTPRequest().RawPath());
-    EXPECT_EQ(0u, c.HTTPRequest().BodyLength());
-    c.SendHTTPResponse("ALMOST_POSTED");
-  }, std::move(reserved_port));
+  std::thread t(
+      [](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        EXPECT_EQ("POST", c.HTTPRequest().Method());
+        EXPECT_EQ("/unittest_empty_post", c.HTTPRequest().RawPath());
+        EXPECT_EQ(0u, c.HTTPRequest().BodyLength());
+        c.SendHTTPResponse("ALMOST_POSTED");
+      },
+      std::move(reserved_port));
   EXPECT_EQ("ALMOST_POSTED", TypeParam::MakePostRequest(t, port, "/unittest_empty_post", ""));
 }
 
 TYPED_TEST(HTTPTest, AttemptsToSendResponseTwice) {
   auto reserved_port = current::net::ReserveLocalPort();
   const int port = reserved_port;
-  std::thread t([](Socket s) {
-    HTTPServerConnection c(s.Accept());
-    c.SendHTTPResponse("one");
-    ASSERT_THROW(c.SendHTTPResponse("two"), AttemptedToSendHTTPResponseMoreThanOnce);
-    ASSERT_THROW(c.SendChunkedHTTPResponse().Send("three"), AttemptedToSendHTTPResponseMoreThanOnce);
-  }, std::move(reserved_port));
+  std::thread t(
+      [](Socket s) {
+        HTTPServerConnection c(s.Accept());
+        c.SendHTTPResponse("one");
+        ASSERT_THROW(c.SendHTTPResponse("two"), AttemptedToSendHTTPResponseMoreThanOnce);
+        ASSERT_THROW(c.SendChunkedHTTPResponse().Send("three"), AttemptedToSendHTTPResponseMoreThanOnce);
+      },
+      std::move(reserved_port));
   EXPECT_EQ("one", TypeParam::MakeGetRequest(t, port, "/"));
 }
 
diff --git a/bricks/net/tcp/impl/posix.h b/bricks/net/tcp/impl/posix.h
index 764d260ec..1c1a6bf5e 100644
--- a/bricks/net/tcp/impl/posix.h
+++ b/bricks/net/tcp/impl/posix.h
@@ -24,11 +24,11 @@ SOFTWARE.
 
 #if 0
 
-# NOTE(dkorolev): I have tested the `ReserveLocalPort` logic in the following way.
-# Step one: build.
+#NOTE(dkorolev) : I have tested the `ReserveLocalPort` logic in the following way.
+#Step one : build.
 g++ -g -std=c++17 -W -Wall -Wno-strict-aliasing   -o ".current/test" "test.cc" -pthread -ldl
 ulimit -c unlimited
-# Step two: run in two terminals in parallel.
+#Step two : run in two terminals in parallel.
 rm -f core ; while true ; do ./.current/test --gtest_throw_on_failure --gtest_catch_exceptions=0 || break ; done
 
 #endif
@@ -108,9 +108,8 @@ enum class BarePort : uint16_t {};
 class SocketHandle : private SocketSystemInitializer {
  private:
   struct InternalInit final {};
-  explicit SocketHandle(InternalInit,
-                        NagleAlgorithm nagle_algorithm_policy = kDefaultNagleAlgorithmPolicy)
-    : socket_(::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) {
+  explicit SocketHandle(InternalInit, NagleAlgorithm nagle_algorithm_policy = kDefaultNagleAlgorithmPolicy)
+      : socket_(::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) {
     if (socket_ < 0) {
       CURRENT_THROW(SocketCreateException());  // LCOV_EXCL_LINE -- Not covered by unit tests.
     }
@@ -126,11 +125,7 @@ class SocketHandle : private SocketSystemInitializer {
     // NOTE(dkorolev): On Windows, `SO_REUSEADDR` is unnecessary.
     // First, local ports can be reused right away, so it doesn't win anything.
     // Second, on Windows this setting allows binding the second socket to the same port, which is just bad.
-    if (::setsockopt(socket_,
-                     SOL_SOCKET,
-                     SO_REUSEADDR,
-                     &just_one,
-                     sizeof(just_one))) {
+    if (::setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR, &just_one, sizeof(just_one))) {
       CURRENT_THROW(SocketCreateException());  // LCOV_EXCL_LINE -- Not covered by the unit tests.
     }
 #endif
@@ -154,7 +149,6 @@ class SocketHandle : private SocketSystemInitializer {
       }
     }
     // LCOV_EXCL_STOP
-    
   }
 
  public:
@@ -188,7 +182,7 @@ class SocketHandle : private SocketSystemInitializer {
 
   struct DoNotBind final {};
   explicit SocketHandle(DoNotBind, NagleAlgorithm nagle_algorithm_policy = kDefaultNagleAlgorithmPolicy)
-        : SocketHandle(InternalInit(), nagle_algorithm_policy) {}
+      : SocketHandle(InternalInit(), nagle_algorithm_policy) {}
 
   struct FromAcceptedHandle final {
     SOCKET handle;
@@ -215,9 +209,7 @@ class SocketHandle : private SocketSystemInitializer {
     }
   }
 
-  explicit SocketHandle(SocketHandle&& rhs) : socket_(static_cast<SOCKET>(-1)) {
-    std::swap(socket_, rhs.socket_);
-  }
+  explicit SocketHandle(SocketHandle&& rhs) : socket_(static_cast<SOCKET>(-1)) { std::swap(socket_, rhs.socket_); }
 
  private:
   friend class Socket;
@@ -295,11 +287,10 @@ class ReservedLocalPort final : public current::net::SocketHandle {
  public:
   struct Construct final {};
   ReservedLocalPort() = delete;
-  ReservedLocalPort(Construct, uint16_t port, current::net::SocketHandle&& socket) : super_t(std::move(socket)), port_(port) {}
+  ReservedLocalPort(Construct, uint16_t port, current::net::SocketHandle&& socket)
+      : super_t(std::move(socket)), port_(port) {}
   ReservedLocalPort(const ReservedLocalPort&) = delete;
-  ReservedLocalPort(ReservedLocalPort&& rhs) : super_t(std::move(rhs)), port_(rhs.port_) {
-    rhs.port_ = 0;
-  }
+  ReservedLocalPort(ReservedLocalPort&& rhs) : super_t(std::move(rhs)), port_(rhs.port_) { rhs.port_ = 0; }
   ReservedLocalPort& operator=(const ReservedLocalPort&) = delete;
   ReservedLocalPort& operator=(ReservedLocalPort&&) = delete;
   operator uint16_t() const { return port_; }
@@ -323,10 +314,9 @@ class ReserveLocalPortImpl final {
     index_ = 0u;
   }
 
-  current::net::ReservedLocalPort DoIt(
-      uint16_t hint,
-      NagleAlgorithm nagle_algorithm_policy,
-      MaxServerQueuedConnectionsValue max_connections) {
+  current::net::ReservedLocalPort DoIt(uint16_t hint,
+                                       NagleAlgorithm nagle_algorithm_policy,
+                                       MaxServerQueuedConnectionsValue max_connections) {
     size_t save_index = index_;
     bool keep_searching = true;
     while (keep_searching) {
@@ -350,13 +340,12 @@ class ReserveLocalPortImpl final {
         return retval;
       }();
       try {
-        current::net::SocketHandle try_to_hold_port(current::net::SocketHandle::BindAndListen(), 
+        current::net::SocketHandle try_to_hold_port(current::net::SocketHandle::BindAndListen(),
                                                     BarePort(candidate_port),
                                                     nagle_algorithm_policy,
                                                     max_connections);
-        return current::net::ReservedLocalPort(current::net::ReservedLocalPort::Construct(),
-                                          candidate_port,
-                                          std::move(try_to_hold_port));
+        return current::net::ReservedLocalPort(
+            current::net::ReservedLocalPort::Construct(), candidate_port, std::move(try_to_hold_port));
       } catch (const current::net::SocketConnectException&) {
         // Keep trying.
         // std::cerr << "Failed in `connect`." << candidate_port << '\n';
@@ -374,7 +363,7 @@ class ReserveLocalPortImpl final {
   }
 };
 
-}  // namespace current::net::impl
+}  // namespace impl
 
 // Pick an available local port.
 [[nodiscard]] inline ReservedLocalPort ReserveLocalPort(
@@ -387,7 +376,8 @@ class ReserveLocalPortImpl final {
     uint16_t hint,
     NagleAlgorithm nagle_algorithm_policy = kDefaultNagleAlgorithmPolicy,
     MaxServerQueuedConnectionsValue max_connections = kMaxServerQueuedConnections) {
-  return current::ThreadLocalSingleton<impl::ReserveLocalPortImpl>().DoIt(hint, nagle_algorithm_policy, max_connections);
+  return current::ThreadLocalSingleton<impl::ReserveLocalPortImpl>().DoIt(
+      hint, nagle_algorithm_policy, max_connections);
 }
 
 class Connection : public SocketHandle {
@@ -411,9 +401,7 @@ class Connection : public SocketHandle {
   enum BlockingReadPolicy { ReturnASAP = false, FillFullBuffer = true };
   template <typename T>
   inline std::enable_if_t<sizeof(T) == 1, size_t> BlockingRead(
-      T* output_buffer,
-      size_t max_length,
-      BlockingReadPolicy policy = BlockingReadPolicy::ReturnASAP) {
+      T* output_buffer, size_t max_length, BlockingReadPolicy policy = BlockingReadPolicy::ReturnASAP) {
     if (max_length == 0) {
       return 0;  // LCOV_EXCL_LINE
     } else {
@@ -580,8 +568,7 @@ class Socket final : public SocketHandle {
   explicit Socket(BarePort bare_port,
                   NagleAlgorithm nagle_algorithm_policy = kDefaultNagleAlgorithmPolicy,
                   MaxServerQueuedConnectionsValue max_connections = kMaxServerQueuedConnections)
-      : SocketHandle(SocketHandle::BindAndListen(), bare_port, nagle_algorithm_policy, max_connections) {
-  }
+      : SocketHandle(SocketHandle::BindAndListen(), bare_port, nagle_algorithm_policy, max_connections) {}
 
   explicit Socket(ReservedLocalPort&& reserved_port) : SocketHandle(std::move(reserved_port)) {}
 
@@ -637,7 +624,7 @@ namespace addrinfo_t_impl {
 struct Deleter {
   void operator()(struct addrinfo* ptr) { ::freeaddrinfo(ptr); }
 };
-}
+}  // namespace addrinfo_t_impl
 using addrinfo_t = std::unique_ptr<struct addrinfo, addrinfo_t_impl::Deleter>;
 
 inline addrinfo_t GetAddrInfo(const std::string& host, const std::string& serv = "") {
@@ -671,7 +658,7 @@ inline Connection ClientSocket(const std::string& host, T port_or_serv) {
   class ClientSocket final : public SocketHandle {
    public:
     explicit ClientSocket(const std::string& host,
-                          const std::string& serv, 
+                          const std::string& serv,
                           NagleAlgorithm nagle_algorithm_policy = kDefaultNagleAlgorithmPolicy)
         : SocketHandle(SocketHandle::DoNotBind(), nagle_algorithm_policy) {
       CURRENT_BRICKS_NET_LOG("S%05d ", static_cast<SOCKET>(socket));
diff --git a/bricks/net/tcp/test.cc b/bricks/net/tcp/test.cc
index 55e21c895..9b9ee93d3 100644
--- a/bricks/net/tcp/test.cc
+++ b/bricks/net/tcp/test.cc
@@ -41,15 +41,15 @@ using std::string;
 using std::to_string;
 using std::vector;
 
-using std::this_thread::sleep_for;
 using std::chrono::milliseconds;
+using std::this_thread::sleep_for;
 
-using current::strings::Printf;
 using current::Singleton;
-using current::net::Socket;
-using current::net::Connection;
 using current::net::ClientSocket;
+using current::net::Connection;
 using current::net::ResolveIPFromHostname;
+using current::net::Socket;
+using current::strings::Printf;
 
 using current::net::AttemptedToUseMovedAwayConnection;
 using current::net::SocketBindException;
@@ -79,44 +79,38 @@ static void ExpectFromSocket(const std::string& golden,
                              const string& host,
                              const uint16_t port,
                              const string& message_to_send_from_client = "") {
-  ExpectFromSocket(golden,
-                   server_thread,
-                   host,
-                   port,
-                   [&message_to_send_from_client](Connection& connection) {
-                     if (!message_to_send_from_client.empty()) {
-                       connection.BlockingWrite(message_to_send_from_client, false);
-                     }
-                   });
+  ExpectFromSocket(golden, server_thread, host, port, [&message_to_send_from_client](Connection& connection) {
+    if (!message_to_send_from_client.empty()) {
+      connection.BlockingWrite(message_to_send_from_client, false);
+    }
+  });
 }
 
 static void ExpectFromSocket(const std::string& golden,
                              std::thread& server_thread,
                              const uint16_t port,
                              const string& message_to_send_from_client = "") {
-  ExpectFromSocket(golden,
-                   server_thread,
-                   "localhost",
-                   port,
-                   [&message_to_send_from_client](Connection& connection) {
-                     if (!message_to_send_from_client.empty()) {
-                       connection.BlockingWrite(message_to_send_from_client, false);
-                     }
-                   });
+  ExpectFromSocket(golden, server_thread, "localhost", port, [&message_to_send_from_client](Connection& connection) {
+    if (!message_to_send_from_client.empty()) {
+      connection.BlockingWrite(message_to_send_from_client, false);
+    }
+  });
 }
 
 TEST(TCPTest, IPAndPort) {
   current::net::ReservedLocalPort port_reservation = ReserveLocalPort();
   const uint16_t port_number = port_reservation;
 
-  std::thread server([port_number](Socket socket) {
-    Connection connection = socket.Accept();
-    EXPECT_EQ("127.0.0.1", connection.LocalIPAndPort().ip);
-    EXPECT_EQ(port_number, connection.LocalIPAndPort().port);
-    EXPECT_EQ("127.0.0.1", connection.RemoteIPAndPort().ip);
-    EXPECT_LT(0, connection.RemoteIPAndPort().port);
-    connection.BlockingWrite("42", false);
-  }, Socket(std::move(port_reservation)));
+  std::thread server(
+      [port_number](Socket socket) {
+        Connection connection = socket.Accept();
+        EXPECT_EQ("127.0.0.1", connection.LocalIPAndPort().ip);
+        EXPECT_EQ(port_number, connection.LocalIPAndPort().port);
+        EXPECT_EQ("127.0.0.1", connection.RemoteIPAndPort().ip);
+        EXPECT_LT(0, connection.RemoteIPAndPort().port);
+        connection.BlockingWrite("42", false);
+      },
+      Socket(std::move(port_reservation)));
   Connection client(ClientSocket("127.0.0.1", port_number));
   EXPECT_EQ("127.0.0.1", client.LocalIPAndPort().ip);
   EXPECT_LT(0, client.LocalIPAndPort().port);
@@ -146,12 +140,14 @@ TEST(TCPTest, ReceiveMessageOfTwoParts) {
 TEST(TCPTest, ReceiveDelayedMessage) {
   current::net::ReservedLocalPort port_reservation = ReserveLocalPort();
   const uint16_t port_number = port_reservation;
-  std::thread server([](Socket socket) {
-    Connection connection = socket.Accept();
-    connection.BlockingWrite("BLA", true);
-    sleep_for(milliseconds(1));
-    connection.BlockingWrite("H", false);
-  }, std::move(port_reservation));
+  std::thread server(
+      [](Socket socket) {
+        Connection connection = socket.Accept();
+        connection.BlockingWrite("BLA", true);
+        sleep_for(milliseconds(1));
+        connection.BlockingWrite("H", false);
+      },
+      std::move(port_reservation));
   Connection client(ClientSocket("localhost", port_number));
   char response[5] = "????";
   ASSERT_EQ(4u, client.BlockingRead(response, 4, Connection::FillFullBuffer));
@@ -162,14 +158,16 @@ TEST(TCPTest, ReceiveDelayedMessage) {
 TEST(TCPTest, ReceiveMessageAsResponse) {
   current::net::ReservedLocalPort port_reservation = ReserveLocalPort();
   const uint16_t port_number = port_reservation;
-  std::thread server([](Socket socket) {
-    Connection connection = socket.Accept();
-    connection.BlockingWrite("{", true);
-    char buffer[2];  // Wait for three incoming bytes before sending data out.
-    ASSERT_EQ(2u, connection.BlockingRead(buffer, 2, Connection::FillFullBuffer));
-    connection.BlockingWrite(buffer, 2, true);
-    connection.BlockingWrite("}", false);
-  }, std::move(port_reservation));
+  std::thread server(
+      [](Socket socket) {
+        Connection connection = socket.Accept();
+        connection.BlockingWrite("{", true);
+        char buffer[2];  // Wait for three incoming bytes before sending data out.
+        ASSERT_EQ(2u, connection.BlockingRead(buffer, 2, Connection::FillFullBuffer));
+        connection.BlockingWrite(buffer, 2, true);
+        connection.BlockingWrite("}", false);
+      },
+      std::move(port_reservation));
   Connection client(ClientSocket("localhost", port_number));
   client.BlockingWrite("!?", false);
   char response[5] = "????";
@@ -181,12 +179,14 @@ TEST(TCPTest, ReceiveMessageAsResponse) {
 TEST(TCPTest, CanNotUseMovedAwayConnection) {
   current::net::ReservedLocalPort port_reservation = ReserveLocalPort();
   const uint16_t port_number = port_reservation;
-  std::thread server([](Socket socket) {
-    Connection connection = socket.Accept();
-    char buffer[3];  // Wait for three incoming bytes before sending data out.
-    ASSERT_EQ(3u, connection.BlockingRead(buffer, 3, Connection::FillFullBuffer));
-    connection.BlockingWrite("OK", false);
-  }, std::move(port_reservation));
+  std::thread server(
+      [](Socket socket) {
+        Connection connection = socket.Accept();
+        char buffer[3];  // Wait for three incoming bytes before sending data out.
+        ASSERT_EQ(3u, connection.BlockingRead(buffer, 3, Connection::FillFullBuffer));
+        connection.BlockingWrite("OK", false);
+      },
+      std::move(port_reservation));
   Connection old_connection(ClientSocket("localhost", port_number));
   old_connection.BlockingWrite("1", true);
   Connection new_connection(std::move(old_connection));
@@ -204,59 +204,63 @@ TEST(TCPTest, ReceiveMessageOfTwoUInt16AndTestEndianness) {
   // NOTE(dkorolev): This tests endianness as well.
   current::net::ReservedLocalPort port_reservation = ReserveLocalPort();
   const uint16_t port_number = port_reservation;
-  std::thread server_thread([](Socket socket) {
-    socket.Accept().BlockingWrite(vector<uint16_t>{0x3031, 0x3233}, false);
-  }, std::move(port_reservation));
+  std::thread server_thread(
+      [](Socket socket) {
+        socket.Accept().BlockingWrite(vector<uint16_t>{0x3031, 0x3233}, false);
+      },
+      std::move(port_reservation));
   ExpectFromSocket("1032", server_thread, port_number);
 }
 
 TEST(TCPTest, EchoMessage) {
   current::net::ReservedLocalPort port_reservation = ReserveLocalPort();
   const uint16_t port_number = port_reservation;
-  std::thread server_thread([](Socket socket) {
-    Connection connection(socket.Accept());
-    std::vector<char> s(7);
-    ASSERT_EQ(s.size(), connection.BlockingRead(&s[0], s.size(), Connection::FillFullBuffer));
-    connection.BlockingWrite("ECHO: " + std::string(s.begin(), s.end()), false);
-  }, std::move(port_reservation));
+  std::thread server_thread(
+      [](Socket socket) {
+        Connection connection(socket.Accept());
+        std::vector<char> s(7);
+        ASSERT_EQ(s.size(), connection.BlockingRead(&s[0], s.size(), Connection::FillFullBuffer));
+        connection.BlockingWrite("ECHO: " + std::string(s.begin(), s.end()), false);
+      },
+      std::move(port_reservation));
   ExpectFromSocket("ECHO: TEST OK", server_thread, port_number, std::string("TEST OK"));
 }
 
 TEST(TCPTest, EchoThreeMessages) {
   current::net::ReservedLocalPort port_reservation = ReserveLocalPort();
   const uint16_t port_number = port_reservation;
-  std::thread server_thread([](Socket socket) {
-    const size_t block_length = 3;
-    string s(block_length, ' ');
-    Connection connection(socket.Accept());
-    for (int i = 0; i < 3; ++i) {
-      ASSERT_EQ(block_length, connection.BlockingRead(&s[0], block_length, Connection::FillFullBuffer));
-      connection.BlockingWrite(i > 0 ? "," : "ECHO: ", true);
-      connection.BlockingWrite(s, false);
-    }
-  }, std::move(port_reservation));
-  ExpectFromSocket("ECHO: FOO,BAR,BAZ",
-                   server_thread,
-                   "localhost",
-                   port_number,
-                   [](Connection& connection) {
-                     connection.BlockingWrite("FOOBARB", true);
-                     sleep_for(milliseconds(1));
-                     connection.BlockingWrite("A", true);
-                     sleep_for(milliseconds(1));
-                     connection.BlockingWrite("Z", false);
-                   });
+  std::thread server_thread(
+      [](Socket socket) {
+        const size_t block_length = 3;
+        string s(block_length, ' ');
+        Connection connection(socket.Accept());
+        for (int i = 0; i < 3; ++i) {
+          ASSERT_EQ(block_length, connection.BlockingRead(&s[0], block_length, Connection::FillFullBuffer));
+          connection.BlockingWrite(i > 0 ? "," : "ECHO: ", true);
+          connection.BlockingWrite(s, false);
+        }
+      },
+      std::move(port_reservation));
+  ExpectFromSocket("ECHO: FOO,BAR,BAZ", server_thread, "localhost", port_number, [](Connection& connection) {
+    connection.BlockingWrite("FOOBARB", true);
+    sleep_for(milliseconds(1));
+    connection.BlockingWrite("A", true);
+    sleep_for(milliseconds(1));
+    connection.BlockingWrite("Z", false);
+  });
 }
 
 TEST(TCPTest, EchoLongMessageTestsDynamicBufferGrowth) {
   current::net::ReservedLocalPort port_reservation = ReserveLocalPort();
   const uint16_t port_number = port_reservation;
-  std::thread server_thread([](Socket socket) {
-    Connection connection(socket.Accept());
-    std::vector<char> s(10000);
-    ASSERT_EQ(s.size(), connection.BlockingRead(&s[0], s.size(), Connection::FillFullBuffer));
-    connection.BlockingWrite("ECHO: " + std::string(s.begin(), s.end()), false);
-  }, std::move(port_reservation));
+  std::thread server_thread(
+      [](Socket socket) {
+        Connection connection(socket.Accept());
+        std::vector<char> s(10000);
+        ASSERT_EQ(s.size(), connection.BlockingRead(&s[0], s.size(), Connection::FillFullBuffer));
+        connection.BlockingWrite("ECHO: " + std::string(s.begin(), s.end()), false);
+      },
+      std::move(port_reservation));
   std::string message;
   for (size_t i = 0; i < 10000; ++i) {
     message += '0' + (i % 10);
@@ -309,12 +313,14 @@ TEST(TCPTest, CanNotBindTwoSocketsToTheSamePortSimultaneously) {
 TEST(TCPTest, WriteExceptionWhileWritingAVeryLongMessage) {
   auto port_reservation = ReserveLocalPort();
   const uint16_t port_number = port_reservation;
-  std::thread server_thread([](Socket socket) {
-    Connection connection(socket.Accept());
-    char buffer[3];
-    connection.BlockingRead(buffer, 3, Connection::FillFullBuffer);
-    connection.BlockingWrite("Done, thanks.\n", false);
-  }, Socket(std::move(port_reservation)));
+  std::thread server_thread(
+      [](Socket socket) {
+        Connection connection(socket.Accept());
+        char buffer[3];
+        connection.BlockingRead(buffer, 3, Connection::FillFullBuffer);
+        connection.BlockingWrite("Done, thanks.\n", false);
+      },
+      Socket(std::move(port_reservation)));
   // Attempt to send a very long message to ensure it does not fit OS buffers.
   Connection connection(ClientSocket("localhost", port_number));
   ASSERT_THROW(connection.BlockingWrite(std::vector<char>(100 * 1000 * 1000, '!'), true),
@@ -347,12 +353,12 @@ TEST(TCPTest, PickLocalPort) {
 }
 
 #if 0
-# NOTE(dkorolev): This test will fail if the following command is run from two terminals concurrently.
+#NOTE(dkorolev) : This test will fail if the following command is run from two terminals concurrently.
 while true ; do ./.current/test \
   --gtest_filter=TCPTest.PickLocalPortWithHint \
   --gtest_throw_on_failure \
   --gtest_catch_exceptions=0 || break ; done
-# The above test, `TCPTest.PickLocalPort`, would run just fine in such a scenario.
+#The above test, `TCPTest.PickLocalPort`, would run just fine in such a scenario.
 #endif
 
 TEST(TCPTest, PickLocalPortWithHint) {
diff --git a/bricks/strings/chunk.h b/bricks/strings/chunk.h
index ca7c85602..ee5b4a7db 100644
--- a/bricks/strings/chunk.h
+++ b/bricks/strings/chunk.h
@@ -166,12 +166,8 @@ class Chunk {
   typedef EqualityComparator Pride;  // Your favorite equality smiley here. Mine is *HAWAII*, because rainbow.
 
   // Still allow comparing `Chunk`-s to `std::string`-s, for purely code readability purposes.
-  bool operator==(const std::string& rhs) const {
-    return N == rhs.length() && ::memcmp(S, rhs.c_str(), N) == 0;
-  }
-  bool operator!=(const std::string& rhs) const {
-    return !operator==(rhs);
-  }
+  bool operator==(const std::string& rhs) const { return N == rhs.length() && ::memcmp(S, rhs.c_str(), N) == 0; }
+  bool operator!=(const std::string& rhs) const { return !operator==(rhs); }
 
  private:
   const char* S;
diff --git a/bricks/strings/fixed_size_serializer.h b/bricks/strings/fixed_size_serializer.h
index db2e35966..c667e997e 100644
--- a/bricks/strings/fixed_size_serializer.h
+++ b/bricks/strings/fixed_size_serializer.h
@@ -40,8 +40,9 @@ namespace strings {
 
 struct FixedSizeSerializerEnabler {};
 template <typename T>
-struct FixedSizeSerializer : std::enable_if_t<std::is_unsigned<T>::value && std::is_integral<T>::value && (sizeof(T) > 1),
-                                              FixedSizeSerializerEnabler> {
+struct FixedSizeSerializer
+    : std::enable_if_t<std::is_unsigned<T>::value && std::is_integral<T>::value && (sizeof(T) > 1),
+                       FixedSizeSerializerEnabler> {
   enum { size_in_bytes = std::numeric_limits<T>::digits10 + 1 };
   static std::string PackToString(T x) {
     std::ostringstream os;
@@ -67,7 +68,7 @@ inline const T& UnpackFromString(std::string const& s, T& x) {
   return x;
 }
 
-}  // namespace string
+}  // namespace strings
 }  // namespace current
 
 #endif  // BRICKS_STRINGS_FIXED_SIZE_SERIALIZER_H
diff --git a/bricks/strings/group_by_lines.h b/bricks/strings/group_by_lines.h
index e3bb6463b..ae25ff0c6 100644
--- a/bricks/strings/group_by_lines.h
+++ b/bricks/strings/group_by_lines.h
@@ -90,12 +90,10 @@ class GenericStatefulGroupByLines final {
       PROCESSOR::DoProcess(std::move(extracted), f_);
     }
   }
-  
+
  public:
   explicit GenericStatefulGroupByLines(F&& f) : f_(std::move(f)) {}
-  void Feed(const std::string& s) {
-    Feed(s.c_str());
-  }
+  void Feed(const std::string& s) { Feed(s.c_str()); }
   void Feed(const char* s) {
     if (done_called_) {
       CURRENT_THROW(GroupByLinesFeedCaledAfterDone());
@@ -159,82 +157,71 @@ class GenericStatefulGroupByLines final {
   }
 };
 
-using StatefulGroupByLines =
-  GenericStatefulGroupByLines<std::function<void(std::string&&)>,
-                              GroupByLinesExceptions::Prohibit,
-                              GenericStatefulGroupByLinesProcessCPPString>;
-using StatefulGroupByLinesCStringProcessing =
-  GenericStatefulGroupByLines<std::function<void(const char*)>,
-                              GroupByLinesExceptions::Prohibit,
-                              GenericStatefulGroupByLinesProcessCString>;
-
-using ExceptionFriendlyStatefulGroupByLines =
-  GenericStatefulGroupByLines<std::function<void(std::string&&)>,
-                              GroupByLinesExceptions::Allow,
-                              GenericStatefulGroupByLinesProcessCPPString>;
+using StatefulGroupByLines = GenericStatefulGroupByLines<std::function<void(std::string&&)>,
+                                                         GroupByLinesExceptions::Prohibit,
+                                                         GenericStatefulGroupByLinesProcessCPPString>;
+using StatefulGroupByLinesCStringProcessing = GenericStatefulGroupByLines<std::function<void(const char*)>,
+                                                                          GroupByLinesExceptions::Prohibit,
+                                                                          GenericStatefulGroupByLinesProcessCString>;
+
+using ExceptionFriendlyStatefulGroupByLines = GenericStatefulGroupByLines<std::function<void(std::string&&)>,
+                                                                          GroupByLinesExceptions::Allow,
+                                                                          GenericStatefulGroupByLinesProcessCPPString>;
 using ExceptionFriendlyStatefulGroupByLinesCStringProcessing =
-  GenericStatefulGroupByLines<std::function<void(const char*)>,
-                              GroupByLinesExceptions::Allow,
-                              GenericStatefulGroupByLinesProcessCString>;
+    GenericStatefulGroupByLines<std::function<void(const char*)>,
+                                GroupByLinesExceptions::Allow,
+                                GenericStatefulGroupByLinesProcessCString>;
 
 template <class F, GroupByLinesExceptions E, bool CPP_STRING, bool C_STRING>
 struct CreateStatefulGroupByLinesImpl;
 
 template <class F, GroupByLinesExceptions E>
 struct CreateStatefulGroupByLinesImpl<F, E, true, true> final {
-  using type_t = GenericStatefulGroupByLines<std::function<void(std::string&&)>,
-                                             E,
-                                             GenericStatefulGroupByLinesProcessCPPString>;
-  static type_t DoIt(F&& f) {
-    return type_t(std::forward<F>(f));
-  }
+  using type_t =
+      GenericStatefulGroupByLines<std::function<void(std::string&&)>, E, GenericStatefulGroupByLinesProcessCPPString>;
+  static type_t DoIt(F&& f) { return type_t(std::forward<F>(f)); }
 };
 
 template <class F, GroupByLinesExceptions E, bool B>
 struct CreateStatefulGroupByLinesImpl<F, E, false, B> final {
-  using type_t = GenericStatefulGroupByLines<std::function<void(const char*)>,
-                                             E,
-                                             GenericStatefulGroupByLinesProcessCString>;
-  static type_t DoIt(F&& f) {
-    return type_t(std::forward<F>(f));
-  }
+  using type_t =
+      GenericStatefulGroupByLines<std::function<void(const char*)>, E, GenericStatefulGroupByLinesProcessCString>;
+  static type_t DoIt(F&& f) { return type_t(std::forward<F>(f)); }
 };
 
 #ifndef CURRENT_FOR_CPP14
 template <class F>
 auto CreateStatefulGroupByLines(F&& f) {
-  return CreateStatefulGroupByLinesImpl<
-            F,
-            GroupByLinesExceptions::Prohibit,
-            std::is_invocable<F, std::string&&>::value,
-            std::is_invocable<F, const char*>::value>::DoIt(std::forward<F>(f));
+  return CreateStatefulGroupByLinesImpl<F,
+                                        GroupByLinesExceptions::Prohibit,
+                                        std::is_invocable<F, std::string&&>::value,
+                                        std::is_invocable<F, const char*>::value>::DoIt(std::forward<F>(f));
 }
 
 template <class F>
 auto CreateExceptionFriendlyStatefulGroupByLines(F&& f) {
-  return CreateStatefulGroupByLinesImpl<
-            F,
-            GroupByLinesExceptions::Allow,
-            std::is_invocable<F, std::string&&>::value,
-            std::is_invocable<F, const char*>::value>::DoIt(std::forward<F>(f));
+  return CreateStatefulGroupByLinesImpl<F,
+                                        GroupByLinesExceptions::Allow,
+                                        std::is_invocable<F, std::string&&>::value,
+                                        std::is_invocable<F, const char*>::value>::DoIt(std::forward<F>(f));
 }
 #else
 template <class F>
 auto CreateStatefulGroupByLines(F&& f) {
   return CreateStatefulGroupByLinesImpl<
-            F,
-            GroupByLinesExceptions::Prohibit,
-            current::weed::call_with<F, std::string&&>::implemented,
-            current::weed::call_with<F, const char*>::implemented>::DoIt(std::forward<F>(f));
+      F,
+      GroupByLinesExceptions::Prohibit,
+      current::weed::call_with<F, std::string&&>::implemented,
+      current::weed::call_with<F, const char*>::implemented>::DoIt(std::forward<F>(f));
 }
 
 template <class F>
 auto CreateExceptionFriendlyStatefulGroupByLines(F&& f) {
   return CreateStatefulGroupByLinesImpl<
-            F,
-            GroupByLinesExceptions::Allow,
-            current::weed::call_with<F, std::string&&>::implemented,
-            current::weed::call_with<F, const char*>::implemented>::DoIt(std::forward<F>(f));
+      F,
+      GroupByLinesExceptions::Allow,
+      current::weed::call_with<F, std::string&&>::implemented,
+      current::weed::call_with<F, const char*>::implemented>::DoIt(std::forward<F>(f));
 }
 #endif  // CURRENT_FOR_CPP14
 
diff --git a/bricks/strings/join.h b/bricks/strings/join.h
index 41f747728..5d72ba304 100644
--- a/bricks/strings/join.h
+++ b/bricks/strings/join.h
@@ -65,9 +65,10 @@ template <typename T, typename = void>
 struct is_container : std::false_type {};
 
 template <typename T>
-struct is_container<T, std::void_t<decltype(std::declval<T>().begin()),
-                                   decltype(std::declval<T>().end()),
-                                   typename T::value_type>> : std::true_type {};
+struct is_container<
+    T,
+    std::void_t<decltype(std::declval<T>().begin()), decltype(std::declval<T>().end()), typename T::value_type>>
+    : std::true_type {};
 
 #ifndef CURRENT_FOR_CPP14
 
@@ -105,7 +106,7 @@ template <typename CONTAINER, typename SEPARATOR>
 void OptionallyReserveOutputBuffer(std::string& output, const CONTAINER& components, SEPARATOR&& separator) {
 #ifndef CURRENT_FOR_CPP14
   // Note: this implementation does not do `reserve()` for chars, the length of which is always known to be 1.
-  if constexpr(sfinae::is_container_of_strings_v<CONTAINER>) {
+  if constexpr (sfinae::is_container_of_strings_v<CONTAINER>) {
     if (!components.empty()) {
       size_t length = 0;
       for (const auto& cit : components) {
diff --git a/bricks/strings/printf.h b/bricks/strings/printf.h
index 700f2e63b..f346ceefd 100644
--- a/bricks/strings/printf.h
+++ b/bricks/strings/printf.h
@@ -39,7 +39,8 @@ namespace strings {
 #ifdef __GNUC__
 __attribute__((__format__(__printf__, 1, 2)))
 #endif
-inline std::string Printf(const char *fmt, ...) {
+inline std::string
+Printf(const char *fmt, ...) {
   // Most of the platforms now support thread locals, so 64Kb buffer seems reasonable.
   constexpr int max_string_length_for_static_buffer = 64 * 1024 - 1;
   // Absolute limit on result size is 1Mb.
@@ -67,7 +68,8 @@ inline std::string Printf(const char *fmt, ...) {
   }
 #else
   va_start(ap, fmt);
-  const int res = _vsnprintf_s(buffer, max_string_length_for_static_buffer + 1, max_string_length_for_static_buffer, fmt, ap);
+  const int res =
+      _vsnprintf_s(buffer, max_string_length_for_static_buffer + 1, max_string_length_for_static_buffer, fmt, ap);
   va_end(ap);
   if (res < 0 || errno == ERANGE) {
     va_start(ap, fmt);
diff --git a/bricks/strings/regex.h b/bricks/strings/regex.h
index 64d8ac0fe..aca81a9e0 100644
--- a/bricks/strings/regex.h
+++ b/bricks/strings/regex.h
@@ -43,8 +43,7 @@ struct IterateByRegexMatches {
       : copy_of_string_if_needed_(s), begin_(copy_of_string_if_needed_.begin(), copy_of_string_if_needed_.end(), re) {}
 
   template <typename T>
-  IterateByRegexMatches(const std::regex& re, T&& s)
-      : begin_(s.begin(), s.end(), re) {}
+  IterateByRegexMatches(const std::regex& re, T&& s) : begin_(s.begin(), s.end(), re) {}
 
   std::sregex_iterator begin() const { return begin_; }
   std::sregex_iterator end() const { return end_; }
@@ -106,17 +105,14 @@ class NamedRegexCapturer {
     std::smatch match;
 
     MatchResult(std::string input_string, std::shared_ptr<NamedRegexCapturer::Data> data)
-        : owned_string(std::make_unique<std::string>(std::move(input_string))),
-          data(std::move(data)) {}
+        : owned_string(std::make_unique<std::string>(std::move(input_string))), data(std::move(data)) {}
 
     MatchResult() = delete;
     MatchResult(MatchResult const&) = delete;
     MatchResult& operator=(MatchResult const&) = delete;
 
     MatchResult(MatchResult&& rhs)
-        : owned_string(std::move(rhs.owned_string)),
-          data(rhs.data),
-          match(std::move(rhs.match)) {}
+        : owned_string(std::move(rhs.owned_string)), data(rhs.data), match(std::move(rhs.match)) {}
 
     MatchResult& operator=(MatchResult&& rhs) {
       owned_string = std::move(rhs.owned_string);
@@ -180,8 +176,7 @@ class NamedRegexCapturer {
     Iterable(std::shared_ptr<NamedRegexCapturer::Data> data,
              std::string::const_iterator begin,
              std::string::const_iterator end)
-        : data_(std::move(data)),
-          begin_(begin, end, data_->transformed_re) {}
+        : data_(std::move(data)), begin_(begin, end, data_->transformed_re) {}
 
     struct Iterator {
       const std::shared_ptr<NamedRegexCapturer::Data> data_shared_ptr_;
diff --git a/bricks/strings/split.h b/bricks/strings/split.h
index e15a5b693..67f6df131 100644
--- a/bricks/strings/split.h
+++ b/bricks/strings/split.h
@@ -257,10 +257,11 @@ SplitIntoChunks(Chunk chunk,
                 SEPARATOR&& separator = impl::DefaultSeparator<SEPARATOR>::value(),
                 EmptyFields empty_fields_strategy = EmptyFields::Skip) {
   std::vector<Chunk> result;
-  Split(chunk,
-        std::forward<SEPARATOR>(separator),
-        [&result](Chunk chunk) { result.emplace_back(chunk); },
-        empty_fields_strategy);
+  Split(
+      chunk,
+      std::forward<SEPARATOR>(separator),
+      [&result](Chunk chunk) { result.emplace_back(chunk); },
+      empty_fields_strategy);
   return result;
 }
 
@@ -290,10 +291,11 @@ Split(STRING&& s,
       SEPARATOR&& separator = impl::DefaultSeparator<SEPARATOR>::value(),
       EmptyFields empty_fields_strategy = EmptyFields::Skip) {
   std::vector<std::string> result;
-  Split(std::forward<STRING>(s),
-        std::forward<SEPARATOR>(separator),
-        [&result](std::string&& chunk) { result.emplace_back(std::move(chunk)); },
-        empty_fields_strategy);
+  Split(
+      std::forward<STRING>(s),
+      std::forward<SEPARATOR>(separator),
+      [&result](std::string&& chunk) { result.emplace_back(std::move(chunk)); },
+      empty_fields_strategy);
   return result;
 }
 
diff --git a/bricks/strings/test.cc b/bricks/strings/test.cc
index 7ee584c8d..87e921360 100644
--- a/bricks/strings/test.cc
+++ b/bricks/strings/test.cc
@@ -32,39 +32,39 @@ SOFTWARE.
 
 #include "../../3rdparty/gtest/gtest-main.h"
 
-using current::strings::Printf;
-using current::strings::FixedSizeSerializer;
-using current::strings::PackToString;
-using current::strings::UnpackFromString;
+using current::strings::ByLines;
+using current::strings::ByWhitespace;
+using current::strings::Chunk;
+using current::strings::ChunkDB;
 using current::strings::CompileTimeStringLength;
-using current::strings::Trim;
-using current::strings::ToLower;
-using current::strings::ToUpper;
+using current::strings::CreateExceptionFriendlyStatefulGroupByLines;
+using current::strings::CreateStatefulGroupByLines;
+using current::strings::EmptyFields;
+using current::strings::EscapeForCPlusPlus;
+using current::strings::EscapeForMarkdown;
+using current::strings::ExceptionFriendlyStatefulGroupByLines;
+using current::strings::FastEditDistance;
+using current::strings::FixedSizeSerializer;
+using current::strings::is_string_type;
 using current::strings::Join;
+using current::strings::KeyValueMultipleValuesException;
+using current::strings::KeyValueNoValueException;
+using current::strings::KeyValueParsing;
+using current::strings::PackToString;
+using current::strings::Printf;
+using current::strings::RoundDoubleToString;
+using current::strings::SlowEditDistance;
 using current::strings::Split;
 using current::strings::SplitIntoChunks;
 using current::strings::SplitIntoKeyValuePairs;
 using current::strings::StatefulGroupByLines;
-using current::strings::CreateStatefulGroupByLines;
-using current::strings::ExceptionFriendlyStatefulGroupByLines;
-using current::strings::CreateExceptionFriendlyStatefulGroupByLines;
-using current::strings::EmptyFields;
-using current::strings::KeyValueParsing;
-using current::strings::KeyValueNoValueException;
-using current::strings::KeyValueMultipleValuesException;
-using current::strings::ByWhitespace;
-using current::strings::ByLines;
-using current::strings::SlowEditDistance;
-using current::strings::FastEditDistance;
-using current::strings::Chunk;
-using current::strings::UniqueChunk;
-using current::strings::ChunkDB;
-using current::strings::RoundDoubleToString;
-using current::strings::TimeIntervalAsHumanReadableString;
 using current::strings::TimeDifferenceAsHumanReadableString;
-using current::strings::EscapeForCPlusPlus;
-using current::strings::EscapeForMarkdown;
-using current::strings::is_string_type;
+using current::strings::TimeIntervalAsHumanReadableString;
+using current::strings::ToLower;
+using current::strings::ToUpper;
+using current::strings::Trim;
+using current::strings::UniqueChunk;
+using current::strings::UnpackFromString;
 
 TEST(StringPrintf, SmokeTest) {
   EXPECT_EQ("Test: 42, 'Hello', 0000ABBA", Printf("Test: %d, '%s', %08X", 42, "Hello", 0xabba));
@@ -880,7 +880,9 @@ TEST(Regex, SubmatchesDoTheirJobForUnnamedSuperGroups) {
 
 TEST(Regex, SimpleTokenization) {
   const std::vector<std::string> clauses({
-      "(?<uppercase>[A-Z]+)", "(?<lowercase>[a-z]+)", "(?<digits>[0-9]+)",
+      "(?<uppercase>[A-Z]+)",
+      "(?<lowercase>[a-z]+)",
+      "(?<digits>[0-9]+)",
   });
   const current::strings::NamedRegexCapturer re(current::strings::Join(clauses, '|'));
   EXPECT_EQ("([A-Z]+)|([a-z]+)|([0-9]+)", re.GetTransformedRegexBody());
@@ -905,7 +907,8 @@ TEST(Regex, SimpleTokenization) {
 
 TEST(Regex, MemoryOwnershipSmokeTest) {
   const std::vector<std::string> cs({
-      "(?<foo>foo)", "(?<bar>bar)",
+      "(?<foo>foo)",
+      "(?<bar>bar)",
   });
   std::vector<std::string> output;
   for (const auto& token : current::strings::NamedRegexCapturer(current::strings::Join(cs, '|')).Iterate("foo bar")) {
@@ -922,12 +925,14 @@ TEST(Regex, MemoryOwnershipSmokeTest) {
 
 TEST(Regex, SubstringIterationSmokeTest) {
   const std::vector<std::string> cs({
-      "(?<foo>foo)", "(?<bar>bar)",
+      "(?<foo>foo)",
+      "(?<bar>bar)",
   });
   std::string const foo_bar = "foo bar";
   {
     std::vector<std::string> output;
-    for (const auto& token : current::strings::NamedRegexCapturer(current::strings::Join(cs, '|')).Iterate(foo_bar.begin(), foo_bar.end())) {
+    for (const auto& token : current::strings::NamedRegexCapturer(current::strings::Join(cs, '|'))
+                                 .Iterate(foo_bar.begin(), foo_bar.end())) {
       if (token.Has("foo")) {
         output.push_back("foo@" + current::ToString(token.position()));
       } else if (token.Has("bar")) {
@@ -940,7 +945,8 @@ TEST(Regex, SubstringIterationSmokeTest) {
   }
   {
     std::vector<std::string> output;
-    for (const auto& token : current::strings::NamedRegexCapturer(current::strings::Join(cs, '|')).Iterate(foo_bar.begin(), foo_bar.begin() + 3u)) {
+    for (const auto& token : current::strings::NamedRegexCapturer(current::strings::Join(cs, '|'))
+                                 .Iterate(foo_bar.begin(), foo_bar.begin() + 3u)) {
       if (token.Has("foo")) {
         output.push_back("foo@" + current::ToString(token.position()));
       } else if (token.Has("bar")) {
@@ -953,7 +959,8 @@ TEST(Regex, SubstringIterationSmokeTest) {
   }
   {
     std::vector<std::string> output;
-    for (const auto& token : current::strings::NamedRegexCapturer(current::strings::Join(cs, '|')).Iterate(foo_bar.begin() + 3u, foo_bar.begin() + 7u)) {
+    for (const auto& token : current::strings::NamedRegexCapturer(current::strings::Join(cs, '|'))
+                                 .Iterate(foo_bar.begin() + 3u, foo_bar.begin() + 7u)) {
       if (token.Has("foo")) {
         output.push_back("foo@" + current::ToString(token.position()));
       } else if (token.Has("bar")) {
@@ -966,7 +973,8 @@ TEST(Regex, SubstringIterationSmokeTest) {
   }
   {
     std::vector<std::string> output;
-    for (const auto& token : current::strings::NamedRegexCapturer(current::strings::Join(cs, '|')).Iterate(foo_bar.begin() + 5u, foo_bar.begin() + 7u)) {
+    for (const auto& token : current::strings::NamedRegexCapturer(current::strings::Join(cs, '|'))
+                                 .Iterate(foo_bar.begin() + 5u, foo_bar.begin() + 7u)) {
       if (token.Has("foo")) {
         output.push_back("foo@" + current::ToString(token.position()));
       } else if (token.Has("bar")) {
@@ -978,15 +986,18 @@ TEST(Regex, SubstringIterationSmokeTest) {
     EXPECT_TRUE(output.empty());
   }
   {
-    const auto iterable = current::strings::NamedRegexCapturer(current::strings::Join(cs, '|')).Iterate(foo_bar.begin() + 0u, foo_bar.begin() + 7u);
+    const auto iterable = current::strings::NamedRegexCapturer(current::strings::Join(cs, '|'))
+                              .Iterate(foo_bar.begin() + 0u, foo_bar.begin() + 7u);
     EXPECT_FALSE(iterable.begin() == iterable.end());
   }
   {
-    const auto iterable = current::strings::NamedRegexCapturer(current::strings::Join(cs, '|')).Iterate(foo_bar.begin() + 0u, foo_bar.begin() + 2u);
+    const auto iterable = current::strings::NamedRegexCapturer(current::strings::Join(cs, '|'))
+                              .Iterate(foo_bar.begin() + 0u, foo_bar.begin() + 2u);
     EXPECT_TRUE(iterable.begin() == iterable.end());
   }
   {
-    const auto iterable = current::strings::NamedRegexCapturer(current::strings::Join(cs, '|')).Iterate(foo_bar.begin() + 5u, foo_bar.begin() + 7u);
+    const auto iterable = current::strings::NamedRegexCapturer(current::strings::Join(cs, '|'))
+                              .Iterate(foo_bar.begin() + 5u, foo_bar.begin() + 7u);
     EXPECT_TRUE(iterable.begin() == iterable.end());
   }
 }
@@ -998,7 +1009,8 @@ TEST(UTF8StringLength, Smoke) {
 
 TEST(StatefulGroupByLines, SmokeTrivial) {
   std::vector<std::string> lines;
-  StatefulGroupByLines splitter = CreateStatefulGroupByLines([&lines](const std::string& line) { lines.push_back(line); });
+  StatefulGroupByLines splitter =
+      CreateStatefulGroupByLines([&lines](const std::string& line) { lines.push_back(line); });
   splitter.Feed("foo\n");
   splitter.Feed("bar\n");
   splitter.Feed("baz\n");
@@ -1091,9 +1103,7 @@ TEST(StatefulGroupByLines, DoneMustBeCalledForExceptionFriendlySplitter) {
   bool done_not_called_failure = false;
   auto& handler = current::Singleton<current::strings::ExceptionFriendlyStatefulGroupByLinesDoneNotCalledHandler>();
   handler.InjectHandler([&done_not_called_failure]() { done_not_called_failure = true; });
-  {
-    RunTest(lines).DoRunTest();
-  }
+  { RunTest(lines).DoRunTest(); }
   handler.ResetHandler();
   ASSERT_TRUE(done_not_called_failure);
   ASSERT_EQ(2u, lines.size());
@@ -1103,9 +1113,7 @@ TEST(StatefulGroupByLines, DoneMustBeCalledForExceptionFriendlySplitter) {
 
 TEST(StatefulGroupByLines, CanNotCallDoneTwiceOnExceptionFriendlySplitter) {
   std::vector<std::string> lines;
-  auto splitter = CreateExceptionFriendlyStatefulGroupByLines([&lines](const char* line) {
-    lines.push_back(line);
-  });
+  auto splitter = CreateExceptionFriendlyStatefulGroupByLines([&lines](const char* line) { lines.push_back(line); });
   ASSERT_EQ(0u, lines.size());
   splitter.Feed("foo\nba");
   ASSERT_EQ(1u, lines.size());
diff --git a/bricks/strings/util.h b/bricks/strings/util.h
index dd16ea830..38bd585df 100644
--- a/bricks/strings/util.h
+++ b/bricks/strings/util.h
@@ -223,7 +223,6 @@ struct FromStringImpl<INPUT, uint8_t, false, false> {
   }
 };
 
-
 template <typename INPUT>
 struct FromStringImpl<INPUT, std::chrono::milliseconds, false, false> {
   static const std::chrono::milliseconds& Go(INPUT&& input, std::chrono::milliseconds& output) {
@@ -272,7 +271,7 @@ inline OUTPUT FromString(INPUT&& input) {
 inline std::string FromString(const std::string& input) { return input; }
 
 template <size_t N>
-constexpr std::enable_if_t<(N > 0), size_t> CompileTimeStringLength(char const(&)[N]) {
+constexpr std::enable_if_t<(N > 0), size_t> CompileTimeStringLength(char const (&)[N]) {
   return N - 1;
 }
 
@@ -341,8 +340,8 @@ inline const char* ConstCharPtr(const std::string& s) { return s.c_str(); }
 
 }  // namespace strings
 
-using strings::ToString;
 using strings::FromString;
+using strings::ToString;
 
 }  // namespace current
 
diff --git a/bricks/sync/locks.h b/bricks/sync/locks.h
index e1c56bebc..de7a41492 100644
--- a/bricks/sync/locks.h
+++ b/bricks/sync/locks.h
@@ -41,8 +41,7 @@ struct NoOpLock {
 };
 
 template <MutexLockStatus MLS, class MUTEX = std::mutex>
-using SmartMutexLockGuard =
-    std::conditional_t<MLS == MutexLockStatus::NeedToLock, std::lock_guard<MUTEX>, NoOpLock>;
+using SmartMutexLockGuard = std::conditional_t<MLS == MutexLockStatus::NeedToLock, std::lock_guard<MUTEX>, NoOpLock>;
 
 static_assert(std::is_same_v<std::lock_guard<std::mutex>, SmartMutexLockGuard<MutexLockStatus::NeedToLock>>, "");
 static_assert(std::is_same_v<NoOpLock, SmartMutexLockGuard<MutexLockStatus::AlreadyLocked>>, "");
diff --git a/bricks/sync/owned_borrowed.h b/bricks/sync/owned_borrowed.h
index 29c23e8ee..0c5efe09a 100644
--- a/bricks/sync/owned_borrowed.h
+++ b/bricks/sync/owned_borrowed.h
@@ -153,7 +153,7 @@ struct UniqueInstance final {
   size_t total_borrowers_spawned_throughout_lifetime_;  // A pre-increment of this value is the key in the above map.
 };
 
-}  // namespace current::sync::impl
+}  // namespace impl
 
 template <typename T>
 class Owned;
@@ -308,7 +308,7 @@ struct UniqueInstanceContainer {
   UniqueInstanceContainer& operator=(const UniqueInstanceContainer&) = delete;
 };
 
-}  // namespace current::sync::impl
+}  // namespace impl
 
 template <typename T>
 struct ConstructOwned {};
@@ -466,7 +466,7 @@ Owned<T> MakeOwned(ARGS&&... args) {
   return Owned<T>(ConstructOwned<T>(), std::forward<ARGS>(args)...);
 }
 
-}  // namespace current::sync
+}  // namespace sync
 
 template <typename T>
 using ConstructOwned = sync::ConstructOwned<T>;
diff --git a/bricks/sync/test.cc b/bricks/sync/test.cc
index 74d65ff94..56981b06a 100644
--- a/bricks/sync/test.cc
+++ b/bricks/sync/test.cc
@@ -194,11 +194,10 @@ TEST(OwnedBorrowed, BorrowedWithCallbackOutlivingTheOwner) {
             y.ExclusiveUse([](Container& container) { ++container.ref; });
           }
         },
-        std::make_unique<current::BorrowedWithCallback<Container>>(x,
-                                                                   [&log, &terminating]() {
-                                                                     terminating = true;
-                                                                     log += "Terminating.\n";
-                                                                   }));
+        std::make_unique<current::BorrowedWithCallback<Container>>(x, [&log, &terminating]() {
+          terminating = true;
+          log += "Terminating.\n";
+        }));
 
     EXPECT_EQ(1u, x.NumberOfActiveBorrowers());
     EXPECT_EQ(1u, x.TotalBorrowersSpawnedThroughoutLifetime());
@@ -231,16 +230,18 @@ TEST(OwnedBorrowed, UseInternalIsDestructingGetter) {
   std::unique_ptr<std::thread> thread;
   {
     current::Owned<Container> x(current::ConstructOwned<Container>(), container);
-    thread = std::make_unique<std::thread>([](current::Borrowed<Container> y) {
-      // Keep incrementing until external termination request.
-      while (y) {
-        y.ExclusiveUse([](Container& container) { ++container.ref; });
-      }
-      // And do another one thousand increments just because we can.
-      for (int i = 0; i < 1000; ++i) {
-        y.ExclusiveUse([](Container& container) { ++container.ref; });
-      }
-    }, current::Borrowed<Container>(x));
+    thread = std::make_unique<std::thread>(
+        [](current::Borrowed<Container> y) {
+          // Keep incrementing until external termination request.
+          while (y) {
+            y.ExclusiveUse([](Container& container) { ++container.ref; });
+          }
+          // And do another one thousand increments just because we can.
+          for (int i = 0; i < 1000; ++i) {
+            y.ExclusiveUse([](Container& container) { ++container.ref; });
+          }
+        },
+        current::Borrowed<Container>(x));
 
     int extracted_value;
     do {
@@ -253,8 +254,8 @@ TEST(OwnedBorrowed, UseInternalIsDestructingGetter) {
 }
 
 TEST(WaitableAtomic, Smoke) {
-  using current::WaitableAtomic;
   using current::IntrusiveClient;
+  using current::WaitableAtomic;
 
   struct Object {
     size_t x = 0;
@@ -269,34 +270,40 @@ TEST(WaitableAtomic, Smoke) {
     WaitableAtomic<bool, true> top_level_lock;
 
     // The `++x` thread uses mutable accessors.
-    std::thread([&top_level_lock, &object](IntrusiveClient top_level_client) {
-      // Should be able to register another client for `top_level_lock`.
-      ASSERT_TRUE(bool(top_level_lock.RegisterScopedClient()));
-      while (top_level_client) {
-        // This loop will be terminated as `top_level_lock` will be leaving the scope.
-        ++object.MutableScopedAccessor()->x;
-        std::this_thread::sleep_for(std::chrono::milliseconds(1));
-      }
-      // Should no longer be able to register another client for `top_level_lock`.
-      ASSERT_FALSE(bool(top_level_lock.RegisterScopedClient()));
-      std::this_thread::sleep_for(std::chrono::milliseconds(10));
-      object.MutableScopedAccessor()->x_done = true;
-    }, top_level_lock.RegisterScopedClient()).detach();
+    std::thread(
+        [&top_level_lock, &object](IntrusiveClient top_level_client) {
+          // Should be able to register another client for `top_level_lock`.
+          ASSERT_TRUE(bool(top_level_lock.RegisterScopedClient()));
+          while (top_level_client) {
+            // This loop will be terminated as `top_level_lock` will be leaving the scope.
+            ++object.MutableScopedAccessor()->x;
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+          }
+          // Should no longer be able to register another client for `top_level_lock`.
+          ASSERT_FALSE(bool(top_level_lock.RegisterScopedClient()));
+          std::this_thread::sleep_for(std::chrono::milliseconds(10));
+          object.MutableScopedAccessor()->x_done = true;
+        },
+        top_level_lock.RegisterScopedClient())
+        .detach();
 
     // The `++y` thread uses the functional style.
-    std::thread([&top_level_lock, &object](IntrusiveClient top_level_client) {
-      // Should be able to register another client for `top_level_lock`.
-      ASSERT_TRUE(bool(top_level_lock.RegisterScopedClient()));
-      while (top_level_client) {
-        // This loop will be terminated as `top_level_lock` will be leaving the scope.
-        object.MutableUse([](Object& object) { ++object.y; });
-        std::this_thread::sleep_for(std::chrono::milliseconds(1));
-      }
-      // Should no longer be able to register another client for `top_level_lock`.
-      ASSERT_FALSE(bool(top_level_lock.RegisterScopedClient()));
-      std::this_thread::sleep_for(std::chrono::milliseconds(10));
-      object.MutableUse([](Object& object) { object.y_done = true; });
-    }, top_level_lock.RegisterScopedClient()).detach();
+    std::thread(
+        [&top_level_lock, &object](IntrusiveClient top_level_client) {
+          // Should be able to register another client for `top_level_lock`.
+          ASSERT_TRUE(bool(top_level_lock.RegisterScopedClient()));
+          while (top_level_client) {
+            // This loop will be terminated as `top_level_lock` will be leaving the scope.
+            object.MutableUse([](Object& object) { ++object.y; });
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+          }
+          // Should no longer be able to register another client for `top_level_lock`.
+          ASSERT_FALSE(bool(top_level_lock.RegisterScopedClient()));
+          std::this_thread::sleep_for(std::chrono::milliseconds(10));
+          object.MutableUse([](Object& object) { object.y_done = true; });
+        },
+        top_level_lock.RegisterScopedClient())
+        .detach();
 
     // Let `++x` and `++y` threads run 25ms.
     std::this_thread::sleep_for(std::chrono::milliseconds(25));
@@ -348,8 +355,8 @@ TEST(WaitableAtomic, ProxyConstructor) {
 }
 
 TEST(WaitableAtomic, IntrusiveClientsCanBeTransferred) {
-  using current::WaitableAtomic;
   using current::IntrusiveClient;
+  using current::WaitableAtomic;
 
   WaitableAtomic<bool, true> object;
   auto f = [](IntrusiveClient& c) { static_cast<void>(c); };
diff --git a/bricks/sync/waitable_atomic.h b/bricks/sync/waitable_atomic.h
index dbe65110e..02bf49bc0 100644
--- a/bricks/sync/waitable_atomic.h
+++ b/bricks/sync/waitable_atomic.h
@@ -116,8 +116,7 @@ class WaitableAtomicImpl {
     enum { IS_INTRUSIVE = false };
 
     template <typename... ARGS>
-    BasicImpl(ARGS&&... args)
-        : data_(std::forward<ARGS>(args)...) {}
+    BasicImpl(ARGS&&... args) : data_(std::forward<ARGS>(args)...) {}
 
     BasicImpl(const DATA& data) : data_(data) {}
 
@@ -143,9 +142,8 @@ class WaitableAtomicImpl {
         bool mark_as_unmodified_;
       };
 
-      using impl_t = std::conditional_t<std::is_const<POINTER>::value,
-                                        ImmutableAccessorDoesNotNotify,
-                                        MutableAccessorDoesNotify>;
+      using impl_t =
+          std::conditional_t<std::is_const<POINTER>::value, ImmutableAccessorDoesNotNotify, MutableAccessorDoesNotify>;
     };
 
     // A generic implementation for both mutable and immutable scoped accessors.
@@ -154,9 +152,8 @@ class WaitableAtomicImpl {
      public:
       using parent_t = PARENT;
       using optional_notifier_t = typename NotifyIfMutable<PARENT>::impl_t;
-      using data_t = std::conditional_t<std::is_const<parent_t>::value,
-                                        const typename parent_t::data_t,
-                                        typename parent_t::data_t>;
+      using data_t = std::
+          conditional_t<std::is_const<parent_t>::value, const typename parent_t::data_t, typename parent_t::data_t>;
 
       explicit ScopedAccessorImpl(parent_t* parent)
           : ScopedUniqueLock(parent->data_mutex_), optional_notifier_t(parent), pdata_(&parent->data_) {}
diff --git a/bricks/system/current.inl.h b/bricks/system/current.inl.h
index 21e4aea2f..261103c88 100644
--- a/bricks/system/current.inl.h
+++ b/bricks/system/current.inl.h
@@ -14,7 +14,7 @@ namespace inl {
 static const std::string bricks_system_current_inl = current::Base64Decode("Ly8gV2hlbiBgSklUQ29tcGlsZWRDUFBgIGlzIHByb3ZpZGVkIHRoZSBzZWNvbmQgcGFyYW1ldGVyLCB0aGUgcGF0aCB0byBgY3VycmVudGAsIHRoZQovLyBzeW1ib2xpYyBsaW5rIGNhbGxlZCBgY3VycmVudGAgaXMgY3JlYXRlZCBpbiB0aGUgZGlyZWN0b3J5IGluIHdoaWNoIHRoZSB1c2VyIGNvZGUgaXMgY29tcGlsZWQuCi8vCi8vIFRoaXMgaW1tZWRpYXRlbHkgYWxsb3dzIHRoZSB1c2VyIGNvZGUgdG8gYWNjZXNzIEN1cnJlbnQgaGVhZGVycyBieSBtZWFucyBvZiBgI2luY2x1ZGUgImN1cnJlbnQvLi4uImAuCi8vCi8vIE11Y2ggbGlrZSB3aXRob3V0IHRoZSBzZWNvbmQgcGFyYW1ldGVyIHByb3ZpZGVkIHRvIGBKSVRDb21waWxlZENQUGAsIHRoZSB1c2VyIGNvZGUKLy8gaXMgY29tcGlsZWQgZnJvbSB3aXRoaW4gYSBkaXJlY3Rvcnkgd2hlcmUgdGhlIGBjdXJyZW50LmhgIGhlYWRlciBmaWxlIGlzIHBsYWNlZC4KLy8KLy8gSW4gdGhlIGFic2VuY2Ugb2YgQ3VycmVudCBzeW1saW5rZWQgaW4gdGhhdCBkaXJlY3RvcnksIHRoZSBkdW1teSwgZW1wdHksIGBjdXJyZW50LmhgIGhlYWRlciBjcmVhdGVkIHRoZXJlCi8vIHNlcnZlcyB0aGUgcHVycG9zZSBvZiBhbGxvd2luZyB0aGUgdXNlciB0byBoYXZlIHRoZWlyIG93biwgZGlmZmVyZW50IGBjdXJyZW50LmhgIGZpbGUgaW4gdGhlIGRpcmVjb3J5Ci8vIGZyb20gd2hpY2ggdGhleSB3b3VsZCBiZSAiY3VybCBQT1NUIi1pbmcgdGhpcyBmaWxlIHRvIHRoZSBzZXJ2ZXIsIHRvIGRlZmluZSB0aGUgc3ltYm9scyB0aGUgInNlcnZlci1zaWRlIiBkbG9wZW4oKQovLyB3b3VsZCBjb250YWluIGluIHRoZSBib2xpZXJwbGF0ZSwgdGh1cyBtYWtpbmcgc3VyZSB0aGUgdXNlciBjb2RlIGlzIHNlbGYtc3VmZmljaWVudCBmcm9tIHRoZSBJREUgcHVycG9zZXMsCi8vIHN1Y2ggdGhhdCBmZWF0dXJlcyBzdWNoIGFzIGNvbXBsZXRpb24gYW5kIGVycm9ycyBoaWdobGlnaHRpbmcgd291bGQgd29yayBqdXN0IGZpbmUuCi8vCi8vIEluIHRoZSBwcmVzZW5jZSBvZiBDdXJyZW50LCB0aGUgYGN1cnJlbnQuaGAgaGVhZGVyIGlzIG5vIGxvbmdlciBkdW1teSwgYnV0IHNlcnZlcyBhcyBhIGJvaWxlcnBsYXRlIHRvIGluY2x1ZGUKLy8gdmFyaW91cyBDdXJyZW50LXNwZWNpZmljIHdyYXBwZXJzIHNvIHRoYXQgdGhlIHVzZXIgY29kZSBoYXMgaW1tZWRpYXRlIGFjY2VzcyB0byB0aGVtLgovLwovLyBUaGlzIGNvbnRlbnRzIG9mIHRoaXMgaGVhZGVyIGZpbGUgYXJlIHRoZW4gInR1bmVkIiB0byBkZW1vbnN0cmF0ZSB0aGUgcG93ZXIgb2YgQysrIHdpdGggQ3VycmVudCwKLy8gd2l0aG91dCBzbG93aW5nIHRoZSBjb21waWxhdGlvbiBtdWNoLgoKI2luY2x1ZGUgImN1cnJlbnQvYnJpY2tzL3N0cmluZ3MvcHJpbnRmLmgiCiNpbmNsdWRlICJjdXJyZW50L2JyaWNrcy9zdHJpbmdzL3V0aWwuaCIKI2luY2x1ZGUgImN1cnJlbnQvYnJpY2tzL3N0cmluZ3Mvc3BsaXQuaCIKI2luY2x1ZGUgImN1cnJlbnQvYnJpY2tzL3N0cmluZ3Mvam9pbi5oIgojaW5jbHVkZSAiY3VycmVudC9icmlja3Mvc3RyaW5ncy9jaHVuay5oIgoKdXNpbmcgY3VycmVudDo6c3RyaW5nczo6UHJpbnRmOwp1c2luZyBjdXJyZW50OjpzdHJpbmdzOjpGcm9tU3RyaW5nOwp1c2luZyBjdXJyZW50OjpzdHJpbmdzOjpUb1N0cmluZzsKdXNpbmcgY3VycmVudDo6c3RyaW5nczo6VG9Mb3dlcjsKdXNpbmcgY3VycmVudDo6c3RyaW5nczo6VG9VcHBlcjsKdXNpbmcgY3VycmVudDo6c3RyaW5nczo6VHJpbTsKdXNpbmcgY3VycmVudDo6c3RyaW5nczo6U3BsaXQ7CnVzaW5nIGN1cnJlbnQ6OnN0cmluZ3M6OkpvaW47CnVzaW5nIGN1cnJlbnQ6OnN0cmluZ3M6OkNodW5rOwoKI2luY2x1ZGUgImN1cnJlbnQvYnJpY2tzL3V0aWwvc2luZ2xldG9uLmgiCgp1c2luZyBjdXJyZW50OjpTaW5nbGV0b247CgojaW5jbHVkZSAiY3VycmVudC9icmlja3MvdXRpbC9yYW5kb20uaCIKdXNpbmcgbmFtZXNwYWNlIGN1cnJlbnQ6OnJhbmRvbTsKCi8vICNpbmNsdWRlICJjdXJyZW50L3R5cGVzeXN0ZW0vc2VyaWFsaXphdGlvbi9qc29uLmgiIC0tIEEgYml0IHRvbyBzbG93LCBidXQgcGVyaGFwcyBhZGQgYSBzeW1saW5rIHRvIGBqc29uLmhgIGFzIHdlbGwuCg==");
 // clang-format on
 
-}  // namespace current::inl
+}  // namespace inl
 }  // namespace current
 
 #endif  // BRICKS_SYSTEM_CURRENT_INL_H
diff --git a/bricks/system/syscalls.h b/bricks/system/syscalls.h
index 7ab9a6fa3..0a24e0a1a 100644
--- a/bricks/system/syscalls.h
+++ b/bricks/system/syscalls.h
@@ -240,8 +240,8 @@ class JITCompiledCPP final {
 };
 #endif  // CURRENT_WINDOWS
 
-}  // namespace current::bricks::system
-}  // namespace current::bricks
+}  // namespace system
+}  // namespace bricks
 }  // namespace current
 
 #endif  // BRICKS_SYSTEM_SYSCALLS_H
diff --git a/bricks/template/combine.h b/bricks/template/combine.h
index c47fbf8e5..6ef492b9a 100644
--- a/bricks/template/combine.h
+++ b/bricks/template/combine.h
@@ -49,8 +49,7 @@ struct dispatch {
   T instance;
 
   template <typename... ARGS>
-  dispatch(const ARGS&... args)
-      : instance(args...) {}
+  dispatch(const ARGS&... args) : instance(args...) {}
 
   template <typename... XS>
   std::enable_if_t<weed::call_with<T, XS...>::implemented, weed::call_with_type<T, XS...>> operator()(XS&&... params) {
@@ -58,8 +57,8 @@ struct dispatch {
   }
 
   template <typename... XS>
-  std::enable_if_t<weed::call_with<T, XS...>::implemented, weed::call_with_type<T, XS...>>
-  operator()(XS&&... params) const {
+  std::enable_if_t<weed::call_with<T, XS...>::implemented, weed::call_with_type<T, XS...>> operator()(
+      XS&&... params) const {
     return instance(std::forward<XS>(params)...);
   }
 
@@ -83,8 +82,7 @@ struct inherit_from_both : T1, T2 {
   using T2::operator();
 
   template <typename... ARGS>
-  inherit_from_both(const ARGS&... args)
-      : T1(args...), T2(args...) {}
+  inherit_from_both(const ARGS&... args) : T1(args...), T2(args...) {}
 
   // `DispatchToAll(...)` will reach both `T1` and `T2`.
   template <typename... TS>
diff --git a/bricks/template/test.cc b/bricks/template/test.cc
index 109797d35..dc8ff7f3f 100644
--- a/bricks/template/test.cc
+++ b/bricks/template/test.cc
@@ -137,8 +137,8 @@ TEST(TemplateMetaprogrammingInternalTest, Combine) {
 }
 
 TEST(TemplateMetaprogrammingInternalTest, VariadicIndexes) {
-  using current::variadic_indexes::indexes;
   using current::variadic_indexes::generate_indexes;
+  using current::variadic_indexes::indexes;
 
   static_assert(std::is_same_v<indexes<>, generate_indexes<0>>, "");
   static_assert(std::is_same_v<indexes<0>, generate_indexes<1>>, "");
@@ -316,8 +316,7 @@ static_assert(is_same_v<const char*, decay_t<decltype("test")>>, "");
 
 // `current::decay_t` + `std::tuple`.
 static_assert(is_same_v<std::tuple<int, int, int, int>, decay_t<std::tuple<int, int, int, int>>>, "");
-static_assert(is_same_v<std::tuple<int, int, int, int>, decay_t<std::tuple<const int, int&, const int&, int&&>>>,
-              "");
+static_assert(is_same_v<std::tuple<int, int, int, int>, decay_t<std::tuple<const int, int&, const int&, int&&>>>, "");
 
 static_assert(is_same_v<std::tuple<std::string>, decay_t<std::tuple<std::string>>>, "");
 static_assert(is_same_v<std::tuple<std::string>, decay_t<std::tuple<const std::string>>>, "");
@@ -332,17 +331,13 @@ static_assert(is_same_v<std::tuple<std::string>, decay_t<const std::tuple<const
 static_assert(is_same_v<std::tuple<std::string>, decay_t<const std::tuple<const std::string&>&>>, "");
 static_assert(is_same_v<std::tuple<std::string>, decay_t<std::tuple<const std::string&>&&>>, "");
 
-static_assert(is_same_v<std::tuple<std::tuple<std::string>>, decay_t<std::tuple<std::tuple<const std::string>>>>,
-              "");
+static_assert(is_same_v<std::tuple<std::tuple<std::string>>, decay_t<std::tuple<std::tuple<const std::string>>>>, "");
 static_assert(is_same_v<std::tuple<std::tuple<std::string>>, decay_t<std::tuple<std::tuple<std::string&>>>>, "");
-static_assert(is_same_v<std::tuple<std::tuple<std::string>>, decay_t<std::tuple<std::tuple<const std::string&>>>>,
-              "");
+static_assert(is_same_v<std::tuple<std::tuple<std::string>>, decay_t<std::tuple<std::tuple<const std::string&>>>>, "");
 static_assert(is_same_v<std::tuple<std::tuple<std::string>>, decay_t<std::tuple<std::tuple<std::string&&>>>>, "");
 static_assert(is_same_v<std::tuple<std::tuple<std::string>>, decay_t<std::tuple<std::tuple<std::string>>>>, "");
-static_assert(is_same_v<std::tuple<std::tuple<std::string>>, decay_t<const std::tuple<std::tuple<std::string>>&>>,
-              "");
-static_assert(is_same_v<std::tuple<std::tuple<std::string>>, decay_t<const std::tuple<std::tuple<std::string>&>&>>,
-              "");
+static_assert(is_same_v<std::tuple<std::tuple<std::string>>, decay_t<const std::tuple<std::tuple<std::string>>&>>, "");
+static_assert(is_same_v<std::tuple<std::tuple<std::string>>, decay_t<const std::tuple<std::tuple<std::string>&>&>>, "");
 static_assert(is_same_v<std::tuple<std::tuple<std::string>>, decay_t<const std::tuple<std::tuple<std::string&>&>&>>,
               "");
 static_assert(is_same_v<std::tuple<std::tuple<std::string>>, decay_t<const std::tuple<std::tuple<std::string&&>&>&>>,
diff --git a/bricks/template/typelist.h b/bricks/template/typelist.h
index 6eec593e8..732f8098f 100644
--- a/bricks/template/typelist.h
+++ b/bricks/template/typelist.h
@@ -58,7 +58,7 @@ template <typename T>
 #ifndef CURRENT_FOR_CPP14
 inline
 #endif  // CURRENT_FOR_CPP14
-constexpr size_t TypeListSize = TypeListSizeExtractor<T>::value;
+    constexpr size_t TypeListSize = TypeListSizeExtractor<T>::value;
 
 static_assert(TypeListSize<TypeListImpl<>> == 0, "");
 static_assert(TypeListSize<TypeListImpl<int>> == 1, "");
@@ -138,11 +138,9 @@ static_assert(std::is_same_v<TypeListImpl<>, TypeListCat<TypeListImpl<>, TypeLis
 static_assert(std::is_same_v<TypeListImpl<int>, TypeListCat<TypeListImpl<int>, TypeListImpl<>>>, "");
 static_assert(std::is_same_v<TypeListImpl<int>, TypeListCat<TypeListImpl<>, TypeListImpl<int>>>, "");
 static_assert(
-    std::is_same_v<TypeListImpl<int, char, double>, TypeListCat<TypeListImpl<int>, TypeListImpl<char, double>>>,
-    "");
+    std::is_same_v<TypeListImpl<int, char, double>, TypeListCat<TypeListImpl<int>, TypeListImpl<char, double>>>, "");
 static_assert(
-    std::is_same_v<TypeListImpl<int, char, double>, TypeListCat<TypeListImpl<int, char>, TypeListImpl<double>>>,
-    "");
+    std::is_same_v<TypeListImpl<int, char, double>, TypeListCat<TypeListImpl<int, char>, TypeListImpl<double>>>, "");
 static_assert(std::is_same_v<TypeListImpl<>, TypeListCat<>>, "");
 static_assert(std::is_same_v<TypeListImpl<int>, TypeListCat<TypeListImpl<int>>>, "");
 static_assert(std::is_same_v<TypeListImpl<int, char, double>,
@@ -259,13 +257,13 @@ static_assert(std::is_same_v<TypeListImpl<>, TypeListUnion<TypeListImpl<>, TypeL
 static_assert(std::is_same_v<TypeListImpl<int>, TypeListUnion<TypeListImpl<int>, TypeListImpl<>>>, "");
 static_assert(std::is_same_v<TypeListImpl<int>, TypeListUnion<TypeListImpl<>, TypeListImpl<int>>>, "");
 static_assert(std::is_same_v<TypeListImpl<int>, TypeListUnion<TypeListImpl<int>, TypeListImpl<int>>>, "");
-static_assert(std::is_same_v<TypeListImpl<int, char, double>,
-                             TypeListUnion<TypeListImpl<int, char>, TypeListImpl<char, double>>>,
-              "");
+static_assert(
+    std::is_same_v<TypeListImpl<int, char, double>, TypeListUnion<TypeListImpl<int, char>, TypeListImpl<char, double>>>,
+    "");
 static_assert(std::is_same_v<TypeListImpl<>, TypeListUnion<>>, "");
 static_assert(std::is_same_v<TypeListImpl<int>, TypeListUnion<TypeListImpl<int>>>, "");
-static_assert(
-    std::is_same_v<TypeListImpl<int>, TypeListUnion<TypeListImpl<int>, TypeListImpl<int>, TypeListImpl<int>>>, "");
+static_assert(std::is_same_v<TypeListImpl<int>, TypeListUnion<TypeListImpl<int>, TypeListImpl<int>, TypeListImpl<int>>>,
+              "");
 static_assert(
     std::is_same_v<TypeListImpl<int, char>,
                    TypeListUnion<TypeListImpl<int>, TypeListImpl<char>, TypeListImpl<int>, TypeListImpl<char>>>,
@@ -312,8 +310,8 @@ static_assert(std::is_same_v<TypeListImpl<int>, Flatten<TypeListImpl<TypeListImp
 static_assert(std::is_same_v<TypeListImpl<int>, Flatten<TypeListImpl<TypeListImpl<TypeListImpl<int>>>>>, "");
 static_assert(std::is_same_v<TypeListImpl<int, double>, Flatten<TypeListImpl<int, double>>>, "");
 static_assert(std::is_same_v<TypeListImpl<int, double>, Flatten<TypeListImpl<TypeListImpl<int>, double>>>, "");
-static_assert(
-    std::is_same_v<TypeListImpl<int, double>, Flatten<TypeListImpl<TypeListImpl<TypeListImpl<int>>, double>>>, "");
+static_assert(std::is_same_v<TypeListImpl<int, double>, Flatten<TypeListImpl<TypeListImpl<TypeListImpl<int>>, double>>>,
+              "");
 
 // Performance alert, @dkorolev @mzhurovich 12/5/2015. Revisited and kept the semantics same. -- D.K. 10/15/2015.
 // The implementation of `TypeList` deduplication+flattening is very inefficient as of now.
@@ -335,8 +333,8 @@ static_assert(std::is_same_v<TypeListImpl<int>, SlowTypeList<SlowTypeList<SlowTy
 static_assert(std::is_same_v<TypeListImpl<int>, SlowTypeList<int, int>>, "");
 static_assert(std::is_same_v<TypeListImpl<int>, SlowTypeList<int, SlowTypeList<int>>>, "");
 static_assert(std::is_same_v<TypeListImpl<int>, SlowTypeList<int, SlowTypeList<SlowTypeList<int>>>>, "");
-static_assert(
-    std::is_same_v<TypeListImpl<int, double>, SlowTypeList<int, SlowTypeList<SlowTypeList<int>, double>>>, "");
+static_assert(std::is_same_v<TypeListImpl<int, double>, SlowTypeList<int, SlowTypeList<SlowTypeList<int>, double>>>,
+              "");
 static_assert(std::is_same_v<TypeListImpl<int, double>, SlowTypeList<int, int, double, double>>, "");
 static_assert(std::is_same_v<TypeListImpl<int, double>, SlowTypeList<int, double, int>>, "");
 static_assert(std::is_same_v<TypeListImpl<int, double>, SlowTypeList<int, double, int, double>>, "");
@@ -428,7 +426,7 @@ struct Q {
   using type = typename type_wrapper::type;
 };
 
-}  // namespace crnt::tle
+}  // namespace tle
 }  // namespace crnt
 
 namespace current {
@@ -446,12 +444,12 @@ static_assert(std::is_same_v<char, TypeListElement<1, TypeListImpl<long, char>>>
 }  // namespace current
 
 // Export some symbols into global scope.
-using current::metaprogramming::TypeList;
+using current::metaprogramming::IsTypeList;
 using current::metaprogramming::SlowTypeList;
+using current::metaprogramming::TypeList;
 using current::metaprogramming::TypeListContains;
-using current::metaprogramming::IsTypeList;
-using current::metaprogramming::TypeListSize;
 using current::metaprogramming::TypeListElement;
+using current::metaprogramming::TypeListSize;
 
 // Note: For equality and lack of discrimination reasons, the user may still use raw `TypeListImpl`,
 // if she prefers to not have flattening and deduplication take place.
diff --git a/bricks/template/weed.h b/bricks/template/weed.h
index bed6ba92a..5503d6878 100644
--- a/bricks/template/weed.h
+++ b/bricks/template/weed.h
@@ -52,7 +52,7 @@ struct call_with_impl {
   }
 };
 
-}  // namespace current::weed::impl
+}  // namespace impl
 
 template <typename T, typename... XS>
 struct call_with {
@@ -83,7 +83,7 @@ static_assert(!call_with<TEST2, int>::implemented, "");
 
 }  // namespace smoke_test
 
-}  // namespace current::weed
+}  // namespace weed
 }  // namespace current
 
 #endif  // BRICKS_TEMPLATE_WEED_H
diff --git a/bricks/time/chrono.h b/bricks/time/chrono.h
index 031d5ec6e..0a06775c7 100644
--- a/bricks/time/chrono.h
+++ b/bricks/time/chrono.h
@@ -133,7 +133,7 @@ inline void SleepUntil(T moment) {
 
 #endif  // CURRENT_MOCK_TIME
 
-}  // namespace current::time
+}  // namespace time
 
 namespace strings {
 
@@ -153,7 +153,7 @@ struct FixedSizeSerializer<std::chrono::microseconds> {
   }
 };
 
-}  // namespace current::strings
+}  // namespace strings
 
 namespace time {
 
@@ -218,7 +218,7 @@ inline std::tm FillStructTM(std::chrono::microseconds t) {
   return FillStructTM<T>(t, tm);
 }
 
-}  // namespace current::time
+}  // namespace time
 
 template <time::TimeRepresentation T = time::TimeRepresentation::Local>
 inline std::string FormatDateTime(std::chrono::microseconds t, const char* format_string = "%Y/%m/%d %H:%M:%S") {
@@ -257,8 +257,9 @@ inline std::chrono::microseconds DateTimeStringToTimestamp(
       tm.tm_isdst = 0;
       tt = ::timegm(&tm);
     }
-    const auto result = std::chrono::time_point_cast<std::chrono::microseconds>(
-                            std::chrono::system_clock::from_time_t(tt)).time_since_epoch();
+    const auto result =
+        std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::from_time_t(tt))
+            .time_since_epoch();
     if (padding == time::SecondsToMicrosecondsPadding::Lower) {
       return result;
     } else {
@@ -274,7 +275,8 @@ std::chrono::microseconds UTCDateTimeStringToTimestamp(
     STRING&& datetime,
     const char* format_string,
     time::SecondsToMicrosecondsPadding padding = time::SecondsToMicrosecondsPadding::Lower) {
-  return DateTimeStringToTimestamp<time::TimeRepresentation::UTC>(std::forward<STRING>(datetime), format_string, padding);
+  return DateTimeStringToTimestamp<time::TimeRepresentation::UTC>(
+      std::forward<STRING>(datetime), format_string, padding);
 }
 
 template <typename STRING>
@@ -282,21 +284,22 @@ std::chrono::microseconds LocalDateTimeStringToTimestamp(
     STRING&& datetime,
     const char* format_string,
     time::SecondsToMicrosecondsPadding padding = time::SecondsToMicrosecondsPadding::Lower) {
-  return DateTimeStringToTimestamp<time::TimeRepresentation::Local>(std::forward<STRING>(datetime), format_string, padding);
+  return DateTimeStringToTimestamp<time::TimeRepresentation::Local>(
+      std::forward<STRING>(datetime), format_string, padding);
 }
 
 template <typename STRING>
 std::chrono::microseconds IMFFixDateTimeStringToTimestamp(
-    STRING&& datetime,
-    time::SecondsToMicrosecondsPadding padding = time::SecondsToMicrosecondsPadding::Lower) {
-  return DateTimeStringToTimestamp<time::TimeRepresentation::UTC>(std::forward<STRING>(datetime), time::DateTimeFmts::IMFFix, padding);
+    STRING&& datetime, time::SecondsToMicrosecondsPadding padding = time::SecondsToMicrosecondsPadding::Lower) {
+  return DateTimeStringToTimestamp<time::TimeRepresentation::UTC>(
+      std::forward<STRING>(datetime), time::DateTimeFmts::IMFFix, padding);
 }
 
 template <typename STRING>
 std::chrono::microseconds RFC850DateTimeStringToTimestamp(
-    STRING&& datetime,
-    time::SecondsToMicrosecondsPadding padding = time::SecondsToMicrosecondsPadding::Lower) {
-  return DateTimeStringToTimestamp<time::TimeRepresentation::UTC>(std::forward<STRING>(datetime), time::DateTimeFmts::RFC850, padding);
+    STRING&& datetime, time::SecondsToMicrosecondsPadding padding = time::SecondsToMicrosecondsPadding::Lower) {
+  return DateTimeStringToTimestamp<time::TimeRepresentation::UTC>(
+      std::forward<STRING>(datetime), time::DateTimeFmts::RFC850, padding);
 }
 
 }  // namespace current
diff --git a/bricks/time/test.cc b/bricks/time/test.cc
index 90490dcd3..1f5c03dd4 100644
--- a/bricks/time/test.cc
+++ b/bricks/time/test.cc
@@ -95,14 +95,17 @@ TEST(Time, DateTimeFormatFunctions) {
   EXPECT_EQ(1461461461000000, current::IMFFixDateTimeStringToTimestamp("Sun, 24 Apr 2016 01:31:01 GMT").count());
   EXPECT_EQ(1461461461999999,
             current::IMFFixDateTimeStringToTimestamp("Sun, 24 Apr 2016 01:31:01 GMT",
-                                                     current::time::SecondsToMicrosecondsPadding::Upper).count());
+                                                     current::time::SecondsToMicrosecondsPadding::Upper)
+                .count());
   EXPECT_EQ(0, current::IMFFixDateTimeStringToTimestamp("Not valid string,").count());
-  EXPECT_EQ(0,
-            current::IMFFixDateTimeStringToTimestamp("Not valid string,",
-                                                     current::time::SecondsToMicrosecondsPadding::Upper).count());
+  EXPECT_EQ(
+      0,
+      current::IMFFixDateTimeStringToTimestamp("Not valid string,", current::time::SecondsToMicrosecondsPadding::Upper)
+          .count());
   EXPECT_EQ(1461461461000000, current::RFC850DateTimeStringToTimestamp("Sunday, 24-Apr-16 01:31:01 GMT").count());
   EXPECT_EQ(1461461461999999,
             current::RFC850DateTimeStringToTimestamp("Sunday, 24-Apr-16 01:31:01 GMT",
-                                                     current::time::SecondsToMicrosecondsPadding::Upper).count());
+                                                     current::time::SecondsToMicrosecondsPadding::Upper)
+                .count());
   EXPECT_EQ(0, current::RFC850DateTimeStringToTimestamp("Not valid string,").count());
 }
diff --git a/bricks/util/accumulative_scoped_deleter.h b/bricks/util/accumulative_scoped_deleter.h
index aab9c5505..583363cc2 100644
--- a/bricks/util/accumulative_scoped_deleter.h
+++ b/bricks/util/accumulative_scoped_deleter.h
@@ -45,8 +45,7 @@ class AccumulativeScopedDeleter {
   AccumulativeScopedDeleter(std::function<void()> f) : captured_{f} {}
 
   template <bool B>
-  AccumulativeScopedDeleter(AccumulativeScopedDeleter<DIFFERENTIATOR, B>&& rhs)
-      : captured_(std::move(rhs.captured_)) {
+  AccumulativeScopedDeleter(AccumulativeScopedDeleter<DIFFERENTIATOR, B>&& rhs) : captured_(std::move(rhs.captured_)) {
     rhs.captured_.clear();
   }
   template <bool B>
diff --git a/bricks/util/base64.h b/bricks/util/base64.h
index dd4cf38cc..a92b4e52e 100644
--- a/bricks/util/base64.h
+++ b/bricks/util/base64.h
@@ -152,9 +152,8 @@ inline std::string Base64Encode(const std::string& input) {
 }
 
 inline strings::Chunk Base64EncodeInto(strings::Chunk input, std::string& placeholder) {
-  base64::Impl<base64::EncodingType::Canonical>::EncodeInto(reinterpret_cast<const uint8_t*>(input.c_str()),
-                                                            input.length(),
-                                                            placeholder);
+  base64::Impl<base64::EncodingType::Canonical>::EncodeInto(
+      reinterpret_cast<const uint8_t*>(input.c_str()), input.length(), placeholder);
   return placeholder;
 }
 
diff --git a/bricks/util/comparators.h b/bricks/util/comparators.h
index 4b0cabeee..af7f66bc4 100644
--- a/bricks/util/comparators.h
+++ b/bricks/util/comparators.h
@@ -59,8 +59,7 @@ constexpr auto HasHashMethod(int) -> decltype(std::declval<const T>().Hash(), bo
 
 template <typename T>
 struct GenericHashFunctionSelector {
-  typedef custom_comparator_and_hash_function::GenericHashFunctionImpl<T, HasHashMethod<T>(0), std::is_enum_v<T>>
-      type;
+  typedef custom_comparator_and_hash_function::GenericHashFunctionImpl<T, HasHashMethod<T>(0), std::is_enum_v<T>> type;
 };
 
 }  // namespace custom_comparator_and_hash_function
diff --git a/bricks/util/iterator.h b/bricks/util/iterator.h
index d8d2f9acd..817d7f7a8 100644
--- a/bricks/util/iterator.h
+++ b/bricks/util/iterator.h
@@ -140,7 +140,7 @@ struct is_unordered_map {
   constexpr static bool value = Check<MAP>(0);
 };
 
-}  // namespace current::stl_wrappers::sfinae
+}  // namespace sfinae
 
 template <typename MAP>
 struct GenericMapAccessor final {
@@ -178,10 +178,10 @@ struct GenericMapAccessor final {
   int64_t TotalElementsForHypermediaCollectionView() const { return static_cast<int64_t>(Size()); }
 };
 
-}  // namespace current::stl_wrappers
+}  // namespace stl_wrappers
 
-using stl_wrappers::GenericMapIterator;
 using stl_wrappers::GenericMapAccessor;
+using stl_wrappers::GenericMapIterator;
 
 }  // namespace current
 
diff --git a/bricks/util/object_interface.h b/bricks/util/object_interface.h
index 242203fcf..7c6f662cd 100644
--- a/bricks/util/object_interface.h
+++ b/bricks/util/object_interface.h
@@ -41,10 +41,10 @@ SOFTWARE.
   template <>                                                   \
   struct CURRENT_OBJECT_INTERFACE_METHODS_WRAPPER<type> : CURRENT_OBJECT_INTERFACE_IMPL_POINTER_CONTAINER<type>
 
-#define CURRENT_FORWARD_METHOD(method)                                                                         \
-  template <typename... ARGS>                                                                                  \
-  auto method(ARGS&&... args) {                                                                                     \
-    return this->CURRENT_IMPLEMENTATION_POINTER->method(std::forward<ARGS>(args)...);                          \
+#define CURRENT_FORWARD_METHOD(method)                                                \
+  template <typename... ARGS>                                                         \
+  auto method(ARGS&&... args) {                                                       \
+    return this->CURRENT_IMPLEMENTATION_POINTER->method(std::forward<ARGS>(args)...); \
   }
 
 #endif  // BRICKS_UTIL_OBJECT_INTERFACE_H
diff --git a/bricks/util/random.h b/bricks/util/random.h
index 0acba168d..f9d5c1001 100644
--- a/bricks/util/random.h
+++ b/bricks/util/random.h
@@ -135,13 +135,13 @@ inline double CSRandomDouble(const double a, const double b) { return RandomReal
 }  // namespace random
 }  // namespace current
 
+using current::random::RandomDouble;
+using current::random::RandomFloat;
 using current::random::RandomInt;
-using current::random::RandomLong;
-using current::random::RandomULong;
 using current::random::RandomInt64;
+using current::random::RandomLong;
 using current::random::RandomUInt64;
-using current::random::RandomFloat;
-using current::random::RandomDouble;
+using current::random::RandomULong;
 
 using current::random::SetRandomSeed;
 
diff --git a/bricks/util/singleton.h b/bricks/util/singleton.h
index 74b50a86e..170d6bd28 100644
--- a/bricks/util/singleton.h
+++ b/bricks/util/singleton.h
@@ -105,13 +105,13 @@ struct ThreadLocalSingletonContainer : ThreadLocalSingletonContainerBase {
 };
 
 struct ThreadLocalSingletonsFactory {
-  std::unordered_map<std::type_index, std::unique_ptr<ThreadLocalSingletonContainerBase>> instances;
+  std::unordered_map<std::type_index, std::unique_ptr<ThreadLocalSingletonContainerBase> > instances;
 
   template <typename T>
   T& DoGetInstance() {
     auto& placeholder = instances[std::type_index(typeid(T))];
     if (!placeholder) {
-      placeholder = std::make_unique<ThreadLocalSingletonContainer<T>>();
+      placeholder = std::make_unique<ThreadLocalSingletonContainer<T> >();
     }
     return dynamic_cast<ThreadLocalSingletonContainer<T>&>(*placeholder).instance;
   }
diff --git a/bricks/util/test.cc b/bricks/util/test.cc
index 42f65ea14..3559b7916 100644
--- a/bricks/util/test.cc
+++ b/bricks/util/test.cc
@@ -196,11 +196,10 @@ TEST(Util, MakePointerScopeGuard) {
     EXPECT_EQ("custom_guarded_pointer\n", story);
     {
       Instance* pointer = new Instance(story);
-      const auto guard = current::MakePointerScopeGuard(pointer,
-                                                        [&story](Instance* p) {
-                                                          story += "guarded_delete\n";
-                                                          delete p;
-                                                        });
+      const auto guard = current::MakePointerScopeGuard(pointer, [&story](Instance* p) {
+        story += "guarded_delete\n";
+        delete p;
+      });
       EXPECT_EQ("custom_guarded_pointer\nconstructed\n", story);
     }
     EXPECT_EQ("custom_guarded_pointer\nconstructed\nguarded_delete\ndestructed\n", story);
@@ -242,10 +241,10 @@ TEST(Util, ThreadLocalSingleton) {
 }
 
 TEST(Util, Base64) {
-  using current::Base64Encode;
-  using current::Base64URLEncode;
   using current::Base64Decode;
+  using current::Base64Encode;
   using current::Base64URLDecode;
+  using current::Base64URLEncode;
 
   EXPECT_EQ("", Base64Encode(""));
   EXPECT_EQ("Zg==", Base64Encode("f"));
@@ -371,10 +370,9 @@ TEST(Util, WaitableTerminateSignalGotExternalTerminateSignal) {
   bool result;
   std::thread thread([&signal, &counter, &mutex, &result, &result_set]() {
     std::unique_lock<std::mutex> lock(mutex);
-    result = signal.WaitUntil(lock,
-                              [&counter]() {
-                                return counter > 1000u;  // Not going to happen in this test.
-                              });
+    result = signal.WaitUntil(lock, [&counter]() {
+      return counter > 1000u;  // Not going to happen in this test.
+    });
     result_set = true;
   });
 
@@ -445,11 +443,11 @@ TEST(Util, WaitableTerminateSignalScopedRegisterer) {
 }
 
 TEST(Util, LazyInstantiation) {
-  using current::LazilyInstantiated;
   using current::DelayedInstantiate;
   using current::DelayedInstantiateFromTuple;
   using current::DelayedInstantiateWithExtraParameter;
   using current::DelayedInstantiateWithExtraParameterFromTuple;
+  using current::LazilyInstantiated;
 
   struct Foo {
     int foo;
@@ -785,8 +783,7 @@ template <typename T>
 struct ObjectContainer {
   T object;
   template <typename... ARGS>
-  ObjectContainer(ARGS&&... args)
-      : object(std::forward<ARGS>(args)...) {}
+  ObjectContainer(ARGS&&... args) : object(std::forward<ARGS>(args)...) {}
 };
 
 template <typename T>
@@ -795,8 +792,7 @@ struct ExampleObjectInterface : private ObjectContainer<T>, public CURRENT_OBJEC
   using methods_wrapper_t = CURRENT_OBJECT_INTERFACE_METHODS_WRAPPER<T>;
 
   template <typename... ARGS>
-  ExampleObjectInterface(ARGS&&... args)
-      : object_container_t(std::forward<ARGS>(args)...) {
+  ExampleObjectInterface(ARGS&&... args) : object_container_t(std::forward<ARGS>(args)...) {
     methods_wrapper_t::CURRENT_IMPLEMENTATION_POINTER = &(object_container_t::object);
   }
 };
@@ -818,8 +814,7 @@ template <typename T>
 struct NamespacedObjectContainer {
   T object;
   template <typename... ARGS>
-  NamespacedObjectContainer(ARGS&&... args)
-      : object(std::forward<ARGS>(args)...) {}
+  NamespacedObjectContainer(ARGS&&... args) : object(std::forward<ARGS>(args)...) {}
 };
 
 template <typename T>
@@ -829,8 +824,7 @@ struct NamespacedExampleObjectInterface : private NamespacedObjectContainer<T>,
   using methods_wrapper_t = CURRENT_OBJECT_INTERFACE_METHODS_WRAPPER<T>;
 
   template <typename... ARGS>
-  NamespacedExampleObjectInterface(ARGS&&... args)
-      : object_container_t(std::forward<ARGS>(args)...) {
+  NamespacedExampleObjectInterface(ARGS&&... args) : object_container_t(std::forward<ARGS>(args)...) {
     methods_wrapper_t::CURRENT_IMPLEMENTATION_POINTER = &(object_container_t::object);
   }
 };
@@ -861,7 +855,8 @@ TEST(ObjectInterface, Smoke) {
   }
   {
     object_with_interface_test_namespace::NamespacedExampleObjectInterface<
-        object_with_interface_test_namespace::NamespacedObjectWithInterface> o;
+        object_with_interface_test_namespace::NamespacedObjectWithInterface>
+        o;
     EXPECT_EQ(1, o.total_calls());
     EXPECT_EQ(2, o.total_calls());
     EXPECT_EQ(3, o.total_calls());
diff --git a/compact_tsv/gen.cc b/compact_tsv/gen.cc
index 23c4e78fb..85157637f 100644
--- a/compact_tsv/gen.cc
+++ b/compact_tsv/gen.cc
@@ -40,20 +40,25 @@ DEFINE_size_t(random_seed, 42, "Random seed.");
 int main(int argc, char** argv) {
   ParseDFlags(&argc, &argv);
   std::unordered_map<size_t, std::string> strings;
-  CreateTSV([&strings](const std::vector<size_t>& row) {
-    for (size_t i = 0; i < row.size(); ++i) {
-      std::string& s = strings[row[i]];
-      if (s.empty()) {
-        do {
-          s += 'a' + rand() % 26;
-          if (FLAGS_nulls) {
+  CreateTSV(
+      [&strings](const std::vector<size_t>& row) {
+        for (size_t i = 0; i < row.size(); ++i) {
+          std::string& s = strings[row[i]];
+          if (s.empty()) {
             do {
-              s += '\0';
-            } while ((rand() & 31) == 31);
+              s += 'a' + rand() % 26;
+              if (FLAGS_nulls) {
+                do {
+                  s += '\0';
+                } while ((rand() & 31) == 31);
+              }
+            } while (rand() & 7);
           }
-        } while (rand() & 7);
-      }
-      std::cout << s << ((i + 1) == row.size() ? '\n' : '\t');
-    }
-  }, FLAGS_rows, FLAGS_cols, FLAGS_scale, FLAGS_random_seed);
+          std::cout << s << ((i + 1) == row.size() ? '\n' : '\t');
+        }
+      },
+      FLAGS_rows,
+      FLAGS_cols,
+      FLAGS_scale,
+      FLAGS_random_seed);
 }
diff --git a/compact_tsv/test.cc b/compact_tsv/test.cc
index e628b72a6..6617c0794 100644
--- a/compact_tsv/test.cc
+++ b/compact_tsv/test.cc
@@ -47,11 +47,16 @@ TEST(CompactTSV, Smoke) {
   std::ostringstream os;
 
   const auto t_a_begin = current::time::Now();
-  CreateTSV([&os](const std::vector<size_t> &row) {
-    for (size_t i = 0; i < row.size(); ++i) {
-      os << std::setw(2) << row[i] << ((i + 1) == row.size() ? '\n' : ' ');
-    }
-  }, FLAGS_rows, FLAGS_cols, FLAGS_scale, FLAGS_random_seed);
+  CreateTSV(
+      [&os](const std::vector<size_t> &row) {
+        for (size_t i = 0; i < row.size(); ++i) {
+          os << std::setw(2) << row[i] << ((i + 1) == row.size() ? '\n' : ' ');
+        }
+      },
+      FLAGS_rows,
+      FLAGS_cols,
+      FLAGS_scale,
+      FLAGS_random_seed);
   const auto t_a_end = current::time::Now();
 
   if (run_test) {
@@ -74,24 +79,31 @@ TEST(CompactTSV, Smoke) {
 
   CompactTSV fast;
   const auto t_b_begin = current::time::Now();
-  CreateTSV([&fast](const std::vector<size_t> &row) {
-    std::vector<std::string> row_of_strings(row.size());
-    for (size_t i = 0; i < row.size(); ++i) {
-      row_of_strings[i] = current::ToString(row[i]);
-    }
-    fast(row_of_strings);
-  }, FLAGS_rows, FLAGS_cols, FLAGS_scale, FLAGS_random_seed);
+  CreateTSV(
+      [&fast](const std::vector<size_t> &row) {
+        std::vector<std::string> row_of_strings(row.size());
+        for (size_t i = 0; i < row.size(); ++i) {
+          row_of_strings[i] = current::ToString(row[i]);
+        }
+        fast(row_of_strings);
+      },
+      FLAGS_rows,
+      FLAGS_cols,
+      FLAGS_scale,
+      FLAGS_random_seed);
   const auto t_b_end = current::time::Now();
   fast.Finalize();
 
   std::ostringstream os2;
   const auto t_c_begin = current::time::Now();
   EXPECT_EQ(FLAGS_rows,
-            CompactTSV::Unpack([&os2](const std::vector<std::string> &row) {
-              for (size_t i = 0; i < row.size(); ++i) {
-                os2 << std::setw(2) << row[i] << ((i + 1) == row.size() ? '\n' : ' ');
-              }
-            }, fast.GetPackedString()));
+            CompactTSV::Unpack(
+                [&os2](const std::vector<std::string> &row) {
+                  for (size_t i = 0; i < row.size(); ++i) {
+                    os2 << std::setw(2) << row[i] << ((i + 1) == row.size() ? '\n' : ' ');
+                  }
+                },
+                fast.GetPackedString()));
   EXPECT_EQ(golden, os2.str());
   const auto t_c_end = current::time::Now();
 
@@ -116,12 +128,12 @@ TEST(CompactTSV, Smoke) {
     std::cerr << "Original TSV size:\t" << golden_size << "b, or\t" << golden_size / (1024u * 1024u) << "MB.\n";
     std::cerr << "Packed   TSV size:\t" << packed_size << "b, or\t" << packed_size / (1024u * 1024u) << "MB.\n";
     const double K = 1e-3;  // microseconds -> milliseconds.
-    std::cerr << "Generate:                                   " << K *(t_a_end - t_a_begin).count() << "ms.\n";
-    std::cerr << "Pack:                                       " << K *(t_b_end - t_b_begin).count() << "ms.\n";
-    std::cerr << "Unpack into std::ostringstream:             " << K *(t_c_end - t_c_begin).count() << "ms.\n";
-    std::cerr << "Unpack into std::string-s:                  " << K *(t_d_end - t_d_begin).count() << "ms.\n";
-    std::cerr << "Unpack into std::pair<const char*, size_t>: " << K *(t_e_end - t_e_begin).count() << "ms.\n";
-    std::cerr << "Unpack into UniqueChunk-s:                  " << K *(t_f_end - t_f_begin).count() << "ms.\n";
+    std::cerr << "Generate:                                   " << K * (t_a_end - t_a_begin).count() << "ms.\n";
+    std::cerr << "Pack:                                       " << K * (t_b_end - t_b_begin).count() << "ms.\n";
+    std::cerr << "Unpack into std::ostringstream:             " << K * (t_c_end - t_c_begin).count() << "ms.\n";
+    std::cerr << "Unpack into std::string-s:                  " << K * (t_d_end - t_d_begin).count() << "ms.\n";
+    std::cerr << "Unpack into std::pair<const char*, size_t>: " << K * (t_e_end - t_e_begin).count() << "ms.\n";
+    std::cerr << "Unpack into UniqueChunk-s:                  " << K * (t_f_end - t_f_begin).count() << "ms.\n";
     // LCOV_EXCL_STOP
   }
 }
diff --git a/compact_tsv/unpack_fast.cc b/compact_tsv/unpack_fast.cc
index 52267ffec..a84df6cc9 100644
--- a/compact_tsv/unpack_fast.cc
+++ b/compact_tsv/unpack_fast.cc
@@ -39,13 +39,15 @@ int main(int argc, char** argv) {
   CURRENT_ASSERT(!FLAGS_input.empty());
   const auto contents = current::FileSystem::ReadFileAsString(FLAGS_input);
 
-  CompactTSV::Unpack([](const std::vector<std::pair<const char*, size_t>>& v) {
-    for (size_t i = 0; i < v.size(); ++i) {
-      if (i) {
-        fputc('\t', stdout);
-      }
-      fwrite(v[i].first, 1, v[i].second, stdout);
-    }
-    fputc('\n', stdout);
-  }, contents);
+  CompactTSV::Unpack(
+      [](const std::vector<std::pair<const char*, size_t>>& v) {
+        for (size_t i = 0; i < v.size(); ++i) {
+          if (i) {
+            fputc('\t', stdout);
+          }
+          fwrite(v[i].first, 1, v[i].second, stdout);
+        }
+        fputc('\n', stdout);
+      },
+      contents);
 }
diff --git a/examples/benchmark/generic/benchmark.h b/examples/benchmark/generic/benchmark.h
index 351f8b836..b60c67794 100644
--- a/examples/benchmark/generic/benchmark.h
+++ b/examples/benchmark/generic/benchmark.h
@@ -55,7 +55,8 @@ struct ScenariosRegisterer {
   }
   void Synopsis() const {
     std::cout << "./.current/run --scenario={scenario} [--threads={threads_to_query_from}] "
-                 "[--secons={seconds_to_run_benchmark_for}." << std::endl;
+                 "[--secons={seconds_to_run_benchmark_for}."
+              << std::endl;
     for (const auto& scenario : map) {
       std::cout << "\t--scenario=" << scenario.first << " : " << scenario.second.first << std::endl;
     }
diff --git a/examples/benchmark/generic/scenario_storage.h b/examples/benchmark/generic/scenario_storage.h
index 0bcd2a05f..4722c2d08 100644
--- a/examples/benchmark/generic/scenario_storage.h
+++ b/examples/benchmark/generic/scenario_storage.h
@@ -54,8 +54,8 @@ CURRENT_STRUCT(UInt32KeyValuePair) {
 CURRENT_STRUCT(StringKeyValuePair) {
   CURRENT_FIELD(key, std::string);
   CURRENT_FIELD(value, uint32_t);
-  CURRENT_CONSTRUCTOR(StringKeyValuePair)(const std::string key = "", uint32_t value = 0)
-      : key(std::move(key)), value(value) {}
+  CURRENT_CONSTRUCTOR(StringKeyValuePair)
+  (const std::string key = "", uint32_t value = 0) : key(std::move(key)), value(value) {}
 };
 
 CURRENT_STORAGE_FIELD_ENTRY(UnorderedDictionary, UInt32KeyValuePair, PersistedUInt32KeyValuePair);
@@ -91,32 +91,31 @@ SCENARIO(storage, "Storage transactions test.") {
         {{"size"},
          [this]() {
            db->ReadOnlyTransaction([this](ImmutableFields<storage_t> fields) {
-             if (fields.hashmap_uint32.Size() != actual_size_uint32 ||
-                 fields.hashmap_string.Size() != actual_size_string) {
-               std::cerr << "Test failed." << std::endl;
-               std::exit(-1);
-             }
-           }).Wait();
+               if (fields.hashmap_uint32.Size() != actual_size_uint32 ||
+                   fields.hashmap_string.Size() != actual_size_string) {
+                 std::cerr << "Test failed." << std::endl;
+                 std::exit(-1);
+               }
+             }).Wait();
          }},
         {{"get"},
          [this, testing_string]() {
            Value(db->ReadOnlyTransaction([this, testing_string](ImmutableFields<storage_t> fields) {
-             if (!testing_string) {
-               return Exists(fields.hashmap_uint32[RandomUInt32()]);
-             } else {
-               return Exists(fields.hashmap_string[RandomString()]);
-             }
-           }).Go());
+                     if (!testing_string) {
+                       return Exists(fields.hashmap_uint32[RandomUInt32()]);
+                     } else {
+                       return Exists(fields.hashmap_string[RandomString()]);
+                     }
+                   }).Go());
          }},
-        {{"put"},
-         [this, testing_string]() {
+        {{"put"}, [this, testing_string]() {
            db->ReadWriteTransaction([this, testing_string](MutableFields<storage_t> fields) {
-             if (!testing_string) {
-               fields.hashmap_uint32.Add(UInt32KeyValuePair(RandomUInt32(), RandomUInt32()));
-             } else {
-               fields.hashmap_string.Add(StringKeyValuePair(RandomString(), RandomUInt32()));
-             }
-           }).Wait();
+               if (!testing_string) {
+                 fields.hashmap_uint32.Add(UInt32KeyValuePair(RandomUInt32(), RandomUInt32()));
+               } else {
+                 fields.hashmap_string.Add(StringKeyValuePair(RandomString(), RandomUInt32()));
+               }
+             }).Wait();
          }}};
     const auto cit = tests.find(FLAGS_storage_transaction);
 
@@ -132,13 +131,14 @@ SCENARIO(storage, "Storage transactions test.") {
       CURRENT_ASSERT(false);
     }
 
-    const auto pair = Value(db->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      for (uint32_t i = 0; i < FLAGS_storage_initial_size; ++i) {
-        fields.hashmap_uint32.Add(UInt32KeyValuePair(RandomUInt32(), RandomUInt32()));
-        fields.hashmap_string.Add(StringKeyValuePair(RandomString(), RandomUInt32()));
-      }
-      return NonSerializablePairOfTwoSizeT(fields.hashmap_uint32.Size(), fields.hashmap_string.Size());
-    }).Go());
+    const auto pair =
+        Value(db->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                  for (uint32_t i = 0; i < FLAGS_storage_initial_size; ++i) {
+                    fields.hashmap_uint32.Add(UInt32KeyValuePair(RandomUInt32(), RandomUInt32()));
+                    fields.hashmap_string.Add(StringKeyValuePair(RandomString(), RandomUInt32()));
+                  }
+                  return NonSerializablePairOfTwoSizeT(fields.hashmap_uint32.Size(), fields.hashmap_string.Size());
+                }).Go());
     actual_size_uint32 = pair.first;
     actual_size_string = pair.second;
 
diff --git a/examples/benchmark/http/benchmark.cc b/examples/benchmark/http/benchmark.cc
index 177ec1f17..bba1f2f07 100644
--- a/examples/benchmark/http/benchmark.cc
+++ b/examples/benchmark/http/benchmark.cc
@@ -55,8 +55,7 @@ int main(int argc, char** argv) {
       while (NowInSeconds() < timestamp_end) {
         const int a = current::random::RandomIntegral(-1000000, +1000000);
         const int b = current::random::RandomIntegral(-1000000, +1000000);
-        const auto r =
-            HTTP(GET(strings::Printf(FLAGS_url.c_str(), port) + strings::Printf("?a=%d&b=%d", a, b)));
+        const auto r = HTTP(GET(strings::Printf(FLAGS_url.c_str(), port) + strings::Printf("?a=%d&b=%d", a, b)));
         CURRENT_ASSERT(r.code == HTTPResponseCode.OK);
         CURRENT_ASSERT(ParseJSON<AddResult>(r.body).sum == a + b);
         ++queries_;
diff --git a/examples/benchmark/http/server.h b/examples/benchmark/http/server.h
index 81fae735f..3305669ca 100644
--- a/examples/benchmark/http/server.h
+++ b/examples/benchmark/http/server.h
@@ -37,12 +37,9 @@ class BenchmarkTestServer {
   BenchmarkTestServer(current::net::ReservedLocalPort reserved_port, const std::string& route)
       : port_(reserved_port),
         http_server_(HTTP(std::move(reserved_port))),
-        scope_(http_server_.Register(route,
-                                   [](Request r) {
-                                     r(AddResult(current::FromString<int64_t>(r.url.query["a"]) +
-                                                 current::FromString<int64_t>(r.url.query["b"])));
-                                   }) +
-               http_server_.Register("/perftest", [](Request r) { r("perftest ok\n"); })) {}
+        scope_(http_server_.Register(route, [](Request r) {
+          r(AddResult(current::FromString<int64_t>(r.url.query["a"]) + current::FromString<int64_t>(r.url.query["b"])));
+        }) + http_server_.Register("/perftest", [](Request r) { r("perftest ok\n"); })) {}
 
   void Join() { http_server_.Join(); }
 
diff --git a/examples/benchmark/lockfree/benchmark.cc b/examples/benchmark/lockfree/benchmark.cc
index 8cd56e20b..dd0a6c82d 100644
--- a/examples/benchmark/lockfree/benchmark.cc
+++ b/examples/benchmark/lockfree/benchmark.cc
@@ -35,15 +35,16 @@ struct EpochClockGuaranteeingMonotonicity {
 
   inline std::chrono::microseconds Now() const {
     std::lock_guard<std::mutex> lock(mutex);
-    const uint64_t now_us = std::chrono::duration_cast<std::chrono::microseconds>(
-                                std::chrono::system_clock::now().time_since_epoch()).count();
+    const uint64_t now_us =
+        std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch())
+            .count();
     monotonic_now_us = std::max(monotonic_now_us + 1, now_us);
     return std::chrono::microseconds(monotonic_now_us);
   }
 };
 
 inline std::chrono::microseconds Now() { return current::Singleton<EpochClockGuaranteeingMonotonicity>().Now(); }
-}
+}  // namespace current_time_with_mutex
 
 template <typename QUERY>
 std::chrono::microseconds Run() {
@@ -64,16 +65,16 @@ std::chrono::microseconds Run() {
   };
 
   std::vector<std::unique_ptr<Thread>> threads(FLAGS_threads);
-  const auto start = 
-    std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch());
+  const auto start =
+      std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch());
   for (auto& thread : threads) {
     thread = std::make_unique<Thread>(FLAGS_iterations);
   }
   for (auto& thread : threads) {
     thread->Join();
   }
-  const auto end = 
-    std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch());
+  const auto end =
+      std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch());
   return (end - start) / FLAGS_threads;
 }
 
diff --git a/examples/benchmark/storage/replay.cc b/examples/benchmark/storage/replay.cc
index ce32dab84..06c432395 100644
--- a/examples/benchmark/storage/replay.cc
+++ b/examples/benchmark/storage/replay.cc
@@ -21,10 +21,12 @@ inline void GenerateTestData(const std::string& file, uint32_t size) {
   current::FileSystem::RmFile(file, current::FileSystem::RmFileParameters::Silent);
   auto storage = storage_t::CreateMasterStorage(file);
   for (uint32_t i = 0u; i < size; ++i) {
-    storage->ReadWriteTransaction([i](MutableFields<storage_t> fields) {
-      Entry entry(static_cast<EntryID>(i), current::SHA256(current::ToString(i)));
-      fields.entries.Add(entry);
-    }).Go();
+    storage
+        ->ReadWriteTransaction([i](MutableFields<storage_t> fields) {
+          Entry entry(static_cast<EntryID>(i), current::SHA256(current::ToString(i)));
+          fields.entries.Add(entry);
+        })
+        .Go();
   }
 }
 
@@ -141,8 +143,10 @@ inline void PerformReplayBenchmark(const std::string& file,
     auto storage = storage_t::CreateFollowingStorageAtopExistingStream(stream);
     // Spin lock checking the number of imported entries.
     while (storage_size < stream_size) {
-      storage->ReadOnlyTransaction(
-                   [&storage_size](ImmutableFields<storage_t> fields) { storage_size = fields.entries.Size(); }).Go();
+      storage
+          ->ReadOnlyTransaction(
+              [&storage_size](ImmutableFields<storage_t> fields) { storage_size = fields.entries.Size(); })
+          .Go();
       std::this_thread::sleep_for(spin_lock_sleep);
     }
     const auto end = current::time::Now();
@@ -258,42 +262,42 @@ int main(int argc, char** argv) {
                                     .ImageSize(1000)
                                     .OutputFormat("pngcairo")
                                     .Plot(WithMeta([&report](Plotter p) {
-                                      for (size_t i = 0; i < report.subs.size(); ++i) {
-                                        p(report.subs[i], 1e-3 * report.owning_storage_replay_ms[i]);
-                                      }
-                                    })
+                                            for (size_t i = 0; i < report.subs.size(); ++i) {
+                                              p(report.subs[i], 1e-3 * report.owning_storage_replay_ms[i]);
+                                            }
+                                          })
                                               .LineWidth(5)
                                               .Color("rgb '#B90000'")
                                               .Name("Owning storage"))
                                     .Plot(WithMeta([&report](Plotter p) {
-                                      for (size_t i = 0; i < report.subs.size(); ++i) {
-                                        p(report.subs[i], 1e-3 * report.following_storage_replay_ms[i]);
-                                      }
-                                    })
+                                            for (size_t i = 0; i < report.subs.size(); ++i) {
+                                              p(report.subs[i], 1e-3 * report.following_storage_replay_ms[i]);
+                                            }
+                                          })
                                               .LineWidth(5)
                                               .Color("rgb '#0000B9'")
                                               .Name("Following storage"))
                                     .Plot(WithMeta([&report](Plotter p) {
-                                      for (size_t i = 0; i < report.subs.size(); ++i) {
-                                        p(report.subs[i], 1e-3 * report.raw_persister_replay_ms[i]);
-                                      }
-                                    })
+                                            for (size_t i = 0; i < report.subs.size(); ++i) {
+                                              p(report.subs[i], 1e-3 * report.raw_persister_replay_ms[i]);
+                                            }
+                                          })
                                               .LineWidth(5)
                                               .Color("rgb '#008080'")
                                               .Name("Persister iterators"))
                                     .Plot(WithMeta([&report](Plotter p) {
-                                      for (size_t i = 0; i < report.subs.size(); ++i) {
-                                        p(report.subs[i], 1e-3 * report.raw_file_scan_ms[i]);
-                                      }
-                                    })
+                                            for (size_t i = 0; i < report.subs.size(); ++i) {
+                                              p(report.subs[i], 1e-3 * report.raw_file_scan_ms[i]);
+                                            }
+                                          })
                                               .LineWidth(5)
                                               .Color("rgb '#404040'")
                                               .Name("File scan w/o parsing"))
                                     .Plot(WithMeta([&report](Plotter p) {
-                                      for (size_t i = 0; i < report.subs.size(); ++i) {
-                                        p(report.subs[i], 1e-3 * report.parsing_file_scan_ms[i]);
-                                      }
-                                    })
+                                            for (size_t i = 0; i < report.subs.size(); ++i) {
+                                              p(report.subs[i], 1e-3 * report.parsing_file_scan_ms[i]);
+                                            }
+                                          })
                                               .LineWidth(5)
                                               .Color("rgb '#00B900'")
                                               .Name("File scan with parsing"));
diff --git a/examples/cookies_server/cookies.cc b/examples/cookies_server/cookies.cc
index 45b8a5246..eebd1e343 100644
--- a/examples/cookies_server/cookies.cc
+++ b/examples/cookies_server/cookies.cc
@@ -31,15 +31,13 @@ DEFINE_int32(cookies_demo_port, 3000, "Local port to spawn the server on.");
 int main(int argc, char** argv) {
   ParseDFlags(&argc, &argv);
 
-  HTTP(FLAGS_cookies_demo_port)
-      .Register("/",
-                [](Request r) {
-                  const auto now = current::ToString(current::time::Now().count());
-                  r(Response(r.headers.CookiesAsString())
-                        .SetCookie("Now", now)
-                        .SetCookie("SecureNow", now, {{"secure", ""}})
-                        .SetCookie("LoadedAt" + now, "Yes."));
-                });
+  HTTP(FLAGS_cookies_demo_port).Register("/", [](Request r) {
+    const auto now = current::ToString(current::time::Now().count());
+    r(Response(r.headers.CookiesAsString())
+          .SetCookie("Now", now)
+          .SetCookie("SecureNow", now, {{"secure", ""}})
+          .SetCookie("LoadedAt" + now, "Yes."));
+  });
 
   HTTP(FLAGS_cookies_demo_port).Join();
 }
diff --git a/examples/datafest_talk/tier1_cook_dataset/step2_confirm_timestamps_are_valid.cc b/examples/datafest_talk/tier1_cook_dataset/step2_confirm_timestamps_are_valid.cc
index b891a237e..307f590ad 100644
--- a/examples/datafest_talk/tier1_cook_dataset/step2_confirm_timestamps_are_valid.cc
+++ b/examples/datafest_talk/tier1_cook_dataset/step2_confirm_timestamps_are_valid.cc
@@ -9,12 +9,17 @@
 #include "../../../bricks/time/chrono.h"
 
 static std::unordered_map<std::string, int> dow_map{
-  {"Mon", 0}, {"Tue", 1}, {"Wed", 2}, {"Thu", 3}, {"Fri", 4}, {"Sat", 5}, {"Sun", 6},
+    {"Mon", 0},
+    {"Tue", 1},
+    {"Wed", 2},
+    {"Thu", 3},
+    {"Fri", 4},
+    {"Sat", 5},
+    {"Sun", 6},
 };
 
 static const char* const one_based_month_name[13] = {
-  "", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
-};
+    "", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
 
 inline void ValidateTimestamp(std::vector<current::strings::Chunk> const& pieces) {
   CURRENT_ASSERT(pieces.size() == 9);
@@ -43,15 +48,14 @@ inline void ValidateTimestamp(std::vector<current::strings::Chunk> const& pieces
 
   CURRENT_ASSERT(epoch_seconds > 0);
 
-  std::string imf_fix_date = 
-                   current::strings::Printf("%s, %2d %s %d %02d:%02d:%02d GMT",
-                                            dow_as_string.c_str(),
-                                            day,
-                                            one_based_month_name[month],
-                                            year,
-                                            hour,
-                                            minute,
-                                            second);
+  std::string imf_fix_date = current::strings::Printf("%s, %2d %s %d %02d:%02d:%02d GMT",
+                                                      dow_as_string.c_str(),
+                                                      day,
+                                                      one_based_month_name[month],
+                                                      year,
+                                                      hour,
+                                                      minute,
+                                                      second);
 
   int const imf_fix_timestamp = current::IMFFixDateTimeStringToTimestamp(imf_fix_date).count() / 1000000;
 
diff --git a/examples/datafest_talk/tier2_rides_by_months/step3_rides_by_months_unoptimized.cc b/examples/datafest_talk/tier2_rides_by_months/step3_rides_by_months_unoptimized.cc
index 23f41d7a4..bb5991926 100644
--- a/examples/datafest_talk/tier2_rides_by_months/step3_rides_by_months_unoptimized.cc
+++ b/examples/datafest_talk/tier2_rides_by_months/step3_rides_by_months_unoptimized.cc
@@ -1,5 +1,5 @@
 // To run: g++ -std=c++11 -O3 step3_rides_by_months_unoptimized.cc && time ./a.out | tee >(md5sum)
-// 
+//
 // Count rides by month, print the counters in the lexicographically sorted order of keys.
 // The "canonical C++" implementation, with extra checks, longer, and slower.
 
diff --git a/examples/datafest_talk/tier2_rides_by_months/step4_rides_by_months_still_unoptimized.cc b/examples/datafest_talk/tier2_rides_by_months/step4_rides_by_months_still_unoptimized.cc
index db6d204ec..546d01c0b 100644
--- a/examples/datafest_talk/tier2_rides_by_months/step4_rides_by_months_still_unoptimized.cc
+++ b/examples/datafest_talk/tier2_rides_by_months/step4_rides_by_months_still_unoptimized.cc
@@ -1,5 +1,5 @@
 // To run: g++ -std=c++11 -O3 step4_rides_by_months_still_unoptimized.cc && time ./a.out | tee >(md5sum)
-// 
+//
 // Count rides by month, print the counters in the lexicographically sorted order of keys.
 // The "canonical C++" implementation splitting into `Chunk`-s, not `std::string`-s.
 
diff --git a/examples/datafest_talk/tier2_rides_by_months/step6_rides_by_months_readfullfile.cc b/examples/datafest_talk/tier2_rides_by_months/step6_rides_by_months_readfullfile.cc
index bad9706de..7e96403c6 100644
--- a/examples/datafest_talk/tier2_rides_by_months/step6_rides_by_months_readfullfile.cc
+++ b/examples/datafest_talk/tier2_rides_by_months/step6_rides_by_months_readfullfile.cc
@@ -1,5 +1,5 @@
 // To run: g++ -std=c++11 -O3 step6_rides_by_months_readfullfile.cc && time ./a.out | tee >(md5sum)
-// 
+//
 // Count rides by month, print the counters in the lexicographically sorted order of keys.
 // The "read whole file into memory and analyze it" C implementation, still unsafe in a few ways.
 
@@ -22,7 +22,7 @@ int main(int argc, char** argv) {
   if (!buffer) {
     return -1;
   }
-  if (::fread(buffer, 1, length,  f) != length) {
+  if (::fread(buffer, 1, length, f) != length) {
     return -1;
   }
   ::fclose(f);
diff --git a/examples/datafest_talk/tier3_cook_binary/step1_cook.cc b/examples/datafest_talk/tier3_cook_binary/step1_cook.cc
index 856136086..245ee693e 100644
--- a/examples/datafest_talk/tier3_cook_binary/step1_cook.cc
+++ b/examples/datafest_talk/tier3_cook_binary/step1_cook.cc
@@ -1,5 +1,5 @@
 // To run: g++ -std=c++11 -O3 step1_cook.cc && time ./a.out
-// 
+//
 // Cooks the CSV file into a binary format.
 
 #include <cstdio>
@@ -10,13 +10,13 @@
 #include "../../../bricks/strings/strings.h"
 
 std::unordered_map<std::string, uint8_t> dow_map{
-  { "Mon", 0 },
-  { "Tue", 1 },
-  { "Wed", 2 },
-  { "Thu", 3 },
-  { "Fri", 4 },
-  { "Sat", 5 },
-  { "Sun", 6 },
+    {"Mon", 0},
+    {"Tue", 1},
+    {"Wed", 2},
+    {"Thu", 3},
+    {"Fri", 4},
+    {"Sat", 5},
+    {"Sun", 6},
 };
 
 void PackTimestamp(std::vector<current::strings::Chunk> const& pieces, Timestamp& timestamp) {
diff --git a/examples/datafest_talk/tier4_cook_binary_integers/schema_integers.h b/examples/datafest_talk/tier4_cook_binary_integers/schema_integers.h
index c2ad35ce5..4bbbb5624 100644
--- a/examples/datafest_talk/tier4_cook_binary_integers/schema_integers.h
+++ b/examples/datafest_talk/tier4_cook_binary_integers/schema_integers.h
@@ -41,12 +41,12 @@ struct IntegerRide {
   int32_t tolls_amount_cents;
   int32_t improvement_surcharge_cents;
   int32_t total_amount_cents;
-  uint8_t vendor_id;                // Same 1 or 2.
-  char store_and_fwd_flag;          // Same 'N' or 'Y'.
-  uint8_t ratecode_id;              // Integer, { 1, 2, 3, 4, 5, 6, 99 }.
-  uint8_t passenger_count;          // Integer, { 0 .. 9 }.
-  uint8_t payment_type;             // One of { 1, 2, 3, 4, 5 }.
-  uint8_t trip_type;                // Empty = 0, '1', or '2'.
+  uint8_t vendor_id;        // Same 1 or 2.
+  char store_and_fwd_flag;  // Same 'N' or 'Y'.
+  uint8_t ratecode_id;      // Integer, { 1, 2, 3, 4, 5, 6, 99 }.
+  uint8_t passenger_count;  // Integer, { 0 .. 9 }.
+  uint8_t payment_type;     // One of { 1, 2, 3, 4, 5 }.
+  uint8_t trip_type;        // Empty = 0, '1', or '2'.
   uint16_t pu_location_id;
   uint16_t do_location_id;
 };
diff --git a/examples/datafest_talk/tier4_cook_binary_integers/step1_cook.cc b/examples/datafest_talk/tier4_cook_binary_integers/step1_cook.cc
index 69adc2548..6aed9beac 100644
--- a/examples/datafest_talk/tier4_cook_binary_integers/step1_cook.cc
+++ b/examples/datafest_talk/tier4_cook_binary_integers/step1_cook.cc
@@ -8,13 +8,13 @@
 #include "../../../bricks/strings/strings.h"
 
 std::unordered_map<std::string, uint8_t> dow_map{
-  { "Mon", 0 },
-  { "Tue", 1 },
-  { "Wed", 2 },
-  { "Thu", 3 },
-  { "Fri", 4 },
-  { "Sat", 5 },
-  { "Sun", 6 },
+    {"Mon", 0},
+    {"Tue", 1},
+    {"Wed", 2},
+    {"Thu", 3},
+    {"Fri", 4},
+    {"Sat", 5},
+    {"Sun", 6},
 };
 
 void PackTimestamp(std::vector<current::strings::Chunk> const& pieces, Timestamp& timestamp) {
diff --git a/examples/datafest_talk/tier5_online_tool/nyc_taxi_dataset_service.h b/examples/datafest_talk/tier5_online_tool/nyc_taxi_dataset_service.h
index 31171135e..421182abd 100644
--- a/examples/datafest_talk/tier5_online_tool/nyc_taxi_dataset_service.h
+++ b/examples/datafest_talk/tier5_online_tool/nyc_taxi_dataset_service.h
@@ -110,7 +110,9 @@ class NYCTaxiDatasetServiceImpl {
   std::unordered_map<std::string, std::unique_ptr<CompiledUserFunction>> handlers_;
 
   HTTPRoutesScope RegisterRoutes(std::string route, uint16_t port) {
-    return HTTP(current::net::BarePort(port)).Register(route, URLPathArgs::CountMask::Any, [this](Request r) { Serve(std::move(r)); });
+    return HTTP(current::net::BarePort(port)).Register(route, URLPathArgs::CountMask::Any, [this](Request r) {
+      Serve(std::move(r));
+    });
   }
 
   std::string ConstructSource(const std::string& body, const std::string& source_name = "code.cc") const {
diff --git a/examples/dump_schema/dump_schema.cc b/examples/dump_schema/dump_schema.cc
index 22b6d80c4..669fc415e 100644
--- a/examples/dump_schema/dump_schema.cc
+++ b/examples/dump_schema/dump_schema.cc
@@ -24,17 +24,13 @@ SOFTWARE.
 
 #include "../../current.h"
 
-template<class T, current::reflection::Language L>
+template <class T, current::reflection::Language L>
 void DumpSchema() {
   current::reflection::StructSchema schema;
   schema.AddType<T>();
   std::cout << schema.GetSchemaInfo().Describe<L>();
 }
 
-CURRENT_STRUCT(CurrentType) {
-  CURRENT_FIELD(foo, std::string);
-};
+CURRENT_STRUCT(CurrentType) { CURRENT_FIELD(foo, std::string); };
 
-int main() {
-  DumpSchema<CurrentType, current::reflection::Language::Markdown>();
-}
+int main() { DumpSchema<CurrentType, current::reflection::Language::Markdown>(); }
diff --git a/examples/ejs/cpp/ejs.cc b/examples/ejs/cpp/ejs.cc
index 22260624b..d4253cb8b 100644
--- a/examples/ejs/cpp/ejs.cc
+++ b/examples/ejs/cpp/ejs.cc
@@ -45,48 +45,47 @@ int main(int argc, char** argv) {
 
   auto& http_server = HTTP(FLAGS_ejs_server_port);
 
-  const auto http_route_scope = http_server.Register(
-      "/",
-      [](Request request) {
-        const PrimesResponse response = [&request]() {
-          PrimesResponse response;
-          response.a = current::FromString<int64_t>(request.url.query.get("a", "1"));
-          response.b = current::FromString<int64_t>(request.url.query.get("b", "100"));
-          for (int64_t p = response.a; p <= response.b; ++p) {
-            bool is_prime = (p % 2) ? true : false;
-            for (int64_t d = 3; d * d <= p && is_prime; d += 2) {
-              if ((p % d) == 0) {
-                is_prime = false;
-              }
-            }
-            if (is_prime) {
-              response.x.push_back(p);
-            }
+  const auto http_route_scope = http_server.Register("/", [](Request request) {
+    const PrimesResponse response = [&request]() {
+      PrimesResponse response;
+      response.a = current::FromString<int64_t>(request.url.query.get("a", "1"));
+      response.b = current::FromString<int64_t>(request.url.query.get("b", "100"));
+      for (int64_t p = response.a; p <= response.b; ++p) {
+        bool is_prime = (p % 2) ? true : false;
+        for (int64_t d = 3; d * d <= p && is_prime; d += 2) {
+          if ((p % d) == 0) {
+            is_prime = false;
           }
-          return response;
-        }();
-
-        const bool html = [&request]() {
-          const char* kAcceptHeader = "Accept";
-          if (request.headers.Has(kAcceptHeader)) {
-            for (const auto& h : current::strings::Split(request.headers[kAcceptHeader].value, ',')) {
-              if (current::strings::Split(h, ';').front() == "text/html") {  // Allow "text/html; charset=...", etc.
-                return true;
-              }
-            }
+        }
+        if (is_prime) {
+          response.x.push_back(p);
+        }
+      }
+      return response;
+    }();
+
+    const bool html = [&request]() {
+      const char* kAcceptHeader = "Accept";
+      if (request.headers.Has(kAcceptHeader)) {
+        for (const auto& h : current::strings::Split(request.headers[kAcceptHeader].value, ',')) {
+          if (current::strings::Split(h, ';').front() == "text/html") {  // Allow "text/html; charset=...", etc.
+            return true;
           }
-          return false;
-        }();
-
-        if (html) {
-          request(HTTP(POST(current::strings::Printf("http://localhost:%d", static_cast<int>(FLAGS_ejs_renderer_port)),
-                            response)).body,
-                  HTTPResponseCode.OK,
-                  current::net::constants::kDefaultHTMLContentType);
-        } else {
-          request(response);
         }
-      });
+      }
+      return false;
+    }();
+
+    if (html) {
+      request(HTTP(POST(current::strings::Printf("http://localhost:%d", static_cast<int>(FLAGS_ejs_renderer_port)),
+                        response))
+                  .body,
+              HTTPResponseCode.OK,
+              current::net::constants::kDefaultHTMLContentType);
+    } else {
+      request(response);
+    }
+  });
 
   std::cout << "c++ app listening on port " << FLAGS_ejs_server_port << std::endl;
 
diff --git a/examples/embedded_db/db.cc b/examples/embedded_db/db.cc
index 728fbd776..d8b2f96e7 100644
--- a/examples/embedded_db/db.cc
+++ b/examples/embedded_db/db.cc
@@ -143,56 +143,46 @@ int main(int argc, char** argv) {
   HTTP(port).Register("/healthz", [](Request r) { r("OK\n"); });
 
   // Schema.
+  using reflection::Language;
   using reflection::SchemaInfo;
   using reflection::StructSchema;
-  using reflection::Language;
 
-  HTTP(port)
-      .Register(
-          "/schema.h",
-          [](Request r) {
-            StructSchema schema;
-            schema.AddType<Event>();
-            r(schema.GetSchemaInfo().Describe<Language::CPP>(), HTTPResponseCode.OK, "text/plain; charset=us-ascii");
-          });
-
-  HTTP(port)
-      .Register(
-          "/schema.fs",
-          [](Request r) {
-            StructSchema schema;
-            schema.AddType<Event>();
-            r(schema.GetSchemaInfo().Describe<Language::FSharp>(), HTTPResponseCode.OK, "text/plain; charset=us-ascii");
-          });
-
-  HTTP(port)
-      .Register("/schema.json",
-                [](Request r) {
-                  StructSchema schema;
-                  schema.AddType<Event>();
-                  r(schema.GetSchemaInfo());
-                });
+  HTTP(port).Register("/schema.h", [](Request r) {
+    StructSchema schema;
+    schema.AddType<Event>();
+    r(schema.GetSchemaInfo().Describe<Language::CPP>(), HTTPResponseCode.OK, "text/plain; charset=us-ascii");
+  });
+
+  HTTP(port).Register("/schema.fs", [](Request r) {
+    StructSchema schema;
+    schema.AddType<Event>();
+    r(schema.GetSchemaInfo().Describe<Language::FSharp>(), HTTPResponseCode.OK, "text/plain; charset=us-ascii");
+  });
+
+  HTTP(port).Register("/schema.json", [](Request r) {
+    StructSchema schema;
+    schema.AddType<Event>();
+    r(schema.GetSchemaInfo());
+  });
 
   // Subscribe.
   HTTP(port).Register("/data", *stream);
 
   // Publish.
-  HTTP(port)
-      .Register("/publish",
-                [&stream](Request r) {
-                  if (r.method == "POST") {
-                    try {
-                      auto event = ParseJSON<Event>(r.body);
-                      SetMicroTimestamp(event, time::Now());
-                      stream->Publisher()->Publish(std::move(event));
-                      r("", HTTPResponseCode.NoContent);
-                    } catch (const Exception& e) {
-                      r(Error(e.DetailedDescription()), HTTPResponseCode.BadRequest);
-                    }
-                  } else {
-                    r(Error("This request should be a POST."), HTTPResponseCode.MethodNotAllowed);
-                  }
-                });
+  HTTP(port).Register("/publish", [&stream](Request r) {
+    if (r.method == "POST") {
+      try {
+        auto event = ParseJSON<Event>(r.body);
+        SetMicroTimestamp(event, time::Now());
+        stream->Publisher()->Publish(std::move(event));
+        r("", HTTPResponseCode.NoContent);
+      } catch (const Exception& e) {
+        r(Error(e.DetailedDescription()), HTTPResponseCode.BadRequest);
+      }
+    } else {
+      r(Error("This request should be a POST."), HTTPResponseCode.MethodNotAllowed);
+    }
+  });
 
   // Read model.
   current::ss::StreamSubscriber<UserNicknamesReadModel, Event> read_model(port);
diff --git a/examples/embedded_db/schema.h b/examples/embedded_db/schema.h
index 15d085734..a35b4075f 100644
--- a/examples/embedded_db/schema.h
+++ b/examples/embedded_db/schema.h
@@ -71,8 +71,8 @@ CURRENT_STRUCT(UserNickname) {
   CURRENT_FIELD(user_id, std::string);
   CURRENT_FIELD(nickname, std::string);
 
-  CURRENT_CONSTRUCTOR(UserNickname)(const std::string& user_id, const std::string& nickname)
-      : user_id(user_id), nickname(nickname) {}
+  CURRENT_CONSTRUCTOR(UserNickname)
+  (const std::string& user_id, const std::string& nickname) : user_id(user_id), nickname(nickname) {}
 };
 
 CURRENT_STRUCT(UserNicknameNotFound) {
diff --git a/examples/event_collector/event_collector.h b/examples/event_collector/event_collector.h
index a1eb815a1..6083d22e0 100644
--- a/examples/event_collector/event_collector.h
+++ b/examples/event_collector/event_collector.h
@@ -80,30 +80,28 @@ class EventCollectorHTTPServer {
         last_event_t_(0u),
         events_pushed_(0u),
         timer_thread_(&EventCollectorHTTPServer::TimerThreadFunction, this),
-        http_route_scope_(HTTP(http_port_)
-                              .Register(route_,
-                                        [this](Request r) {
-                                          LogEntryWithHeaders entry;
-                                          {
-                                            const auto now = current::time::Now();
-                                            std::lock_guard<std::mutex> lock(mutex_);
-                                            entry.t = now.count();
-                                            entry.m = r.method;
-                                            entry.u = r.url.ComposeURLWithoutParameters();
-                                            entry.q = r.url.AllQueryParameters();
-                                            entry.h = r.headers.AsMap();
-                                            entry.c = r.headers.CookiesAsString();
-                                            entry.b = r.body;
-                                            entry.f = r.url.fragment;
-                                            ostream_ << JSON(entry) << std::endl;
-                                            ++events_pushed_;
-                                            last_event_t_ = now;
-                                            if (callback_) {
-                                              callback_(entry);
-                                            }
-                                          }
-                                          r(response_text_);
-                                        })) {}
+        http_route_scope_(HTTP(http_port_).Register(route_, [this](Request r) {
+          LogEntryWithHeaders entry;
+          {
+            const auto now = current::time::Now();
+            std::lock_guard<std::mutex> lock(mutex_);
+            entry.t = now.count();
+            entry.m = r.method;
+            entry.u = r.url.ComposeURLWithoutParameters();
+            entry.q = r.url.AllQueryParameters();
+            entry.h = r.headers.AsMap();
+            entry.c = r.headers.CookiesAsString();
+            entry.b = r.body;
+            entry.f = r.url.fragment;
+            ostream_ << JSON(entry) << std::endl;
+            ++events_pushed_;
+            last_event_t_ = now;
+            if (callback_) {
+              callback_(entry);
+            }
+          }
+          r(response_text_);
+        })) {}
 
   EventCollectorHTTPServer(const EventCollectorHTTPServer&) = delete;
   EventCollectorHTTPServer(EventCollectorHTTPServer&&) = delete;
diff --git a/examples/event_collector/test.cc b/examples/event_collector/test.cc
index 77e068d88..9a7ec55dd 100644
--- a/examples/event_collector/test.cc
+++ b/examples/event_collector/test.cc
@@ -144,9 +144,7 @@ TEST(EventCollector, Headers) {
   std::ostringstream os;
   EventCollectorHTTPServer collector(port, os, std::chrono::microseconds(0), "/ctfo", "=");
   EXPECT_EQ("=",
-            HTTP(GET(Printf("http://localhost:%d/ctfo", port))
-                     .SetHeader("foo", "bar")
-                     .SetHeader("baz", "meh")).body);
+            HTTP(GET(Printf("http://localhost:%d/ctfo", port)).SetHeader("foo", "bar").SetHeader("baz", "meh")).body);
   auto e = ParseJSON<LogEntryWithHeaders>(os.str());
   EXPECT_EQ("bar", e.h["foo"]);
   EXPECT_EQ("meh", e.h["baz"]);
diff --git a/examples/event_store/event_store.h b/examples/event_store/event_store.h
index 3dd18f7a1..9921c2eda 100644
--- a/examples/event_store/event_store.h
+++ b/examples/event_store/event_store.h
@@ -37,7 +37,8 @@ SOFTWARE.
 template <template <template <typename...> class, template <typename> class, typename> class CURRENT_STORAGE_TYPE,
           typename EVENT_TYPE,
           typename EXTRA_TYPE,
-          template <typename...> class DB_PERSISTER>
+          template <typename...>
+          class DB_PERSISTER>
 struct EventStore final {
   using transaction_t = current::storage::transaction_t<CURRENT_STORAGE_TYPE>;
   using stream_type_t = Variant<transaction_t, EXTRA_TYPE>;
@@ -93,14 +94,18 @@ struct EventStore final {
         r("Need one URL parameter.\n", HTTPResponseCode.BadRequest);
       } else {
         const std::string key = r.url_path_args[0];
-        event_store_storage->ReadOnlyTransaction([key](ImmutableFields<event_store_storage_t> fields) -> Response {
-          const auto event = fields.events[key];
-          if (Exists(event)) {
-            return Value(event);
-          } else {
-            return Response("Not found.\n", HTTPResponseCode.NotFound);
-          }
-        }, std::move(r)).Wait();
+        event_store_storage
+            ->ReadOnlyTransaction(
+                [key](ImmutableFields<event_store_storage_t> fields) -> Response {
+                  const auto event = fields.events[key];
+                  if (Exists(event)) {
+                    return Value(event);
+                  } else {
+                    return Response("Not found.\n", HTTPResponseCode.NotFound);
+                  }
+                },
+                std::move(r))
+            .Wait();
       }
     } else if (r.method == "POST") {
       if (!r.url_path_args.empty()) {
@@ -108,27 +113,28 @@ struct EventStore final {
       } else {
         try {
           const auto event = ParseJSON<EVENT_TYPE>(r.body);
-          event_store_storage->ReadWriteTransaction(
-                                   [this, event](MutableFields<event_store_storage_t> fields) -> Response {
-                                     auto existing_event = fields.events[event.key];
-                                     if (Exists(existing_event)) {
-                                       // Ultimately, check the timestamp of an already existing record. -- D.K.
-                                       if (JSON(Value(existing_event)) == JSON(event)) {
-                                         return Response("Already published.\n", HTTPResponseCode.OK);
-                                       } else {
-                                         return Response("Conflict, not publishing.\n", HTTPResponseCode.Conflict);
-                                       }
-                                     } else {
-                                       fields.events.Add(event);
-                                       // Note: Since the storage uses the same stream, to avoid the deadlock
-                                       // it's essential to not lock the mutex.
-                                       event_store_storage->PublisherUsed()
-                                           ->template Publish<current::locks::MutexLockStatus::AlreadyLocked>(
-                                               EXTRA_TYPE(event));
-                                       return Response("Created.\n", HTTPResponseCode.Created);
-                                     }
-                                   },
-                                   std::move(r)).Wait();
+          event_store_storage
+              ->ReadWriteTransaction(
+                  [this, event](MutableFields<event_store_storage_t> fields) -> Response {
+                    auto existing_event = fields.events[event.key];
+                    if (Exists(existing_event)) {
+                      // Ultimately, check the timestamp of an already existing record. -- D.K.
+                      if (JSON(Value(existing_event)) == JSON(event)) {
+                        return Response("Already published.\n", HTTPResponseCode.OK);
+                      } else {
+                        return Response("Conflict, not publishing.\n", HTTPResponseCode.Conflict);
+                      }
+                    } else {
+                      fields.events.Add(event);
+                      // Note: Since the storage uses the same stream, to avoid the deadlock
+                      // it's essential to not lock the mutex.
+                      event_store_storage->PublisherUsed()
+                          ->template Publish<current::locks::MutexLockStatus::AlreadyLocked>(EXTRA_TYPE(event));
+                      return Response("Created.\n", HTTPResponseCode.Created);
+                    }
+                  },
+                  std::move(r))
+              .Wait();
         } catch (const TypeSystemParseJSONException& e) {
           r(std::string("JSON parse error:\n") + e.what() + '\n', HTTPResponseCode.BadRequest);
         }
diff --git a/examples/event_store/test.cc b/examples/event_store/test.cc
index 01f0373ed..8be31cb50 100644
--- a/examples/event_store/test.cc
+++ b/examples/event_store/test.cc
@@ -53,21 +53,24 @@ TEST(EventStore, SmokeWithInMemoryEventStore) {
 
   EXPECT_EQ(0u, event_store.readonly_nonstorage_event_log_persister->Size());
 
-  const auto add_event_result = event_store.event_store_storage->ReadWriteTransaction([](MutableFields<db_t> fields) {
-    EXPECT_TRUE(fields.events.Empty());
-    Event event;
-    event.key = "id";
-    event.body.some_event_data = "foo";
-    fields.events.Add(event);
-  }).Go();
+  const auto add_event_result = event_store.event_store_storage
+                                    ->ReadWriteTransaction([](MutableFields<db_t> fields) {
+                                      EXPECT_TRUE(fields.events.Empty());
+                                      Event event;
+                                      event.key = "id";
+                                      event.body.some_event_data = "foo";
+                                      fields.events.Add(event);
+                                    })
+                                    .Go();
   EXPECT_TRUE(WasCommitted(add_event_result));
 
-  const auto verify_event_added_result =
-      event_store.event_store_storage->ReadOnlyTransaction([](ImmutableFields<db_t> fields) {
-        EXPECT_EQ(1u, fields.events.Size());
-        EXPECT_TRUE(Exists(fields.events["id"]));
-        EXPECT_EQ("foo", Value(fields.events["id"]).body.some_event_data);
-      }).Go();
+  const auto verify_event_added_result = event_store.event_store_storage
+                                             ->ReadOnlyTransaction([](ImmutableFields<db_t> fields) {
+                                               EXPECT_EQ(1u, fields.events.Size());
+                                               EXPECT_TRUE(Exists(fields.events["id"]));
+                                               EXPECT_EQ("foo", Value(fields.events["id"]).body.some_event_data);
+                                             })
+                                             .Go();
   EXPECT_TRUE(WasCommitted(verify_event_added_result));
 
   EXPECT_EQ(0u, event_store.readonly_nonstorage_event_log_persister->Size());
@@ -105,21 +108,25 @@ TEST(EventStore, SmokeWithDiskPersistedEventStore) {
 
     EXPECT_EQ(0u, event_store.readonly_nonstorage_event_log_persister->Size());
 
-    const auto add_event_result = event_store.event_store_storage->ReadWriteTransaction([](MutableFields<db_t> fields) {
-      EXPECT_TRUE(fields.events.Empty());
-      Event event;
-      event.key = "another_id";
-      event.body.some_event_data = "bar";
-      fields.events.Add(event);
-    }).Go();
+    const auto add_event_result = event_store.event_store_storage
+                                      ->ReadWriteTransaction([](MutableFields<db_t> fields) {
+                                        EXPECT_TRUE(fields.events.Empty());
+                                        Event event;
+                                        event.key = "another_id";
+                                        event.body.some_event_data = "bar";
+                                        fields.events.Add(event);
+                                      })
+                                      .Go();
     EXPECT_TRUE(WasCommitted(add_event_result));
 
     const auto verify_event_added_result =
-        event_store.event_store_storage->ReadOnlyTransaction([](ImmutableFields<db_t> fields) {
-          EXPECT_EQ(1u, fields.events.Size());
-          EXPECT_TRUE(Exists(fields.events["another_id"]));
-          EXPECT_EQ("bar", Value(fields.events["another_id"]).body.some_event_data);
-        }).Go();
+        event_store.event_store_storage
+            ->ReadOnlyTransaction([](ImmutableFields<db_t> fields) {
+              EXPECT_EQ(1u, fields.events.Size());
+              EXPECT_TRUE(Exists(fields.events["another_id"]));
+              EXPECT_EQ("bar", Value(fields.events["another_id"]).body.some_event_data);
+            })
+            .Go();
     EXPECT_TRUE(WasCommitted(verify_event_added_result));
 
     EXPECT_EQ(0u, event_store.readonly_nonstorage_event_log_persister->Size());
@@ -141,11 +148,13 @@ TEST(EventStore, SmokeWithDiskPersistedEventStore) {
     event_store_t resumed_event_store(port, "", persistence_file_name);
 
     const auto verify_persisted_result =
-        resumed_event_store.event_store_storage->ReadOnlyTransaction([](ImmutableFields<db_t> fields) {
-          EXPECT_EQ(1u, fields.events.Size());
-          EXPECT_TRUE(Exists(fields.events["another_id"]));
-          EXPECT_EQ("bar", Value(fields.events["another_id"]).body.some_event_data);
-        }).Go();
+        resumed_event_store.event_store_storage
+            ->ReadOnlyTransaction([](ImmutableFields<db_t> fields) {
+              EXPECT_EQ(1u, fields.events.Size());
+              EXPECT_TRUE(Exists(fields.events["another_id"]));
+              EXPECT_EQ("bar", Value(fields.events["another_id"]).body.some_event_data);
+            })
+            .Go();
     EXPECT_TRUE(WasCommitted(verify_persisted_result));
   }
 }
@@ -165,18 +174,19 @@ TEST(EventStore, SmokeWithHTTP) {
 
   EXPECT_EQ("UP!\n", HTTP(GET(Printf("http://localhost:%d/up", port))).body);
 
-  EXPECT_EQ(404,
-            static_cast<int>(HTTP(GET(Printf("http://localhost:%d/event/http1", port))).code));
+  EXPECT_EQ(404, static_cast<int>(HTTP(GET(Printf("http://localhost:%d/event/http1", port))).code));
 
   EXPECT_EQ(0u, event_store.readonly_nonstorage_event_log_persister->Size());
 
-  const auto add_event_result = event_store.event_store_storage->ReadWriteTransaction([](MutableFields<db_t> fields) {
-    EXPECT_TRUE(fields.events.Empty());
-    Event event;
-    event.key = "http1";
-    event.body.some_event_data = "yeah1";
-    fields.events.Add(event);
-  }).Go();
+  const auto add_event_result = event_store.event_store_storage
+                                    ->ReadWriteTransaction([](MutableFields<db_t> fields) {
+                                      EXPECT_TRUE(fields.events.Empty());
+                                      Event event;
+                                      event.key = "http1";
+                                      event.body.some_event_data = "yeah1";
+                                      fields.events.Add(event);
+                                    })
+                                    .Go();
   EXPECT_TRUE(WasCommitted(add_event_result));
 
   {
@@ -195,9 +205,7 @@ TEST(EventStore, SmokeWithHTTP) {
     event2.body.some_event_data = "yeah2";
     // Corresponding stream entry will have timestamp = `42003`, since Storage makes several `Now()` calls
     // to timestamp transaction begin/end as well as the mutation itself.
-    EXPECT_EQ(
-        201,
-        static_cast<int>(HTTP(POST(Printf("http://localhost:%d/event", port), event2)).code));
+    EXPECT_EQ(201, static_cast<int>(HTTP(POST(Printf("http://localhost:%d/event", port), event2)).code));
   }
 
   while (event_store.readonly_nonstorage_event_log_persister->Size() < 1u) {
@@ -207,11 +215,13 @@ TEST(EventStore, SmokeWithHTTP) {
   EXPECT_EQ("1\n", HTTP(GET(Printf("http://localhost:%d/subscribe?sizeonly", port))).body);
 
   const auto verify_http_event_added_result =
-      event_store.event_store_storage->ReadOnlyTransaction([](ImmutableFields<db_t> fields) {
-        EXPECT_EQ(2u, fields.events.Size());
-        EXPECT_TRUE(Exists(fields.events["http2"]));
-        EXPECT_EQ("yeah2", Value(fields.events["http2"]).body.some_event_data);
-      }).Go();
+      event_store.event_store_storage
+          ->ReadOnlyTransaction([](ImmutableFields<db_t> fields) {
+            EXPECT_EQ(2u, fields.events.Size());
+            EXPECT_TRUE(Exists(fields.events["http2"]));
+            EXPECT_EQ("yeah2", Value(fields.events["http2"]).body.some_event_data);
+          })
+          .Go();
   EXPECT_TRUE(WasCommitted(verify_http_event_added_result));
 
   ASSERT_EQ(1u, event_store.readonly_nonstorage_event_log_persister->Size());
diff --git a/examples/flow_tool/flow_tool.h b/examples/flow_tool/flow_tool.h
index cb232c066..4b316d8ee 100644
--- a/examples/flow_tool/flow_tool.h
+++ b/examples/flow_tool/flow_tool.h
@@ -33,7 +33,8 @@ SOFTWARE.
 namespace flow_tool {
 
 template <template <template <typename...> class, template <typename> class, typename> class CURRENT_STORAGE_TYPE,
-          template <typename...> class DB_PERSISTER>
+          template <typename...>
+          class DB_PERSISTER>
 class FlowTool final {
  public:
   using transaction_t = current::storage::transaction_t<CURRENT_STORAGE_TYPE>;
diff --git a/examples/flow_tool/schema.h b/examples/flow_tool/schema.h
index dd9a8bcb5..194a03a65 100644
--- a/examples/flow_tool/schema.h
+++ b/examples/flow_tool/schema.h
@@ -85,7 +85,7 @@ CURRENT_STORAGE(FlowToolDB) {
   CURRENT_STORAGE_FIELD(node, PersistedNode);
 };
 
-}  // namespace flow_tool::db
+}  // namespace db
 
 // HTTP API
 // ========
@@ -116,7 +116,7 @@ CURRENT_STRUCT(PutDirRequest){};
 
 CURRENT_VARIANT(PutRequest, PutDirRequest, PutFileRequest);
 
-}  // namespace flow_tool::api
+}  // namespace request
 
 namespace error {
 
@@ -156,7 +156,7 @@ CURRENT_STRUCT(ErrorPathNotFound, ErrorBase) {
   CURRENT_DEFAULT_CONSTRUCTOR(ErrorPathNotFound) : SUPER("ErrorPathNotFound") {}
 };
 
-}  // namespace flow_tool::api::error
+}  // namespace error
 
 namespace success {
 
@@ -168,11 +168,11 @@ CURRENT_STRUCT(FileOrDirResponse) {
 CURRENT_STRUCT(FileResponse, FileOrDirResponse) { CURRENT_FIELD(data, std::string); };
 CURRENT_STRUCT(DirResponse, FileOrDirResponse) { CURRENT_FIELD(dir, std::vector<std::string>); };
 
-}  // namespace flow_tool::api::success
+}  // namespace success
 
 CURRENT_VARIANT(SuccessfulResponse, success::FileResponse, success::DirResponse);
 
-}  // namespace flow_tool::api
+}  // namespace api
 
 }  // namespace flow_tool
 
diff --git a/examples/flow_tool/test.cc b/examples/flow_tool/test.cc
index c1c7415ad..0a5a449a0 100644
--- a/examples/flow_tool/test.cc
+++ b/examples/flow_tool/test.cc
@@ -287,8 +287,7 @@ TEST(FlowTool, CreatesDirectoriesAndAFile) {
     flow_tool::api::request::PutRequest request_body;
     request_body.template Construct<flow_tool::api::request::PutDirRequest>();
 
-    const auto response =
-        HTTP(PUT(Printf("http://localhost:%d/tree/foo/bar", port), request_body));
+    const auto response = HTTP(PUT(Printf("http://localhost:%d/tree/foo/bar", port), request_body));
     EXPECT_EQ(404, static_cast<int>(response.code)) << response.body;
     EXPECT_EQ("ErrorPathNotFound", ParseJSON<flow_tool::api::error::ErrorBase>(response.body).error);
     const auto error = ParseJSON<flow_tool::api::error::ErrorPathNotFound>(response.body);
@@ -310,8 +309,7 @@ TEST(FlowTool, CreatesDirectoriesAndAFile) {
     flow_tool::api::request::PutRequest request_body;
     request_body.template Construct<flow_tool::api::request::PutDirRequest>();
 
-    const auto response =
-        HTTP(PUT(Printf("http://localhost:%d/tree/foo/bar", port), request_body));
+    const auto response = HTTP(PUT(Printf("http://localhost:%d/tree/foo/bar", port), request_body));
     EXPECT_EQ(200, static_cast<int>(response.code)) << response.body;
     // TODO(dkorolev): Response analysis.
     // Add the timestamp created/updated, number of versions already available, and time interval since last update?
@@ -321,8 +319,7 @@ TEST(FlowTool, CreatesDirectoriesAndAFile) {
     flow_tool::api::request::PutRequest request_body;
     request_body.template Construct<flow_tool::api::request::PutFileRequest>("All good.");
 
-    const auto response =
-        HTTP(PUT(Printf("http://localhost:%d/tree/foo/bar/baz.txt", port), request_body));
+    const auto response = HTTP(PUT(Printf("http://localhost:%d/tree/foo/bar/baz.txt", port), request_body));
     EXPECT_EQ(200, static_cast<int>(response.code)) << response.body;
     // TODO(dkorolev): Response analysis.
     // Add the timestamp created/updated, number of versions already available, and time interval since last update?
@@ -413,8 +410,7 @@ TEST(FlowTool, TrailingSlashesStrictness) {
   {
     flow_tool::api::request::PutRequest request_body;
     request_body.template Construct<flow_tool::api::request::PutFileRequest>("Nope.");
-    const auto response =
-        HTTP(PUT(Printf("http://localhost:%d/tree/nope.txt/", port), request_body));
+    const auto response = HTTP(PUT(Printf("http://localhost:%d/tree/nope.txt/", port), request_body));
     EXPECT_EQ(400, static_cast<int>(response.code)) << response.body;
     EXPECT_EQ("TrailingSlashError", ParseJSON<flow_tool::api::error::ErrorBase>(response.body).error);
   }
@@ -422,8 +418,7 @@ TEST(FlowTool, TrailingSlashesStrictness) {
   {
     flow_tool::api::request::PutRequest request_body;
     request_body.template Construct<flow_tool::api::request::PutFileRequest>("Duh.");
-    const auto response =
-        HTTP(PUT(Printf("http://localhost:%d/tree/duh.txt", port), request_body));
+    const auto response = HTTP(PUT(Printf("http://localhost:%d/tree/duh.txt", port), request_body));
     EXPECT_EQ(200, static_cast<int>(response.code)) << response.body;
   }
 
diff --git a/examples/gradient_boosted_trees/evaluate.cc b/examples/gradient_boosted_trees/evaluate.cc
index 292f98116..addcfe8ab 100644
--- a/examples/gradient_boosted_trees/evaluate.cc
+++ b/examples/gradient_boosted_trees/evaluate.cc
@@ -84,33 +84,33 @@ int main(int argc, char** argv) {
         .ImageSize(1000)
         .OutputFormat("png")
         .Plot(WithMeta([&](Plotter p) {
-          double twice_area_under_pr_curve = 0.0;
-          double previous_precision = 1.0;
-          double previous_recall = 0.0;
-
-          size_t scanned = 0u;
-          double scanned_positives = 0u;
-
-          p(0.0, 1.0);
-          for (const auto& per_score : sorted) {
-            const double save_scanned_positives = scanned_positives;
-            for (size_t point = 0; point < per_score.second.second; ++point) {
-              ++scanned;
-              scanned_positives =
-                  save_scanned_positives + 1.0 * (point + 1) * per_score.second.first / per_score.second.second;
-              const double recall = scanned_positives / total_positives;
-              const double precision = scanned_positives / scanned;
-              p(recall, precision);
-              twice_area_under_pr_curve += (precision + previous_precision) * (recall - previous_recall);
-              previous_recall = recall;
-              previous_precision = precision;
-            }
-          }
-          p(1.0, 0.0);
-          twice_area_under_pr_curve += previous_precision * (1.0 - previous_recall);
-
-          std::cout << "Area under the P/R curve: " << 0.5 * twice_area_under_pr_curve << std::endl;
-        })
+                double twice_area_under_pr_curve = 0.0;
+                double previous_precision = 1.0;
+                double previous_recall = 0.0;
+
+                size_t scanned = 0u;
+                double scanned_positives = 0u;
+
+                p(0.0, 1.0);
+                for (const auto& per_score : sorted) {
+                  const double save_scanned_positives = scanned_positives;
+                  for (size_t point = 0; point < per_score.second.second; ++point) {
+                    ++scanned;
+                    scanned_positives =
+                        save_scanned_positives + 1.0 * (point + 1) * per_score.second.first / per_score.second.second;
+                    const double recall = scanned_positives / total_positives;
+                    const double precision = scanned_positives / scanned;
+                    p(recall, precision);
+                    twice_area_under_pr_curve += (precision + previous_precision) * (recall - previous_recall);
+                    previous_recall = recall;
+                    previous_precision = precision;
+                  }
+                }
+                p(1.0, 0.0);
+                twice_area_under_pr_curve += previous_precision * (1.0 - previous_recall);
+
+                std::cout << "Area under the P/R curve: " << 0.5 * twice_area_under_pr_curve << std::endl;
+              })
                   .Name("Ensemble output")
                   .LineWidth(3));
 
diff --git a/examples/gradient_boosted_trees/train.h b/examples/gradient_boosted_trees/train.h
index 433c49328..41486da0c 100644
--- a/examples/gradient_boosted_trees/train.h
+++ b/examples/gradient_boosted_trees/train.h
@@ -196,7 +196,7 @@ class TreeBuilder {
       ensemble_.nodes[node_index].value = mean_y;
     } else {
       if (dump_ostream_) {
-        *dump_ostream_ << indent << "count: " << n << ", y: " << sum_p1*(1.0 / n)
+        *dump_ostream_ << indent << "count: " << n << ", y: " << sum_p1 * (1.0 / n)
                        << ", y_stddev: " << std::sqrt(baseline_penalty / n);
       }
 
diff --git a/examples/iris/iris.h b/examples/iris/iris.h
index d567ec3af..1dfc0cea6 100644
--- a/examples/iris/iris.h
+++ b/examples/iris/iris.h
@@ -38,7 +38,8 @@ CURRENT_STRUCT(LabeledFlower) {
   CURRENT_FIELD(label, std::string);
 
   CURRENT_DEFAULT_CONSTRUCTOR(LabeledFlower) {}
-  CURRENT_CONSTRUCTOR(LabeledFlower)(size_t key, double sl, double sw, double pl, double pw, const std::string& label)
+  CURRENT_CONSTRUCTOR(LabeledFlower)
+  (size_t key, double sl, double sw, double pl, double pw, const std::string& label)
       : key(key), SL(sl), SW(sw), PL(pl), PW(pw), label(label) {}
 };
 
diff --git a/examples/iris/step2_render.cc b/examples/iris/step2_render.cc
index b596d59da..172844469 100644
--- a/examples/iris/step2_render.cc
+++ b/examples/iris/step2_render.cc
@@ -103,42 +103,37 @@ int main(int argc, char** argv) {
 
   auto& http = HTTP(FLAGS_port);
 
-  const auto scope =
-      http.Register("/",
-                    [&flowers](Request r) {
-                      if (r.url.query.has("x") && r.url.query.has("y")) {
-                        r(Plot(flowers,
-                               r.url.query["x"],
-                               r.url.query["y"],
-                               r.url.query.has("nolegend"),
-                               current::FromString<size_t>(r.url.query.get("dim", "800")),
-                               current::FromString<double>(r.url.query.get("ps", "1.75"))));
-                      } else {
-                        // I don't always generate HTML directly from C++. But when I do ... -- D.K.
-                        std::string html;
-                        html += "<!doctype html>\n";
-                        html += "<table border=1>\n";
-                        for (size_t y = 0; y < 4; ++y) {
-                          html += "  <tr>\n";
-                          for (size_t x = 0; x < 4; ++x) {
-                            if (x == y) {
-                              const auto text = features_list[x].second.name;
-                              html += "    <td align=center valign=center><h3><pre>" + text + "</pre></h1></td>\n";
-                            } else {
-                              const std::string img_a = "?x=" + features_list[x].first + "&y=" + features_list[y].first;
-                              const std::string img_src = img_a + "&dim=250&nolegend&ps=1";
-                              html += "    <td><a href='" + img_a + "'><img src='" + img_src + "' /></a></td>\n";
-                            }
-                          }
-                          html += "  </tr>\n";
-                        }
-                        html += "</table>\n";
-                        r(html,
-                          HTTPResponseCode.OK,
-                          current::net::http::Headers(),
-                          current::net::constants::kDefaultHTMLContentType);
-                      }
-                    });
+  const auto scope = http.Register("/", [&flowers](Request r) {
+    if (r.url.query.has("x") && r.url.query.has("y")) {
+      r(Plot(flowers,
+             r.url.query["x"],
+             r.url.query["y"],
+             r.url.query.has("nolegend"),
+             current::FromString<size_t>(r.url.query.get("dim", "800")),
+             current::FromString<double>(r.url.query.get("ps", "1.75"))));
+    } else {
+      // I don't always generate HTML directly from C++. But when I do ... -- D.K.
+      std::string html;
+      html += "<!doctype html>\n";
+      html += "<table border=1>\n";
+      for (size_t y = 0; y < 4; ++y) {
+        html += "  <tr>\n";
+        for (size_t x = 0; x < 4; ++x) {
+          if (x == y) {
+            const auto text = features_list[x].second.name;
+            html += "    <td align=center valign=center><h3><pre>" + text + "</pre></h1></td>\n";
+          } else {
+            const std::string img_a = "?x=" + features_list[x].first + "&y=" + features_list[y].first;
+            const std::string img_src = img_a + "&dim=250&nolegend&ps=1";
+            html += "    <td><a href='" + img_a + "'><img src='" + img_src + "' /></a></td>\n";
+          }
+        }
+        html += "  </tr>\n";
+      }
+      html += "</table>\n";
+      r(html, HTTPResponseCode.OK, current::net::http::Headers(), current::net::constants::kDefaultHTMLContentType);
+    }
+  });
 
   std::cout << "Starting the server on http://localhost:" << FLAGS_port << std::endl;
 
diff --git a/examples/iris/step3_optimize.cc b/examples/iris/step3_optimize.cc
index 7ff1ee512..29e886c1d 100644
--- a/examples/iris/step3_optimize.cc
+++ b/examples/iris/step3_optimize.cc
@@ -342,15 +342,15 @@ struct FunctionToOptimize {
     const T accuracy = fncas::exp(negative_penalty_discriminant / valid_examples);
 
     return fncas::optimize::ObjectiveFunctionValue<T>([&]() {
-      if (computation_type == ComputationType::ComputeAccuracy) {
-        // Return the probability, and the starting point should be `(1/3)`.
-        return accuracy;
-      } else {
-        // Just return the non-normalized number, for optimization purposes.
-        return computation_type == ComputationType::TrainDescriptiveModel ? negative_penalty_descriptive
-                                                                          : negative_penalty_discriminant;
-      }
-    }())
+             if (computation_type == ComputationType::ComputeAccuracy) {
+               // Return the probability, and the starting point should be `(1/3)`.
+               return accuracy;
+             } else {
+               // Just return the non-normalized number, for optimization purposes.
+               return computation_type == ComputationType::TrainDescriptiveModel ? negative_penalty_descriptive
+                                                                                 : negative_penalty_discriminant;
+             }
+           }())
         .AddPoint("accuracy", accuracy)
         .AddPoint("penalty_descriptive", -negative_penalty_descriptive)
         .AddPoint("penalty_discriminant", -negative_penalty_discriminant);
@@ -438,14 +438,15 @@ int main(int argc, char** argv) {
           fncas::optimize::DefaultOptimizer<FunctionToOptimize, fncas::OptimizationDirection::Maximize>(
               fncas::optimize::OptimizerParameters().TrackOptimizationProgress(),
               flowers,
-              ComputationType::TrainDescriptiveModel).Optimize(starting_point);
+              ComputationType::TrainDescriptiveModel)
+              .Optimize(starting_point);
       descriptive_optimization_accuracy_plot =
           Value(descriptive_optimization_result.progress).additional_values.at("accuracy");
       const std::vector<double> intermediate_point = descriptive_optimization_result.point;
-      std::cout << "After training the descriptive model, the objective function is: "
-                << FunctionToOptimize(flowers, ComputationType::ComputeAccuracy)
-                       .ObjectiveFunction(intermediate_point)
-                       .value << std::endl;
+      std::cout
+          << "After training the descriptive model, the objective function is: "
+          << FunctionToOptimize(flowers, ComputationType::ComputeAccuracy).ObjectiveFunction(intermediate_point).value
+          << std::endl;
       std::cout << "The intermediate parameters vector is: " << JSON(intermediate_point) << std::endl;
       return intermediate_point;
     } else {
@@ -458,7 +459,8 @@ int main(int argc, char** argv) {
           fncas::optimize::DefaultOptimizer<FunctionToOptimize, fncas::OptimizationDirection::Maximize>(
               fncas::optimize::OptimizerParameters().TrackOptimizationProgress(),
               flowers,
-              ComputationType::TrainDiscriminantModel).Optimize(intermediate_point);
+              ComputationType::TrainDiscriminantModel)
+              .Optimize(intermediate_point);
       discriminant_optimization_accuracy_plot =
           Value(discriminant_optimization_result.progress).additional_values.at("accuracy");
       const std::vector<double> final_point = discriminant_optimization_result.point;
@@ -549,41 +551,40 @@ int main(int argc, char** argv) {
                           current::net::constants::kDefaultHTMLContentType);
                       }
                     }) +
-      http.Register(
-          "/training_plots",
-          [descriptive_optimization_accuracy_plot, discriminant_optimization_accuracy_plot](Request r) {
-            using namespace current::gnuplot;
-            GNUPlot plot;
-            r(plot.Title("Classification Accuracy")
-                  .Grid("back")
-                  .XLabel("Iteration")
-                  .YLabel("Classification accuracy")
-                  .Plot(WithMeta([descriptive_optimization_accuracy_plot, discriminant_optimization_accuracy_plot](
-                                     Plotter& p) {
-                    size_t x = 0;
-                    for (double y : descriptive_optimization_accuracy_plot) {
-                      p(++x, y);
-                    }
-                  })
-                            .Name("Descriptive training phase")
-                            .Color("rgb 'blue'")
-                            .LineWidth(2.5))
-                  .Plot(WithMeta([descriptive_optimization_accuracy_plot, discriminant_optimization_accuracy_plot](
-                                     Plotter& p) {
-                    size_t x = descriptive_optimization_accuracy_plot.size();
-                    for (double y : discriminant_optimization_accuracy_plot) {
-                      p(++x, y);
-                    }
-                  })
-                            .Name("Discriminant training phase")
-                            .Color("rgb 'red'")
-                            .LineWidth(2.5))
-                  .OutputFormat("svg")
-                  .ImageSize(800),
-              HTTPResponseCode.OK,
-              current::net::http::Headers(),
-              current::net::constants::kDefaultSVGContentType);
-          });
+      http.Register("/training_plots",
+                    [descriptive_optimization_accuracy_plot, discriminant_optimization_accuracy_plot](Request r) {
+                      using namespace current::gnuplot;
+                      GNUPlot plot;
+                      r(plot.Title("Classification Accuracy")
+                            .Grid("back")
+                            .XLabel("Iteration")
+                            .YLabel("Classification accuracy")
+                            .Plot(WithMeta([descriptive_optimization_accuracy_plot,
+                                            discriminant_optimization_accuracy_plot](Plotter& p) {
+                                    size_t x = 0;
+                                    for (double y : descriptive_optimization_accuracy_plot) {
+                                      p(++x, y);
+                                    }
+                                  })
+                                      .Name("Descriptive training phase")
+                                      .Color("rgb 'blue'")
+                                      .LineWidth(2.5))
+                            .Plot(WithMeta([descriptive_optimization_accuracy_plot,
+                                            discriminant_optimization_accuracy_plot](Plotter& p) {
+                                    size_t x = descriptive_optimization_accuracy_plot.size();
+                                    for (double y : discriminant_optimization_accuracy_plot) {
+                                      p(++x, y);
+                                    }
+                                  })
+                                      .Name("Discriminant training phase")
+                                      .Color("rgb 'red'")
+                                      .LineWidth(2.5))
+                            .OutputFormat("svg")
+                            .ImageSize(800),
+                        HTTPResponseCode.OK,
+                        current::net::http::Headers(),
+                        current::net::constants::kDefaultSVGContentType);
+                    });
 
   std::cout << "Starting the server on http://localhost:" << FLAGS_port << std::endl;
 
diff --git a/examples/iris/test.cc b/examples/iris/test.cc
index ac0092fd9..4b7a96d1a 100644
--- a/examples/iris/test.cc
+++ b/examples/iris/test.cc
@@ -64,43 +64,45 @@ TEST(Iris, Demo) {
   const int port = reserved_port;
   auto& http_server = HTTP(std::move(reserved_port));
 
-  auto http_scope = http_server.Register(
-              "/import",
-              [&db, &number_of_flowers, &dimension_names](Request request) {
-                EXPECT_EQ("POST", request.method);
-                const std::string body = request.body;
-                db->ReadWriteTransaction([body, &number_of_flowers, &dimension_names](MutableFields<TestDB> fields) {
-                  // Skip the first line with labels.
-                  bool first_line = true;
-                  for (auto flower_definition_line : Split<ByLines>(body)) {
-                    std::vector<std::string> flower_definition_fields = Split(flower_definition_line, '\t');
-                    CURRENT_ASSERT(flower_definition_fields.size() == 5u);
-                    if (first_line && flower_definition_fields.back() == "Label") {
-                      // For this example, just overwrite the labels on each `/import`.
-                      dimension_names.clear();
-                      for (size_t i = 0; i < flower_definition_fields.size() - 1; ++i) {
-                        dimension_names[i] = flower_definition_fields[i];
-                      }
-                      continue;
-                    }
-                    first_line = false;
-                    fields.flowers.Add(LabeledFlower(++number_of_flowers,
-                                                     current::FromString<double>(flower_definition_fields[0]),
-                                                     current::FromString<double>(flower_definition_fields[1]),
-                                                     current::FromString<double>(flower_definition_fields[2]),
-                                                     current::FromString<double>(flower_definition_fields[3]),
-                                                     flower_definition_fields[4]));
-                  }
-                  return Printf("Successfully imported %d flowers.\n", static_cast<int>(number_of_flowers));
-                }, std::move(request)).Wait();
-              });
+  auto http_scope = http_server.Register("/import", [&db, &number_of_flowers, &dimension_names](Request request) {
+    EXPECT_EQ("POST", request.method);
+    const std::string body = request.body;
+    db->ReadWriteTransaction(
+          [body, &number_of_flowers, &dimension_names](MutableFields<TestDB> fields) {
+            // Skip the first line with labels.
+            bool first_line = true;
+            for (auto flower_definition_line : Split<ByLines>(body)) {
+              std::vector<std::string> flower_definition_fields = Split(flower_definition_line, '\t');
+              CURRENT_ASSERT(flower_definition_fields.size() == 5u);
+              if (first_line && flower_definition_fields.back() == "Label") {
+                // For this example, just overwrite the labels on each `/import`.
+                dimension_names.clear();
+                for (size_t i = 0; i < flower_definition_fields.size() - 1; ++i) {
+                  dimension_names[i] = flower_definition_fields[i];
+                }
+                continue;
+              }
+              first_line = false;
+              fields.flowers.Add(LabeledFlower(++number_of_flowers,
+                                               current::FromString<double>(flower_definition_fields[0]),
+                                               current::FromString<double>(flower_definition_fields[1]),
+                                               current::FromString<double>(flower_definition_fields[2]),
+                                               current::FromString<double>(flower_definition_fields[3]),
+                                               flower_definition_fields[4]));
+            }
+            return Printf("Successfully imported %d flowers.\n", static_cast<int>(number_of_flowers));
+          },
+          std::move(request))
+        .Wait();
+  });
 
   // The input file is in the `golden` directory for it to be successfully picked up by
   // `scripts/full-test.sh`.
   EXPECT_EQ("Successfully imported 150 flowers.\n",
             HTTP(POSTFromFile(Printf("http://localhost:%d/import", port),
                               current::FileSystem::JoinPath("golden", "dataset.tsv"),
-                              "text/tsv")).body);
+                              "text/tsv"))
+                .body);
 
 #if 0
   // TODO(dkorolev): Re-enable soon.
diff --git a/examples/karl/service_generator.cc b/examples/karl/service_generator.cc
index c2270ecc4..ed462b8e1 100644
--- a/examples/karl/service_generator.cc
+++ b/examples/karl/service_generator.cc
@@ -34,9 +34,7 @@ DEFINE_double(nps, 10.0, "The `numbers per second` to generate.");
 int main(int argc, char **argv) {
   ParseDFlags(&argc, &argv);
   const karl_unittest::ServiceGenerator service(
-      FLAGS_port,
-      std::chrono::microseconds(static_cast<uint64_t>(1e6 / FLAGS_nps) + 1),
-      current::karl::LocalKarl());
+      FLAGS_port, std::chrono::microseconds(static_cast<uint64_t>(1e6 / FLAGS_nps) + 1), current::karl::LocalKarl());
   std::cout << "ServiceGenerator up, http://localhost:" << FLAGS_port << "/numbers" << std::endl;
   HTTP(FLAGS_port).Join();
 }
diff --git a/examples/karl/service_karl.cc b/examples/karl/service_karl.cc
index 547a3e3a7..04b0d7a85 100644
--- a/examples/karl/service_karl.cc
+++ b/examples/karl/service_karl.cc
@@ -44,9 +44,9 @@ int main(int argc, char **argv) {
   if (!FLAGS_nginx_config.empty()) {
     params.SetNginxParameters(current::karl::KarlNginxParameters(FLAGS_nginx_port, FLAGS_nginx_config));
   }
-  const current::karl::GenericKarl<current::karl::UseOwnStorage,
-                                   current::karl::default_user_status::status,
-                                   karl_unittest::is_prime> karl(params);
+  const current::karl::
+      GenericKarl<current::karl::UseOwnStorage, current::karl::default_user_status::status, karl_unittest::is_prime>
+          karl(params);
   std::cout << "Karl up, http://localhost:" << kDefaultKarlFleetViewPort << '/' << std::endl;
   if (!FLAGS_nginx_config.empty()) {
     std::cout << "Karl's Nginx is serving on http://localhost:" << FLAGS_nginx_port << '/' << std::endl;
diff --git a/examples/optimize/main.h b/examples/optimize/main.h
index 63c32c415..849712622 100644
--- a/examples/optimize/main.h
+++ b/examples/optimize/main.h
@@ -161,10 +161,9 @@ inline int run(int& argc, char**& argv) {
   std::cout << "```\n" << std::endl;
 
   // Call the user code to solve the game.
-  const auto strategy = solve(N,
-                              A,
-                              [&](const std::vector<std::vector<fncas::double_t>>& strategy)
-                                  -> bool { return validate(N, A, strategy, false); });
+  const auto strategy = solve(N, A, [&](const std::vector<std::vector<fncas::double_t>>& strategy) -> bool {
+    return validate(N, A, strategy, false);
+  });
 
   // Make sure the solution is valid.
   if (strategy.size() != 2u || strategy[0].size() != N || strategy[1].size() != N) {
diff --git a/examples/optimize/optimize.cc b/examples/optimize/optimize.cc
index cfa00db18..d080d279b 100644
--- a/examples/optimize/optimize.cc
+++ b/examples/optimize/optimize.cc
@@ -134,9 +134,9 @@ std::vector<std::vector<fncas::double_t>> solve(
     std::function<bool(const std::vector<std::vector<fncas::double_t>>& strategy)> validate) {
   const auto build_probabilities =
       [N](const std::vector<fncas::double_t>& x) -> std::vector<std::vector<fncas::double_t>> {
-        return {simplex(std::vector<fncas::double_t>(x.begin(), x.begin() + N)),
-                simplex(std::vector<fncas::double_t>(x.begin() + N, x.begin() + N * 2))};
-      };
+    return {simplex(std::vector<fncas::double_t>(x.begin(), x.begin() + N)),
+            simplex(std::vector<fncas::double_t>(x.begin() + N, x.begin() + N * 2))};
+  };
 
   const auto pretty_print_simplex = [](const std::vector<fncas::double_t>& x) -> std::string {
     std::ostringstream os;
diff --git a/examples/type_evolution/schema.h b/examples/type_evolution/schema.h
index 55579cfbf..2fc45cb63 100644
--- a/examples/type_evolution/schema.h
+++ b/examples/type_evolution/schema.h
@@ -58,8 +58,8 @@ CURRENT_STRUCT(WithOptional) {
   CURRENT_FIELD(maybe_name, Optional<FullName>);
   CURRENT_DEFAULT_CONSTRUCTOR(WithOptional) {}
   CURRENT_CONSTRUCTOR(WithOptional)(std::integral_constant<int, 2>) : maybe_name(nullptr) {}
-  CURRENT_CONSTRUCTOR(WithOptional)(std::integral_constant<int, 3>)
-      : maybe_name(FullName(std::integral_constant<int, 2>())) {}
+  CURRENT_CONSTRUCTOR(WithOptional)
+  (std::integral_constant<int, 3>) : maybe_name(FullName(std::integral_constant<int, 2>())) {}
 };
 
 CURRENT_STRUCT(CustomTypeA) {
@@ -119,14 +119,14 @@ CURRENT_STRUCT(TopLevel) {
   CURRENT_FIELD(data, All);
   CURRENT_CONSTRUCTOR(TopLevel)(std::integral_constant<int, 0>) : data(Basic(std::integral_constant<int, 0>())) {}
   CURRENT_CONSTRUCTOR(TopLevel)(std::integral_constant<int, 1>) : data(FullName(std::integral_constant<int, 1>())) {}
-  CURRENT_CONSTRUCTOR(TopLevel)(std::integral_constant<int, 2>)
-      : data(WithOptional(std::integral_constant<int, 2>())) {}
-  CURRENT_CONSTRUCTOR(TopLevel)(std::integral_constant<int, 3>)
-      : data(WithOptional(std::integral_constant<int, 3>())) {}
-  CURRENT_CONSTRUCTOR(TopLevel)(std::integral_constant<int, 4>)
-      : data(WithExpandingVariant(std::integral_constant<int, 4>())) {}
-  CURRENT_CONSTRUCTOR(TopLevel)(std::integral_constant<int, 5>)
-      : data(WithShrinkingVariant(std::integral_constant<int, 5>())) {}
+  CURRENT_CONSTRUCTOR(TopLevel)
+  (std::integral_constant<int, 2>) : data(WithOptional(std::integral_constant<int, 2>())) {}
+  CURRENT_CONSTRUCTOR(TopLevel)
+  (std::integral_constant<int, 3>) : data(WithOptional(std::integral_constant<int, 3>())) {}
+  CURRENT_CONSTRUCTOR(TopLevel)
+  (std::integral_constant<int, 4>) : data(WithExpandingVariant(std::integral_constant<int, 4>())) {}
+  CURRENT_CONSTRUCTOR(TopLevel)
+  (std::integral_constant<int, 5>) : data(WithShrinkingVariant(std::integral_constant<int, 5>())) {}
   CURRENT_CONSTRUCTOR(TopLevel)(std::integral_constant<int, 6>) : data(WithFieldsToRemove()) {}
 };
 
diff --git a/examples/type_evolution/test.cc b/examples/type_evolution/test.cc
index 2256ffb56..0c69397c1 100644
--- a/examples/type_evolution/test.cc
+++ b/examples/type_evolution/test.cc
@@ -37,25 +37,21 @@ CURRENT_STRUCT_EVOLVER(CustomEvolver, SchemaFrom, FullName, into.full_name = fro
 CURRENT_VARIANT_EVOLVER(CustomEvolver, SchemaFrom, ShrinkingVariant, SchemaInto) {
   CURRENT_COPY_CASE(CustomTypeA);
   CURRENT_COPY_CASE(CustomTypeB);
-  CURRENT_EVOLVE_CASE(CustomTypeC,
-                       {
-                         typename INTO::CustomTypeA value;
-                         value.a = from.c + 1;
-                         into = std::move(value);
-                       });
+  CURRENT_EVOLVE_CASE(CustomTypeC, {
+    typename INTO::CustomTypeA value;
+    value.a = from.c + 1;
+    into = std::move(value);
+  });
 };
 
 // `WithFieldsToRemove` has changed. Need to copy over `.foo` and `.bar`, and process `.baz`.
-CURRENT_STRUCT_EVOLVER(CustomEvolver,
-                       SchemaFrom,
-                       WithFieldsToRemove,
-                       {
-                         CURRENT_COPY_FIELD(foo);
-                         CURRENT_COPY_FIELD(bar);
-                         if (!from.baz.empty()) {
-                           into.foo += ' ' + current::strings::Join(from.baz, ' ');
-                         }
-                       });
+CURRENT_STRUCT_EVOLVER(CustomEvolver, SchemaFrom, WithFieldsToRemove, {
+  CURRENT_COPY_FIELD(foo);
+  CURRENT_COPY_FIELD(bar);
+  if (!from.baz.empty()) {
+    into.foo += ' ' + current::strings::Join(from.baz, ' ');
+  }
+});
 
 TEST(TypeEvolution, SchemaFrom) {
   current::reflection::StructSchema struct_schema;
@@ -106,9 +102,8 @@ TEST(TypeEvolution, Data) {
     typename SchemaInto::TopLevel into;
 
     ParseJSON(line, from);
-    current::type_evolution::Evolve<SchemaFrom,
-                                    typename SchemaFrom::TopLevel,
-                                    current::type_evolution::CustomEvolver>::template Go<SchemaInto>(from, into);
+    current::type_evolution::Evolve<SchemaFrom, typename SchemaFrom::TopLevel, current::type_evolution::CustomEvolver>::
+        template Go<SchemaInto>(from, into);
 
     golden_from.push_back(JSON(from));
     golden_into.push_back(JSON(into));
diff --git a/fncas/fncas/base.h b/fncas/fncas/base.h
index 2ead34d4a..34ed3e7b3 100644
--- a/fncas/fncas/base.h
+++ b/fncas/fncas/base.h
@@ -93,7 +93,7 @@ class JITImplementation;
 
 enum class OptimizationDirection { Minimize, Maximize };
 
-}  // namespace fncas::impl
+}  // namespace impl
 
 using impl::JIT;
 using impl::OptimizationDirection;
diff --git a/fncas/fncas/differentiate.h b/fncas/fncas/differentiate.h
index 674d8c51d..a32bf287a 100644
--- a/fncas/fncas/differentiate.h
+++ b/fncas/fncas/differentiate.h
@@ -73,7 +73,7 @@ inline V d_add(const V& a, const V& b, const V& da, const V& db) {
     return da.value() + db.value();
   } else if (db.equals_to(0)) {
     return da;
-  } else if(da.equals_to(0)) {
+  } else if (da.equals_to(0)) {
     return db;
   } else {
     return da + db;
@@ -87,7 +87,7 @@ inline V d_sub(const V& a, const V& b, const V& da, const V& db) {
     return da.value() - db.value();
   } else if (db.equals_to(0)) {
     return da;
-  } else if(da.equals_to(0)) {
+  } else if (da.equals_to(0)) {
     return -db;
   } else {
     return da - db;
@@ -125,14 +125,10 @@ inline V d_mul(const V& a, const V& b, const V& da, const V& db) {
 inline node_index_t d_op(MathOperation operation, const V& a, const V& b, const V& da, const V& db) {
   static const size_t n = static_cast<size_t>(MathOperation::end);
   static const std::function<V(const V&, const V&, const V&, const V&)> differentiator[n] = {
-      d_add,
-      d_sub,
-      d_mul,
-      [](const V& a, const V& b, const V& da, const V& db) { 
+      d_add, d_sub, d_mul, [](const V& a, const V& b, const V& da, const V& db) {
         // The unary minus doesn't exist, so a "0" node would still appear there, and thus no harm.
         return (simplified_mul(b, da) - simplified_mul(a, db)) / (b * b);
-      }
-  };
+      }};
   return operation < MathOperation::end ? differentiator[static_cast<size_t>(operation)](a, b, da, db).index() : 0;
 }
 
@@ -142,7 +138,7 @@ inline node_index_t d_f(MathFunction function, const V& original, const V& x, co
       // sqr().
       [](const V&, const V& x, const V& dx) { return simplified_mul(V(2.0), simplified_mul(x, dx)); },
       // sqrt().
-      [](const V& original, const V&, const V& dx) { 
+      [](const V& original, const V&, const V& dx) {
         if (original.is_value()) {
           return simplified_mul(V(0.5 / original.value()), dx);
         } else {
@@ -152,11 +148,11 @@ inline node_index_t d_f(MathFunction function, const V& original, const V& x, co
       // exp().
       [](const V& original, const V&, const V& dx) { return simplified_mul(original, dx); },
       // log().
-      [](const V&, const V& x, const V& dx) { 
+      [](const V&, const V& x, const V& dx) {
         if (x.is_value()) {
           return simplified_mul(V(1.0) / x.value(), dx);
         } else {
-          return dx / x; 
+          return dx / x;
         }
       },
       // sin().
@@ -355,7 +351,7 @@ struct g_impl_selector<JIT::Super> {
   using type = g_super;
 };
 
-}  // namespace fncas::impl
+}  // namespace impl
 
 template <JIT JIT_IMPLEMENTATION = JIT::Super>
 using gradient_t = typename impl::g_impl_selector<JIT_IMPLEMENTATION>::type;
diff --git a/fncas/fncas/exceptions.h b/fncas/fncas/exceptions.h
index 8ab42139e..31b4a901e 100644
--- a/fncas/fncas/exceptions.h
+++ b/fncas/fncas/exceptions.h
@@ -57,7 +57,7 @@ struct BacktrackingException : FnCASOptimizationException {
   using FnCASOptimizationException::FnCASOptimizationException;
 };
 
-}  // namespace fncas::exceptions
+}  // namespace exceptions
 }  // namespace fncas
 
 #endif  // #ifndef FNCAS_FNCAS_EXCEPTIONS_H
diff --git a/fncas/fncas/jit.h b/fncas/fncas/jit.h
index 45c1f426b..0b76b608c 100644
--- a/fncas/fncas/jit.h
+++ b/fncas/fncas/jit.h
@@ -61,7 +61,10 @@ static_assert(std::is_same_v<double, double_t>, "FnCAS JIT assumes `double_t` is
 
 inline const char* operation_as_assembler_opcode(MathOperation operation) {
   static const char* representation[static_cast<size_t>(MathOperation::end)] = {
-      "addpd", "subpd", "mulpd", "divpd",
+      "addpd",
+      "subpd",
+      "mulpd",
+      "divpd",
   };
   return operation < MathOperation::end ? representation[static_cast<size_t>(operation)] : "?";
 }
@@ -859,9 +862,8 @@ struct JITCodeGenerator final {
           auto const op = node.operation();
           opcodes::load_from_memory_by_rbx_offset_to_xmm0(code, node.lhs_index() + dim);
 #ifdef FNCAS_DEBUG_NATIVE_JIT
-          std::cerr << "# Z[" << dependent_i << " + " << dim << "] = Z["
-                    << node.lhs_index() << " + " << dim << "] " << operation_as_string(op) << " Z["
-                    << node.rhs_index() << " + " << dim << "];\n";
+          std::cerr << "# Z[" << dependent_i << " + " << dim << "] = Z[" << node.lhs_index() << " + " << dim << "] "
+                    << operation_as_string(op) << " Z[" << node.rhs_index() << " + " << dim << "];\n";
 
           std::cerr << "load_from_memory_by_rbx_offset_to_xmm0(" << node.lhs_index() + dim << ");\n";
 #endif
@@ -879,7 +881,7 @@ struct JITCodeGenerator final {
           opcodes::store_xmm0_to_memory_by_rbx_offset(code, dependent_i + dim);
 #ifdef FNCAS_DEBUG_NATIVE_JIT
           std::cerr << std::string(operation_as_assembler_opcode(op)).substr(0, 3)
-                    << "_from_memory_by_rbx_offset_to_xmm0("<< node.rhs_index() + dim << ");\n";
+                    << "_from_memory_by_rbx_offset_to_xmm0(" << node.rhs_index() + dim << ");\n";
           std::cerr << "store_xmm0_to_memory_by_rbx_offset(" << dependent_i + dim << ");\n";
 #endif
         } else if (node.type() == NodeType::function) {
@@ -891,8 +893,8 @@ struct JITCodeGenerator final {
           opcodes::pop_rdi(code);
           opcodes::store_xmm0_to_memory_by_rbx_offset(code, dependent_i + dim);
 #ifdef FNCAS_DEBUG_NATIVE_JIT
-          std::cerr << "# Z[" << dependent_i << " + " << dim << "] = "
-                    << function_as_string(node.function()) << "(Z[" << node.argument_index() << " + " << dim << "]);\n";
+          std::cerr << "# Z[" << dependent_i << " + " << dim << "] = " << function_as_string(node.function()) << "(Z["
+                    << node.argument_index() << " + " << dim << "]);\n";
           std::cerr << "load_from_memory_by_rbx_offset_to_xmm0(" << node.argument_index() + dim << ");\n";
           std::cerr << "push_rdi();\n";
           std::cerr << "push_rdx();\n";
@@ -951,13 +953,9 @@ struct f_compiled_x64_native_jit final {
     actual_heap.resize(required_heap_size);
   }
 
-  explicit f_compiled_x64_native_jit(V const& node) {
-    generate_code_for_f(node);
-  }
+  explicit f_compiled_x64_native_jit(V const& node) { generate_code_for_f(node); }
 
-  explicit f_compiled_x64_native_jit(const f_impl<JIT::Blueprint>& f) {
-    generate_code_for_f(f.f_);
-  }
+  explicit f_compiled_x64_native_jit(const f_impl<JIT::Blueprint>& f) { generate_code_for_f(f.f_); }
 
   double operator()(const std::vector<double>& x) const {
     return (*jit_compiled_code)(&x[0], &actual_heap[0], &x64_native_jit_function_pointers::tls().p[0]);
@@ -1089,7 +1087,7 @@ struct g_impl_selector<JIT::X64NativeJIT> {
 };
 #endif  // FNCAS_X64_NATIVE_JIT_ENABLED
 
-}  // namespace fncas::impl
+}  // namespace impl
 }  // namespace fncas
 
 #endif  // FNCAS_USE_LONG_DOUBLE
diff --git a/fncas/fncas/logger.h b/fncas/fncas/logger.h
index 586ef0897..9951da2ec 100644
--- a/fncas/fncas/logger.h
+++ b/fncas/fncas/logger.h
@@ -69,7 +69,7 @@ struct ScopedLogToStderr final {
   ~ScopedLogToStderr() { fncas::impl::OptimizerLogger().DisableLogging(); }
 };
 
-}  // namespace fncas::impl
+}  // namespace impl
 
 namespace optimize {
 
@@ -81,7 +81,7 @@ class OptimizerStats final {
   ~OptimizerStats() {
     const auto k = static_cast<double_t>(1e6) / (current::time::Now() - begin_timestamp_).count();
     std::ostringstream os;
-    os << n_iterations_ << " iterations, " << n_iterations_* k << " per second, " << n_f_ << " f() calls, " << n_g_
+    os << n_iterations_ << " iterations, " << n_iterations_ * k << " per second, " << n_f_ << " f() calls, " << n_g_
        << " g() calls";
     if (n_backtracking_calls_) {
       os << ", " << n_backtracking_calls_ << " backtracking calls of " << n_backtracking_steps_ << " total steps";
@@ -106,7 +106,7 @@ class OptimizerStats final {
   size_t n_backtracking_steps_ = 0;
 };
 
-}  // namespace fncas::optimize
+}  // namespace optimize
 }  // namespace fncas
 
 #endif  // #ifndef FNCAS_FNCAS_LOGGER_H
diff --git a/fncas/fncas/mathutil.h b/fncas/fncas/mathutil.h
index 503610f46..0285a74c7 100644
--- a/fncas/fncas/mathutil.h
+++ b/fncas/fncas/mathutil.h
@@ -53,8 +53,7 @@ inline bool IsNormal(double_t arg) { return (std::isnormal(arg) || arg == 0.0);
 namespace impl {
 
 template <typename T>
-std::enable_if_t<std::is_arithmetic_v<T>, std::vector<T>> SumVectors(std::vector<T> a,
-                                                                     const std::vector<T>& b) {
+std::enable_if_t<std::is_arithmetic_v<T>, std::vector<T>> SumVectors(std::vector<T> a, const std::vector<T>& b) {
 #ifndef NDEBUG
   CURRENT_ASSERT(a.size() == b.size());
 #endif
@@ -69,9 +68,9 @@ std::enable_if_t<std::is_arithmetic_v<T>, std::vector<T>> SumVectors(std::vector
 }
 
 template <typename T>
-std::enable_if_t<std::is_arithmetic_v<T>, std::vector<T>>SumVectors(std::vector<T> a,
-                                                                    const std::vector<T>& b,
-                                                                    double_t kb) {
+std::enable_if_t<std::is_arithmetic_v<T>, std::vector<T>> SumVectors(std::vector<T> a,
+                                                                     const std::vector<T>& b,
+                                                                     double_t kb) {
 #ifndef NDEBUG
   CURRENT_ASSERT(a.size() == b.size());
 #endif
@@ -104,8 +103,7 @@ std::enable_if_t<std::is_arithmetic_v<T>, std::vector<T>> SumVectors(std::vector
 }
 
 template <typename T>
-std::enable_if_t<std::is_arithmetic_v<T>, T> DotProduct(const std::vector<T>& v1,
-                                                        const std::vector<T>& v2) {
+std::enable_if_t<std::is_arithmetic_v<T>, T> DotProduct(const std::vector<T>& v1, const std::vector<T>& v2) {
 #ifndef NDEBUG
   CURRENT_ASSERT(v1.size() == v2.size());
 #endif
@@ -191,7 +189,7 @@ ValueAndPoint Backtracking(F&& f,
   }
 }
 
-}  // namespace fncas::impl
+}  // namespace impl
 }  // namespace fncas
 
 #endif  // #ifndef FNCAS_FNCAS_MATHUTIL_H
diff --git a/fncas/fncas/node.h b/fncas/fncas/node.h
index 2348acefb..95a6f1aa6 100644
--- a/fncas/fncas/node.h
+++ b/fncas/fncas/node.h
@@ -53,11 +53,12 @@ inline double_t unit_step(double_t x) { return x >= 0 ? 1 : 0; }
 inline double_t ramp(double_t x) { return x > 0 ? x : 0; }
 // TODO(dkorolev): Sigmoid, its derivative, normal distribution, ERF, etc.
 }  // namespace function_impl
+using function_impl::ramp;
 using function_impl::sqr;
 using function_impl::unit_step;
-using function_impl::ramp;
 
-#define FNCAS_FUNCTION(f) inline double current_fncas_##f(double_t x) { return f(x); }
+#define FNCAS_FUNCTION(f) \
+  inline double current_fncas_##f(double_t x) { return f(x); }
 #include "fncas_functions.dsl.h"
 #undef FNCAS_FUNCTION
 
@@ -96,7 +97,10 @@ inline const char* function_as_string(MathFunction function) {
 template <typename T>
 T apply_operation(MathOperation operation, T lhs, T rhs) {
   static std::function<T(T, T)> evaluator[static_cast<size_t>(MathOperation::end)] = {
-      std::plus<T>(), std::minus<T>(), std::multiplies<T>(), std::divides<T>(),
+      std::plus<T>(),
+      std::minus<T>(),
+      std::multiplies<T>(),
+      std::divides<T>(),
   };
   return operation < MathOperation::end ? evaluator[static_cast<size_t>(operation)](lhs, rhs)
                                         : std::numeric_limits<T>::quiet_NaN();
@@ -220,7 +224,9 @@ inline double_t eval_node(node_index_t index,
       node_impl& f = node_vector_singleton()[static_cast<size_t>(dependent_i)];
       if (f.type() == NodeType::operation) {
         growing_vector_access(node_value, dependent_i, 0.0) =
-            apply_operation<double_t>(f.operation(), node_value[static_cast<size_t>(f.lhs_index())], node_value[static_cast<size_t>(f.rhs_index())]);
+            apply_operation<double_t>(f.operation(),
+                                      node_value[static_cast<size_t>(f.lhs_index())],
+                                      node_value[static_cast<size_t>(f.rhs_index())]);
         growing_vector_access(B, dependent_i, static_cast<int8_t>(false)) = true;
       } else if (f.type() == NodeType::function) {
         growing_vector_access(node_value, dependent_i, 0.0) =
@@ -296,7 +302,9 @@ struct GenericV : node_index_allocator {
   GenericV rhs() const { return from_index(node_vector_singleton()[static_cast<size_t>(index_)].rhs_index()); }
   MathFunction& function() const { return node_vector_singleton()[static_cast<size_t>(index_)].function(); }
   node_index_t& argument_index() const { return node_vector_singleton()[static_cast<size_t>(index_)].argument_index(); }
-  GenericV argument() const { return from_index(node_vector_singleton()[static_cast<size_t>(index_)].argument_index()); }
+  GenericV argument() const {
+    return from_index(node_vector_singleton()[static_cast<size_t>(index_)].argument_index());
+  }
   static GenericV create_variable_node(node_index_t index) {
     GenericV result;
     result.type() = NodeType::variable;
@@ -339,7 +347,7 @@ static_assert(sizeof(V) == 8, "sizeof(V) should be 8, as sizeof(node_index_t).")
 // Class "x" is the placeholder class an instance of which is to be passed to the user function
 // to record the computation rather than perform it.
 
-}  // namespace fncas::impl
+}  // namespace impl
 }  // namespace fncas
 
 // A thin wrapper replacing `std::vector<V>`, with the sole purpose of being able to inherit from it
@@ -476,8 +484,7 @@ struct f_impl<JIT::Blueprint> final : f_super {
   // Template is used here as a form of forward declaration.
   template <typename TX>
   V differentiate(const TX& x_ref, size_t variable_index) const {
-    static_assert(std::is_same_v<TX, X>,
-                  "f_impl<JIT::Blueprint>::differentiate(const x& x, size_t variable_index);");
+    static_assert(std::is_same_v<TX, X>, "f_impl<JIT::Blueprint>::differentiate(const x& x, size_t variable_index);");
     CURRENT_ASSERT(&x_ref == internals_singleton().x_ptr_);
     CURRENT_ASSERT(variable_index >= 0);
     CURRENT_ASSERT(variable_index < dim());
@@ -497,7 +504,7 @@ struct f_impl_selector<JIT::Super> {
   using type = f_super;
 };
 
-}  // namespace fncas::impl
+}  // namespace impl
 }  // namespace fncas
 
 // Arithmetic operations and mathematical functions are defined outside namespace fncas::impl.
diff --git a/fncas/fncas/optimize.h b/fncas/fncas/optimize.h
index 23d3e51fa..6b4a609b7 100644
--- a/fncas/fncas/optimize.h
+++ b/fncas/fncas/optimize.h
@@ -758,8 +758,8 @@ struct OptimizeImpl<ConjugateGradientOptimizerSelector, DIRECTION> {
         stats.JournalIteration();
         if (logger) {
           // `PointAsString()` is an expensive call, don't make it if `logger` is not initialized.
-          logger.Log("ConjugateGradientOptimizer: Iteration " + current::ToString(iteration + 1) + ", OF = " +
-                     current::ToString(current.value) + " @ " + super.PointAsString(current.point));
+          logger.Log("ConjugateGradientOptimizer: Iteration " + current::ToString(iteration + 1) +
+                     ", OF = " + current::ToString(current.value) + " @ " + super.PointAsString(current.point));
         }
         try {
           // Backtracking line search.
@@ -829,7 +829,7 @@ template <class F,
           JIT JIT_IMPLEMENTATION = JIT::Default>
 using DefaultOptimizer = ConjugateGradientOptimizer<F, DIRECTION, JIT_IMPLEMENTATION>;
 
-}  // namespace fncas::optimize
+}  // namespace optimize
 }  // namespace fncas
 
 #endif  // #ifndef FNCAS_FNCAS_OPTIMIZE_H
diff --git a/fncas/test.cc b/fncas/test.cc
index e422c3f8c..51f2c23b9 100644
--- a/fncas/test.cc
+++ b/fncas/test.cc
@@ -361,8 +361,9 @@ TEST(FnCAS, OptimizationOfAStaticFunctionNoJIT) {
   size_t iterations = 0;
   {
     // A run without computing the original function at each step.
-    const auto result = fncas::optimize::GradientDescentOptimizer<StaticFunction>(
-                            fncas::optimize::OptimizerParameters().DisableJIT()).Optimize({0, 0});
+    const auto result =
+        fncas::optimize::GradientDescentOptimizer<StaticFunction>(fncas::optimize::OptimizerParameters().DisableJIT())
+            .Optimize({0, 0});
     iterations = result.optimization_iterations;
     EXPECT_GE(iterations, 3u);  // Should be at least three iterations.
     EXPECT_NEAR(1.0, result.value, 1e-3);
@@ -374,9 +375,9 @@ TEST(FnCAS, OptimizationOfAStaticFunctionNoJIT) {
   {
     // Another run that does compute the original function at each step, confirm
     // the "param" intermediate value has been recorded.
-    const auto result =
-        fncas::optimize::GradientDescentOptimizer<StaticFunction>(
-            fncas::optimize::OptimizerParameters().DisableJIT().TrackOptimizationProgress()).Optimize({0, 0});
+    const auto result = fncas::optimize::GradientDescentOptimizer<StaticFunction>(
+                            fncas::optimize::OptimizerParameters().DisableJIT().TrackOptimizationProgress())
+                            .Optimize({0, 0});
     EXPECT_EQ(iterations, result.optimization_iterations);
     EXPECT_NEAR(1.0, result.value, 1e-3);
     ASSERT_EQ(2u, result.point.size());
@@ -391,8 +392,9 @@ TEST(FnCAS, OptimizationOfAStaticFunctionNoJIT) {
     const auto& param_values = progress.additional_values.at("param");
     ASSERT_EQ(iterations, param_values.size());
     for (size_t i = 1; i < iterations; ++i) {
-      EXPECT_LT(progress.objective_function_values[i], progress.objective_function_values[i - 1]) << JSON(progress)
-                                                                                                  << '\n' << i;
+      EXPECT_LT(progress.objective_function_values[i], progress.objective_function_values[i - 1])
+          << JSON(progress) << '\n'
+          << i;
     }
     for (size_t i = 0; i < iterations; ++i) {
       EXPECT_EQ(progress.objective_function_values[i], std::exp(0.01 * param_values[i])) << JSON(progress) << '\n' << i;
@@ -404,8 +406,9 @@ TEST(FnCAS, OptimizationOfAMemberFunctionNoJIT) {
   MemberFunction f;
   f.a = 3.0;
   f.b = 4.0;
-  const auto result = fncas::optimize::GradientDescentOptimizer<MemberFunction>(
-                          fncas::optimize::OptimizerParameters().DisableJIT(), f).Optimize({0, 0});
+  const auto result =
+      fncas::optimize::GradientDescentOptimizer<MemberFunction>(fncas::optimize::OptimizerParameters().DisableJIT(), f)
+          .Optimize({0, 0});
   EXPECT_NEAR(1.0, result.value, 1e-3);
   ASSERT_EQ(2u, result.point.size());
   EXPECT_NEAR(3.0, result.point[0], 1e-3);
@@ -548,8 +551,9 @@ TEST(FnCAS, JITOptimizationOfHimmelblauUsingConjugateGradient) {
 #endif  // FNCAS_JIT_COMPILED
 
 TEST(FnCAS, OptimizationOfAPolynomialMemberFunctionNoJIT) {
-  const auto result = fncas::optimize::GradientDescentOptimizer<PolynomialFunction>(
-                          fncas::optimize::OptimizerParameters().DisableJIT()).Optimize({5.0, 20.0});
+  const auto result =
+      fncas::optimize::GradientDescentOptimizer<PolynomialFunction>(fncas::optimize::OptimizerParameters().DisableJIT())
+          .Optimize({5.0, 20.0});
   EXPECT_NEAR(0.0, result.value, 1e-3);
   ASSERT_EQ(2u, result.point.size());
   EXPECT_NEAR(0.0, result.point[0], 1e-3);
@@ -558,7 +562,8 @@ TEST(FnCAS, OptimizationOfAPolynomialMemberFunctionNoJIT) {
 
 TEST(FnCAS, OptimizationOfAPolynomialUsingBacktrackingGDNoJIT) {
   const auto result = fncas::optimize::GradientDescentOptimizerBT<PolynomialFunction>(
-                          fncas::optimize::OptimizerParameters().DisableJIT()).Optimize({5.0, 20.0});
+                          fncas::optimize::OptimizerParameters().DisableJIT())
+                          .Optimize({5.0, 20.0});
   EXPECT_NEAR(0.0, result.value, 1e-3);
   ASSERT_EQ(2u, result.point.size());
   EXPECT_NEAR(0.0, result.point[0], 1e-3);
@@ -567,7 +572,8 @@ TEST(FnCAS, OptimizationOfAPolynomialUsingBacktrackingGDNoJIT) {
 
 TEST(FnCAS, OptimizationOfAPolynomialUsingConjugateGradientNoJIT) {
   const auto result = fncas::optimize::ConjugateGradientOptimizer<PolynomialFunction>(
-                          fncas::optimize::OptimizerParameters().DisableJIT()).Optimize({5.0, 20.0});
+                          fncas::optimize::OptimizerParameters().DisableJIT())
+                          .Optimize({5.0, 20.0});
   EXPECT_NEAR(0.0, result.value, 1e-6);
   ASSERT_EQ(2u, result.point.size());
   EXPECT_NEAR(0.0, result.point[0], 1e-6);
@@ -576,7 +582,8 @@ TEST(FnCAS, OptimizationOfAPolynomialUsingConjugateGradientNoJIT) {
 
 TEST(FnCAS, OptimizationOfRosenbrockUsingConjugateGradientNoJIT) {
   const auto result = fncas::optimize::ConjugateGradientOptimizer<RosenbrockFunction>(
-                          fncas::optimize::OptimizerParameters().DisableJIT()).Optimize({-3.0, -4.0});
+                          fncas::optimize::OptimizerParameters().DisableJIT())
+                          .Optimize({-3.0, -4.0});
   EXPECT_NEAR(0.0, result.value, 1e-6);
   ASSERT_EQ(2u, result.point.size());
   EXPECT_NEAR(1.0, result.point[0], 1e-6);
@@ -618,14 +625,14 @@ TEST(FnCAS, NaiveGDvsBacktrackingGDOnRosenbrockFunction1000StepsNoJIT) {
   fncas::optimize::OptimizerParameters params;
   params.SetValue("max_steps", 1000);
   params.SetValue("step_factor", 0.001);  // Used only by naive optimizer. Prevents it from moving to infinity.
-  const auto result_naive =
-      fncas::optimize::GradientDescentOptimizer<RosenbrockFunction,
-                                                fncas::OptimizationDirection::Minimize,
-                                                fncas::JIT::Blueprint>(params).Optimize({-3.0, -4.0});
-  const auto result_bt =
-      fncas::optimize::GradientDescentOptimizerBT<RosenbrockFunction,
-                                                  fncas::OptimizationDirection::Minimize,
-                                                  fncas::JIT::Blueprint>(params).Optimize({-3.0, -4.0});
+  const auto result_naive = fncas::optimize::GradientDescentOptimizer<RosenbrockFunction,
+                                                                      fncas::OptimizationDirection::Minimize,
+                                                                      fncas::JIT::Blueprint>(params)
+                                .Optimize({-3.0, -4.0});
+  const auto result_bt = fncas::optimize::GradientDescentOptimizerBT<RosenbrockFunction,
+                                                                     fncas::OptimizationDirection::Minimize,
+                                                                     fncas::JIT::Blueprint>(params)
+                             .Optimize({-3.0, -4.0});
   const fncas::double_t x0_err_n = std::abs(result_naive.point[0] - 1.0);
   const fncas::double_t x0_err_bt = std::abs(result_bt.point[0] - 1.0);
   const fncas::double_t x1_err_n = std::abs(result_naive.point[1] - 1.0);
@@ -745,7 +752,8 @@ TEST(FnCAS, OptimizationOfNegativeAndZeroCrossingFunctions) {
     f.b = 4.0;
     f.c = -1.01;
     const auto result = fncas::optimize::GradientDescentOptimizer<MemberFunction>(
-                            fncas::optimize::OptimizerParameters().DisableJIT(), f).Optimize({0, 0});
+                            fncas::optimize::OptimizerParameters().DisableJIT(), f)
+                            .Optimize({0, 0});
     EXPECT_NEAR(-0.01, result.value, 1e-3);
     ASSERT_EQ(2u, result.point.size());
     EXPECT_NEAR(3.0, result.point[0], 1e-3);
@@ -757,7 +765,8 @@ TEST(FnCAS, OptimizationOfNegativeAndZeroCrossingFunctions) {
     f.b = 4.0;
     f.c = -0.99;
     const auto result = fncas::optimize::GradientDescentOptimizer<MemberFunction>(
-                            fncas::optimize::OptimizerParameters().DisableJIT(), f).Optimize({0, 0});
+                            fncas::optimize::OptimizerParameters().DisableJIT(), f)
+                            .Optimize({0, 0});
     EXPECT_NEAR(+0.01, result.value, 1e-3);
     ASSERT_EQ(2u, result.point.size());
     EXPECT_NEAR(3.0, result.point[0], 1e-3);
@@ -769,7 +778,8 @@ TEST(FnCAS, OptimizationOfNegativeAndZeroCrossingFunctions) {
     f.b = 4.0;
     f.c = -100;
     const auto result = fncas::optimize::GradientDescentOptimizer<MemberFunction>(
-                            fncas::optimize::OptimizerParameters().DisableJIT(), f).Optimize({0, 0});
+                            fncas::optimize::OptimizerParameters().DisableJIT(), f)
+                            .Optimize({0, 0});
     EXPECT_NEAR(-99, result.value, 1e-3);
     ASSERT_EQ(2u, result.point.size());
     EXPECT_NEAR(3.0, result.point[0], 1e-3);
@@ -785,7 +795,8 @@ TEST(FnCAS, OptimizationInMaximizingDirection) {
     f.k = -1;
     const auto result =
         fncas::optimize::GradientDescentOptimizer<MemberFunction, fncas::OptimizationDirection::Maximize>(
-            fncas::optimize::OptimizerParameters().DisableJIT(), f).Optimize({0, 0});
+            fncas::optimize::OptimizerParameters().DisableJIT(), f)
+            .Optimize({0, 0});
     EXPECT_NEAR(-1, result.value, 1e-3);
     ASSERT_EQ(2u, result.point.size());
     EXPECT_NEAR(2.0, result.point[0], 1e-3);
@@ -799,7 +810,8 @@ TEST(FnCAS, OptimizationInMaximizingDirection) {
     f.k = -1;
     const auto result =
         fncas::optimize::GradientDescentOptimizerBT<MemberFunction, fncas::OptimizationDirection::Maximize>(
-            fncas::optimize::OptimizerParameters().DisableJIT(), f).Optimize({0, 0});
+            fncas::optimize::OptimizerParameters().DisableJIT(), f)
+            .Optimize({0, 0});
     EXPECT_NEAR(-1, result.value, 1e-3);
     ASSERT_EQ(2u, result.point.size());
     EXPECT_NEAR(4.0, result.point[0], 5e-2);
@@ -813,7 +825,8 @@ TEST(FnCAS, OptimizationInMaximizingDirection) {
     f.k = -1;
     const auto result =
         fncas::optimize::ConjugateGradientOptimizer<MemberFunction, fncas::OptimizationDirection::Maximize>(
-            fncas::optimize::OptimizerParameters().DisableJIT(), f).Optimize({0, 0});
+            fncas::optimize::OptimizerParameters().DisableJIT(), f)
+            .Optimize({0, 0});
     EXPECT_NEAR(-1, result.value, 1e-3);
     ASSERT_EQ(2u, result.point.size());
     EXPECT_NEAR(6.0, result.point[0], 5e-2);
@@ -887,7 +900,7 @@ TEST(FnCASX64NativeJIT, TrivialFunctions) {
     fncas::function_t<fncas::JIT::X64NativeJIT> const fn(TrivialFunctionAdd(fncas::variables_vector_t(2)));
     EXPECT_EQ(3.0, fn({1.0, 2.0}));
     EXPECT_EQ(4.0, fn({1.5, 2.5}));
-    EXPECT_EQ(142.0, fn({42.0, 100,0}));
+    EXPECT_EQ(142.0, fn({42.0, 100, 0}));
   }
 
   {
diff --git a/fncas/x64_native_jit/x64_native_jit.h b/fncas/x64_native_jit/x64_native_jit.h
index 928b8ae06..fe1fd999a 100644
--- a/fncas/x64_native_jit/x64_native_jit.h
+++ b/fncas/x64_native_jit/x64_native_jit.h
@@ -341,10 +341,10 @@ void call_function_from_rdx_pointers_array_by_index(C& c, uint8_t index) {
   c.push_back((index + 1) * 0x08);
 }
 
-}  // namespace current::fncas::x64_native_jit::opcodes
+}  // namespace opcodes
 
-}  // namespace current::fncas::x64_native_jit
-}  // namespace current::fncas
+}  // namespace x64_native_jit
+}  // namespace fncas
 }  // namespace current
 
 #endif  // defined(__x86_64__)
diff --git a/integrations/adwords/conversion_tracking.h b/integrations/adwords/conversion_tracking.h
index c741f87b8..5733f46b8 100644
--- a/integrations/adwords/conversion_tracking.h
+++ b/integrations/adwords/conversion_tracking.h
@@ -113,9 +113,9 @@ server {
   const std::string get_url_;
 };
 
-}  // namespace current::integrations::adwords::conversion_tracking
-}  // namespace current::integrations::adwords
-}  // namespace current::integrations
+}  // namespace conversion_tracking
+}  // namespace adwords
+}  // namespace integrations
 }  // namespace current
 
 #endif  // INTEGRATIONS_ADWORDS_CONVERSION_TRACKING_H
diff --git a/integrations/adwords/exceptions.h b/integrations/adwords/exceptions.h
index 9661cfe4a..969704333 100644
--- a/integrations/adwords/exceptions.h
+++ b/integrations/adwords/exceptions.h
@@ -39,8 +39,8 @@ struct AdWordsInitializationException : AdWordsException {
   using AdWordsException::AdWordsException;
 };
 
-}  // namespace current::integrations::adwords
-}  // namespace current::integrations
+}  // namespace adwords
+}  // namespace integrations
 }  // namespace current
 
 #endif  // INTEGRATIONS_ADWORDS_EXCEPTIONS_H
diff --git a/integrations/exceptions.h b/integrations/exceptions.h
index 0cbfc3927..9072b621d 100644
--- a/integrations/exceptions.h
+++ b/integrations/exceptions.h
@@ -34,7 +34,7 @@ struct IntegrationException : Exception {
   using Exception::Exception;
 };
 
-}  // namespace current::integrations
+}  // namespace integrations
 }  // namespace current
 
 #endif  // INTEGRATIONS_EXCEPTIONS_H
diff --git a/integrations/onesignal/exceptions.h b/integrations/onesignal/exceptions.h
index 9081e4dae..848625787 100644
--- a/integrations/onesignal/exceptions.h
+++ b/integrations/onesignal/exceptions.h
@@ -43,8 +43,8 @@ struct OneSignalPushNotificationException : OneSignalException {
   using OneSignalException::OneSignalException;
 };
 
-}  // namespace current::integrations::onesignal
-}  // namespace current::integrations
+}  // namespace onesignal
+}  // namespace integrations
 }  // namespace current
 
 #endif  // INTEGRATIONS_ONESIGNAL_EXCEPTIONS_H
diff --git a/integrations/onesignal/ios_notifications_sender.h b/integrations/onesignal/ios_notifications_sender.h
index f4b0fffcf..97856d314 100644
--- a/integrations/onesignal/ios_notifications_sender.h
+++ b/integrations/onesignal/ios_notifications_sender.h
@@ -184,8 +184,8 @@ server {
   const std::string post_url_;
 };
 
-}  // namespace current::integrations::onesignal
-}  // namespace current::integrations
+}  // namespace onesignal
+}  // namespace integrations
 }  // namespace current
 
 #endif  // INTEGRATIONS_ONESIGNAL_IOS_NOTIFICATIONS_SENDER_H
diff --git a/integrations/segment/schema_web.h b/integrations/segment/schema_web.h
index 20f8cb6a4..788bf6937 100644
--- a/integrations/segment/schema_web.h
+++ b/integrations/segment/schema_web.h
@@ -82,9 +82,9 @@ CURRENT_STRUCT(Event) {
   CURRENT_FIELD(version, Optional<double>);  // What if they decide to use `2.1`. -- D.K.
 };
 
-}  // namespace current::integrations::web
-}  // namespace current::integrations::segment
-}  // namespace current::integrations
+}  // namespace web
+}  // namespace segment
+}  // namespace integrations
 }  // namespace current
 
 #endif  // INTEGRATIONS_SEGMENT_SCHEMA_WEB_H
diff --git a/karl/claire.h b/karl/claire.h
index c26c56030..60e40a0ce 100644
--- a/karl/claire.h
+++ b/karl/claire.h
@@ -111,7 +111,8 @@ class GenericClaire final : private DummyClaireNotifiable {
         karl_keepalive_route_(KarlKeepaliveRoute(karl_, codename_, port_)),
         notifiable_ref_(notifiable),
         us_start_(current::time::Now()),
-        http_scope_(HTTP(current::net::BarePort(port)).Register("/.current", [this](Request r) { ServeCurrent(std::move(r)); })),
+        http_scope_(HTTP(current::net::BarePort(port))
+                        .Register("/.current", [this](Request r) { ServeCurrent(std::move(r)); })),
         destructing_(false),
         keepalive_thread_force_wakeup_(false),
         keepalive_thread_running_(false) {}
@@ -412,15 +413,15 @@ class GenericClaire final : private DummyClaireNotifiable {
       // TODO(dkorolev): Parameter or named constant for keepalive frequency?
       const std::chrono::microseconds projected_next_keepalive =
           last_keepalive_attempt_result_.timestamp +
-          std::chrono::microseconds(current::random::CSRandomUInt64(static_cast<uint64_t>(20e6 * 0.9), static_cast<uint64_t>(20e6 * 1.1)));
+          std::chrono::microseconds(
+              current::random::CSRandomUInt64(static_cast<uint64_t>(20e6 * 0.9), static_cast<uint64_t>(20e6 * 1.1)));
 
       const std::chrono::microseconds now = current::time::Now();
 
       if (projected_next_keepalive > now) {
-        keepalive_condition_variable_.wait_for(
-            lock,
-            projected_next_keepalive - now,
-            [this]() { return destructing_.load() || keepalive_thread_force_wakeup_.load(); });
+        keepalive_condition_variable_.wait_for(lock, projected_next_keepalive - now, [this]() {
+          return destructing_.load() || keepalive_thread_force_wakeup_.load();
+        });
       }
 
       if (destructing_) {
@@ -553,7 +554,7 @@ class GenericClaire final : private DummyClaireNotifiable {
 
 using Claire = GenericClaire<Variant<default_user_status::status>>;
 
-}  // namespace current::karl
+}  // namespace karl
 }  // namespace current
 
 #endif  // KARL_CLAIRE_H
diff --git a/karl/constants.h b/karl/constants.h
index e6d2b8eaa..1aca83c90 100644
--- a/karl/constants.h
+++ b/karl/constants.h
@@ -34,8 +34,8 @@ namespace constants {
 constexpr static uint16_t kDefaultKarlPort = 7576;           // ASCII { 'K', 'L' }.
 constexpr static uint16_t kDefaultKarlFleetViewPort = 7577;  // ASCII { 'K', 'M' }.
 
-}  // namespace current::karl::constants
-}  // namespace current::karl
+}  // namespace constants
+}  // namespace karl
 }  // namespace current
 
 #endif  // KARL_CONSTANTS_H
diff --git a/karl/exceptions.h b/karl/exceptions.h
index ea0acfe2a..cdcb657d7 100644
--- a/karl/exceptions.h
+++ b/karl/exceptions.h
@@ -47,7 +47,7 @@ struct NginxParametersInvalidPortException : KarlException {
   using KarlException::KarlException;
 };
 
-}  // namespace current::karl
+}  // namespace karl
 }  // namespace current
 
 #endif  // CURRENT_KARL_EXCEPTIONS_H
diff --git a/karl/integrations/nodejs/karl_server.cc b/karl/integrations/nodejs/karl_server.cc
index 244e455ea..915798033 100644
--- a/karl/integrations/nodejs/karl_server.cc
+++ b/karl/integrations/nodejs/karl_server.cc
@@ -48,13 +48,10 @@ int main(int argc, char** argv) {
   ParseDFlags(&argc, &argv);
 
   current::WaitableAtomic<bool> shutdown(false);
-  const auto http_routes_scope = HTTP(FLAGS_karl_keepalives_port)
-                                     .Register("/shutdown",
-                                               [&shutdown](Request r) {
-                                                 shutdown.SetValue(true);
-                                                 r("OK\n");
-                                               }) +
-                                 HTTP(FLAGS_karl_keepalives_port).Register("/up", [](Request r) { r("OK\n"); });
+  const auto http_routes_scope = HTTP(FLAGS_karl_keepalives_port).Register("/shutdown", [&shutdown](Request r) {
+    shutdown.SetValue(true);
+    r("OK\n");
+  }) + HTTP(FLAGS_karl_keepalives_port).Register("/up", [](Request r) { r("OK\n"); });
 
   const auto stream_file_remover = current::FileSystem::ScopedRmFile(FLAGS_karl_stream_persistence_file);
   const auto storage_file_remover = current::FileSystem::ScopedRmFile(FLAGS_karl_storage_persistence_file);
diff --git a/karl/karl.h b/karl/karl.h
index db24225f6..c48e313df 100644
--- a/karl/karl.h
+++ b/karl/karl.h
@@ -115,18 +115,20 @@ class KarlNginxManager {
       if (first_run || current_stream_head != last_reflected_stream_head_) {
         nginx::config::ServerDirective server(nginx_parameters_.port);
         server.CreateProxyPassLocation("/", Printf("http://localhost:%d/", karl_fleet_view_port_));
-        storage_->ReadOnlyTransaction([this, &server](ImmutableFields<STORAGE> fields) -> void {
-          // Proxy status pages of the services via `{route_prefix}/{codename}`.
-          for (const auto& claire : fields.claires) {
-            if (claire.registered_state == ClaireRegisteredState::Active) {
-              auto& location = server.CreateProxyPassLocation(nginx_parameters_.route_prefix + '/' + claire.codename,
-                                                              claire.location.StatusPageURL());
-              // Block all HTTP methods except `GET`.
-              location.Add(nginx::config::BlockDirective(
-                  "limit_except", "GET", {nginx::config::SimpleDirective("deny", "all")}));
-            }
-          }
-        }).Go();
+        storage_
+            ->ReadOnlyTransaction([this, &server](ImmutableFields<STORAGE> fields) -> void {
+              // Proxy status pages of the services via `{route_prefix}/{codename}`.
+              for (const auto& claire : fields.claires) {
+                if (claire.registered_state == ClaireRegisteredState::Active) {
+                  auto& location = server.CreateProxyPassLocation(
+                      nginx_parameters_.route_prefix + '/' + claire.codename, claire.location.StatusPageURL());
+                  // Block all HTTP methods except `GET`.
+                  location.Add(nginx::config::BlockDirective(
+                      "limit_except", "GET", {nginx::config::SimpleDirective("deny", "all")}));
+                }
+              }
+            })
+            .Go();
         nginx_manager_->UpdateConfig(std::move(server));
         last_reflected_stream_head_ = current_stream_head;
         first_run = false;
@@ -252,10 +254,10 @@ class GenericKarl final : private KarlStorage<STORAGE_TYPE>,
   using karl_storage_t = KarlStorage<STORAGE_TYPE>;
   using karl_nginx_manager_t = KarlNginxManager<typename karl_storage_t::storage_t>;
   // We need these `using`s because of template base classes :(
-  using karl_storage_t::storage_;
-  using karl_nginx_manager_t::UpdateNginxIfNeeded;
   using karl_nginx_manager_t::has_nginx_config_file_;
   using karl_nginx_manager_t::nginx_parameters_;
+  using karl_nginx_manager_t::UpdateNginxIfNeeded;
+  using karl_storage_t::storage_;
 
   struct PrivateConstructorSelector {};
   template <typename T>
@@ -316,33 +318,37 @@ class GenericKarl final : private KarlStorage<STORAGE_TYPE>,
       std::exit(-1);
     }
     // Report this Karl as up and running.
-    storage_->ReadWriteTransaction([this](MutableFields<storage_t> fields) {
-      const auto& keepalives_data = keepalives_stream_->Data();
-      KarlInfo self_info;
-      if (!keepalives_data->Empty()) {
-        self_info.persisted_keepalives_info = keepalives_data->LastPublishedIndexAndTimestamp();
-      }
-      fields.karl.Add(self_info);
+    storage_
+        ->ReadWriteTransaction([this](MutableFields<storage_t> fields) {
+          const auto& keepalives_data = keepalives_stream_->Data();
+          KarlInfo self_info;
+          if (!keepalives_data->Empty()) {
+            self_info.persisted_keepalives_info = keepalives_data->LastPublishedIndexAndTimestamp();
+          }
+          fields.karl.Add(self_info);
 
-      const auto now = current::time::Now();
-      // Pre-populate services marked as `Active` due to abrupt shutdown into the cache.
-      // This will help to eventually mark non-active services as `DisconnectedByTimeout`.
-      for (const auto& claire : fields.claires) {
-        if (claire.registered_state == ClaireRegisteredState::Active) {
-          services_keepalive_time_cache_[claire.codename] = now;
-        }
-      }
-    }).Wait();
+          const auto now = current::time::Now();
+          // Pre-populate services marked as `Active` due to abrupt shutdown into the cache.
+          // This will help to eventually mark non-active services as `DisconnectedByTimeout`.
+          for (const auto& claire : fields.claires) {
+            if (claire.registered_state == ClaireRegisteredState::Active) {
+              services_keepalive_time_cache_[claire.codename] = now;
+            }
+          }
+        })
+        .Wait();
   }
 
  public:
   ~GenericKarl() {
     destructing_ = true;
-    storage_->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      KarlInfo self_info;
-      self_info.up = false;
-      fields.karl.Add(self_info);
-    }).Wait();
+    storage_
+        ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+          KarlInfo self_info;
+          self_info.up = false;
+          fields.karl.Add(self_info);
+        })
+        .Wait();
     if (state_update_thread_.joinable()) {
       {
         std::unique_lock<std::mutex> lock(services_keepalive_cache_mutex_);
@@ -388,24 +394,26 @@ class GenericKarl final : private KarlStorage<STORAGE_TYPE>,
       }
       if (!timeouted_codenames.empty()) {
         auto& notifiable_ref = notifiable_ref_;
-        storage_->ReadWriteTransaction([&timeouted_codenames, now, &notifiable_ref](MutableFields<storage_t> fields)
-                                           -> void {
-                                             for (const auto& codename : timeouted_codenames) {
-                                               const auto& current_claire_info = fields.claires[codename];
-                                               // OK to call from within a transaction.
-                                               // The call is fast, and `storage_`'s transaction guarantees thread
-                                               // safety. -- D.K.
-                                               ClaireInfo claire;
-                                               if (Exists(current_claire_info)) {
-                                                 claire = Value(current_claire_info);
-                                                 notifiable_ref.OnTimedOut(now, codename, current_claire_info);
-                                               } else {
-                                                 claire.codename = codename;
-                                               }
-                                               claire.registered_state = ClaireRegisteredState::DisconnectedByTimeout;
-                                               fields.claires.Add(claire);
-                                             }
-                                           }).Wait();
+        storage_
+            ->ReadWriteTransaction(
+                [&timeouted_codenames, now, &notifiable_ref](MutableFields<storage_t> fields) -> void {
+                  for (const auto& codename : timeouted_codenames) {
+                    const auto& current_claire_info = fields.claires[codename];
+                    // OK to call from within a transaction.
+                    // The call is fast, and `storage_`'s transaction guarantees thread
+                    // safety. -- D.K.
+                    ClaireInfo claire;
+                    if (Exists(current_claire_info)) {
+                      claire = Value(current_claire_info);
+                      notifiable_ref.OnTimedOut(now, codename, current_claire_info);
+                    } else {
+                      claire.codename = codename;
+                    }
+                    claire.registered_state = ClaireRegisteredState::DisconnectedByTimeout;
+                    fields.claires.Add(claire);
+                  }
+                })
+            .Wait();
       }
       UpdateNginxIfNeeded();
 #ifdef CURRENT_MOCK_TIME
@@ -416,10 +424,9 @@ class GenericKarl final : private KarlStorage<STORAGE_TYPE>,
         const auto wait_interval =
             parameters_.service_timeout_interval - (current::time::Now() - most_recent_keepalive_time);
         if (wait_interval.count() > 0) {
-          update_thread_condition_variable_.wait_for(
-              lock,
-              wait_interval + std::chrono::microseconds(1),
-              [this]() { return destructing_ || state_update_thread_force_wakeup_; });
+          update_thread_condition_variable_.wait_for(lock, wait_interval + std::chrono::microseconds(1), [this]() {
+            return destructing_ || state_update_thread_force_wakeup_;
+          });
         }
       } else {
         update_thread_condition_variable_.wait(lock,
@@ -454,21 +461,25 @@ class GenericKarl final : private KarlStorage<STORAGE_TYPE>,
         const std::string codename = qs["codename"];
         const auto now = current::time::Now();
         auto& notifiable_ref = notifiable_ref_;
-        storage_->ReadWriteTransaction([codename, now, &notifiable_ref](MutableFields<storage_t> fields) -> Response {
-          const auto& current_claire_info = fields.claires[codename];
-          // OK to call from within a transaction.
-          // The call is fast, and `storage_`'s transaction guarantees thread safety. -- D.K.
-          notifiable_ref.OnDeregistered(now, codename, current_claire_info);
-          ClaireInfo claire;
-          if (Exists(current_claire_info)) {
-            claire = Value(current_claire_info);
-          } else {
-            claire.codename = codename;
-          }
-          claire.registered_state = ClaireRegisteredState::Deregistered;
-          fields.claires.Add(claire);
-          return Response("OK\n");
-        }, std::move(r)).Wait();  // NOTE(dkorolev): Could be `.Detach()`, but staying "safe" within Karl for now.
+        storage_
+            ->ReadWriteTransaction(
+                [codename, now, &notifiable_ref](MutableFields<storage_t> fields) -> Response {
+                  const auto& current_claire_info = fields.claires[codename];
+                  // OK to call from within a transaction.
+                  // The call is fast, and `storage_`'s transaction guarantees thread safety. -- D.K.
+                  notifiable_ref.OnDeregistered(now, codename, current_claire_info);
+                  ClaireInfo claire;
+                  if (Exists(current_claire_info)) {
+                    claire = Value(current_claire_info);
+                  } else {
+                    claire.codename = codename;
+                  }
+                  claire.registered_state = ClaireRegisteredState::Deregistered;
+                  fields.claires.Add(claire);
+                  return Response("OK\n");
+                },
+                std::move(r))
+            .Wait();  // NOTE(dkorolev): Could be `.Detach()`, but staying "safe" within Karl for now.
         {
           // Delete this `codename` from cache.
           std::lock_guard<std::mutex> lock(services_keepalive_cache_mutex_);
@@ -490,7 +501,10 @@ class GenericKarl final : private KarlStorage<STORAGE_TYPE>,
           if (qs.has("confirm") && qs.has("port")) {
             const std::string url = "http://" + remote_ip + ':' + qs["port"] + "/.current";
             // Send a GET request, with a random component in the URL to prevent caching.
-            return HTTP(GET(url + "?all&rnd" + current::ToString(current::random::CSRandomUInt(static_cast<uint32_t>(1e9), static_cast<uint32_t>(2e9))))).body;
+            return HTTP(GET(url + "?all&rnd" +
+                            current::ToString(
+                                current::random::CSRandomUInt(static_cast<uint32_t>(1e9), static_cast<uint32_t>(2e9)))))
+                .body;
           } else {
             return r.body;
           }
@@ -551,97 +565,97 @@ class GenericKarl final : private KarlStorage<STORAGE_TYPE>,
           auto& notifiable_ref = notifiable_ref_;
           storage_
               ->ReadWriteTransaction(
-                    [now, location, &parsed_status, &detailed_parsed_status, optional_behind_this_by, &notifiable_ref](
-                        MutableFields<storage_t> fields) -> Response {
-                      // OK to call from within a transaction.
-                      // The call is fast, and `storage_`'s transaction guarantees thread safety. -- D.K.
-                      notifiable_ref.OnKeepalive(now, location, parsed_status.codename, detailed_parsed_status);
-
-                      const auto& service = parsed_status.service;
-                      const auto& codename = parsed_status.codename;
-                      const auto& optional_build = parsed_status.build;
-                      const auto& optional_instance = parsed_status.cloud_instance_name;
-                      const auto& optional_av_group = parsed_status.cloud_availability_group;
-
-                      // Update per-server information in the `DB`.
-                      ServerInfo server;
-                      server.ip = location.ip;
-                      bool need_to_update_server_info = false;
-                      const ImmutableOptional<ServerInfo> current_server_info = fields.servers[location.ip];
-                      if (Exists(current_server_info)) {
-                        server = Value(current_server_info);
-                      }
-                      // Check the instance name.
-                      if (Exists(optional_instance)) {
-                        if (!Exists(server.cloud_instance_name) ||
-                            Value(server.cloud_instance_name) != Value(optional_instance)) {
-                          server.cloud_instance_name = Value(optional_instance);
-                          need_to_update_server_info = true;
-                        }
-                      }
-                      // Check the availability group.
-                      if (Exists(optional_av_group)) {
-                        if (!Exists(server.cloud_availability_group) ||
-                            Value(server.cloud_availability_group) != Value(optional_av_group)) {
-                          server.cloud_availability_group = Value(optional_av_group);
-                          need_to_update_server_info = true;
-                        }
+                  [now, location, &parsed_status, &detailed_parsed_status, optional_behind_this_by, &notifiable_ref](
+                      MutableFields<storage_t> fields) -> Response {
+                    // OK to call from within a transaction.
+                    // The call is fast, and `storage_`'s transaction guarantees thread safety. -- D.K.
+                    notifiable_ref.OnKeepalive(now, location, parsed_status.codename, detailed_parsed_status);
+
+                    const auto& service = parsed_status.service;
+                    const auto& codename = parsed_status.codename;
+                    const auto& optional_build = parsed_status.build;
+                    const auto& optional_instance = parsed_status.cloud_instance_name;
+                    const auto& optional_av_group = parsed_status.cloud_availability_group;
+
+                    // Update per-server information in the `DB`.
+                    ServerInfo server;
+                    server.ip = location.ip;
+                    bool need_to_update_server_info = false;
+                    const ImmutableOptional<ServerInfo> current_server_info = fields.servers[location.ip];
+                    if (Exists(current_server_info)) {
+                      server = Value(current_server_info);
+                    }
+                    // Check the instance name.
+                    if (Exists(optional_instance)) {
+                      if (!Exists(server.cloud_instance_name) ||
+                          Value(server.cloud_instance_name) != Value(optional_instance)) {
+                        server.cloud_instance_name = Value(optional_instance);
+                        need_to_update_server_info = true;
                       }
-                      // Check the time skew.
-                      if (Exists(optional_behind_this_by)) {
-                        const std::chrono::microseconds behind_this_by = Value(optional_behind_this_by);
-                        const auto time_skew_difference = server.behind_this_by - behind_this_by;
-                        if (static_cast<uint64_t>(std::abs(time_skew_difference.count())) >=
-                            kUpdateServerInfoThresholdByTimeSkewDifference) {
-                          server.behind_this_by = behind_this_by;
-                          need_to_update_server_info = true;
-                        }
+                    }
+                    // Check the availability group.
+                    if (Exists(optional_av_group)) {
+                      if (!Exists(server.cloud_availability_group) ||
+                          Value(server.cloud_availability_group) != Value(optional_av_group)) {
+                        server.cloud_availability_group = Value(optional_av_group);
+                        need_to_update_server_info = true;
                       }
-                      if (need_to_update_server_info) {
-                        fields.servers.Add(server);
+                    }
+                    // Check the time skew.
+                    if (Exists(optional_behind_this_by)) {
+                      const std::chrono::microseconds behind_this_by = Value(optional_behind_this_by);
+                      const auto time_skew_difference = server.behind_this_by - behind_this_by;
+                      if (static_cast<uint64_t>(std::abs(time_skew_difference.count())) >=
+                          kUpdateServerInfoThresholdByTimeSkewDifference) {
+                        server.behind_this_by = behind_this_by;
+                        need_to_update_server_info = true;
                       }
+                    }
+                    if (need_to_update_server_info) {
+                      fields.servers.Add(server);
+                    }
 
-                      // Update the `DB` if the build information was not stored there yet.
-                      const ImmutableOptional<ClaireBuildInfo> current_claire_build_info = fields.builds[codename];
-                      if (Exists(optional_build) && (!Exists(current_claire_build_info) ||
-                                                     Value(current_claire_build_info).build != Value(optional_build))) {
-                        ClaireBuildInfo build;
-                        build.codename = codename;
-                        build.build = Value(optional_build);
-                        fields.builds.Add(build);
-                      }
+                    // Update the `DB` if the build information was not stored there yet.
+                    const ImmutableOptional<ClaireBuildInfo> current_claire_build_info = fields.builds[codename];
+                    if (Exists(optional_build) && (!Exists(current_claire_build_info) ||
+                                                   Value(current_claire_build_info).build != Value(optional_build))) {
+                      ClaireBuildInfo build;
+                      build.codename = codename;
+                      build.build = Value(optional_build);
+                      fields.builds.Add(build);
+                    }
 
-                      // Update the `DB` if "codename", "location", or "dependencies" differ.
-                      const ImmutableOptional<ClaireInfo> current_claire_info = fields.claires[codename];
-                      if ([&]() {
-                            if (!Exists(current_claire_info)) {
-                              return true;
-                            } else if (Value(current_claire_info).location != location) {
-                              return true;
-                            } else if (Value(current_claire_info).registered_state != ClaireRegisteredState::Active) {
-                              return true;
-                            } else {
-                              return false;
-                            }
-                          }()) {
-                        ClaireInfo claire;
-                        if (Exists(current_claire_info)) {
-                          // Do not overwrite `build` with `null`.
-                          claire = Value(current_claire_info);
-                        }
-
-                        claire.codename = codename;
-                        claire.service = service;
-                        claire.location = location;
-                        claire.reported_timestamp = now;
-                        claire.url_status_page_direct = location.StatusPageURL();
-                        claire.registered_state = ClaireRegisteredState::Active;
-
-                        fields.claires.Add(claire);
+                    // Update the `DB` if "codename", "location", or "dependencies" differ.
+                    const ImmutableOptional<ClaireInfo> current_claire_info = fields.claires[codename];
+                    if ([&]() {
+                          if (!Exists(current_claire_info)) {
+                            return true;
+                          } else if (Value(current_claire_info).location != location) {
+                            return true;
+                          } else if (Value(current_claire_info).registered_state != ClaireRegisteredState::Active) {
+                            return true;
+                          } else {
+                            return false;
+                          }
+                        }()) {
+                      ClaireInfo claire;
+                      if (Exists(current_claire_info)) {
+                        // Do not overwrite `build` with `null`.
+                        claire = Value(current_claire_info);
                       }
-                      return Response("OK\n");
-                    },
-                    std::move(r))
+
+                      claire.codename = codename;
+                      claire.service = service;
+                      claire.location = location;
+                      claire.reported_timestamp = now;
+                      claire.url_status_page_direct = location.StatusPageURL();
+                      claire.registered_state = ClaireRegisteredState::Active;
+
+                      fields.claires.Add(claire);
+                    }
+                    return Response("OK\n");
+                  },
+                  std::move(r))
               .Wait();
           {
             std::lock_guard<std::mutex> lock(services_keepalive_cache_mutex_);
@@ -701,15 +715,19 @@ class GenericKarl final : private KarlStorage<STORAGE_TYPE>,
 
   void ServeBuild(Request r) {
     const auto codename = r.url_path_args[0];
-    storage_->ReadOnlyTransaction([codename](ImmutableFields<storage_t> fields) -> Response {
-      const auto result = fields.builds[codename];
-      if (Exists(result)) {
-        return Value(result);
-      } else {
-        return Response(current_service_state::Error("Codename '" + codename + "' not found."),
-                        HTTPResponseCode.NotFound);
-      }
-    }, std::move(r)).Wait();  // NOTE(dkorolev): Could be `.Detach()`, but staying "safe" within Karl for now.
+    storage_
+        ->ReadOnlyTransaction(
+            [codename](ImmutableFields<storage_t> fields) -> Response {
+              const auto result = fields.builds[codename];
+              if (Exists(result)) {
+                return Value(result);
+              } else {
+                return Response(current_service_state::Error("Codename '" + codename + "' not found."),
+                                HTTPResponseCode.NotFound);
+              }
+            },
+            std::move(r))
+        .Wait();  // NOTE(dkorolev): Could be `.Detach()`, but staying "safe" within Karl for now.
   }
 
   void ServeSnapshot(Request r) {
@@ -863,106 +881,106 @@ class GenericKarl final : private KarlStorage<STORAGE_TYPE>,
     }();
 
     const std::string public_url = actual_public_url_;
-    storage_->ReadOnlyTransaction(
-                  [this,
-                   now,
-                   from,
-                   to,
-                   active_only,
-                   response_format,
-                   public_url,
-                   codenames_to_resolve,
-                   report_for_codename,
-                   codenames_per_service,
-                   service_key_into_codename](ImmutableFields<storage_t> fields) -> Response {
-                    std::unordered_map<std::string, ClaireServiceKey> resolved_codenames;
-                    karl_status_t result;
-                    result.now = now;
-                    result.from = from;
-                    result.to = to;
-                    for (const auto& codename : codenames_to_resolve) {
-                      resolved_codenames[codename] = [&]() -> ClaireServiceKey {
-                        const ImmutableOptional<ClaireInfo> resolved = fields.claires[codename];
-                        if (Exists(resolved)) {
-                          return Value(resolved).location;
-                        } else {
-                          ClaireServiceKey key;
-                          key.ip = "zombie/" + codename;
-                          key.port = 0;
-                          return key;
-                        }
-                      }();
+    storage_
+        ->ReadOnlyTransaction(
+            [this,
+             now,
+             from,
+             to,
+             active_only,
+             response_format,
+             public_url,
+             codenames_to_resolve,
+             report_for_codename,
+             codenames_per_service,
+             service_key_into_codename](ImmutableFields<storage_t> fields) -> Response {
+              std::unordered_map<std::string, ClaireServiceKey> resolved_codenames;
+              karl_status_t result;
+              result.now = now;
+              result.from = from;
+              result.to = to;
+              for (const auto& codename : codenames_to_resolve) {
+                resolved_codenames[codename] = [&]() -> ClaireServiceKey {
+                  const ImmutableOptional<ClaireInfo> resolved = fields.claires[codename];
+                  if (Exists(resolved)) {
+                    return Value(resolved).location;
+                  } else {
+                    ClaireServiceKey key;
+                    key.ip = "zombie/" + codename;
+                    key.port = 0;
+                    return key;
+                  }
+                }();
+              }
+              for (const auto& iterating_over_services : codenames_per_service) {
+                const std::string& service = iterating_over_services.first;
+                for (const auto& codename : iterating_over_services.second) {
+                  ServiceToReport<runtime_status_variant_t> blob;
+                  const auto& rhs = report_for_codename.at(codename);
+                  if (active_only) {
+                    const auto& persisted_claire = fields.claires[codename];
+                    if (Exists(persisted_claire) &&
+                        Value(persisted_claire).registered_state != ClaireRegisteredState::Active) {
+                      continue;
                     }
-                    for (const auto& iterating_over_services : codenames_per_service) {
-                      const std::string& service = iterating_over_services.first;
-                      for (const auto& codename : iterating_over_services.second) {
-                        ServiceToReport<runtime_status_variant_t> blob;
-                        const auto& rhs = report_for_codename.at(codename);
-                        if (active_only) {
-                          const auto& persisted_claire = fields.claires[codename];
-                          if (Exists(persisted_claire) &&
-                              Value(persisted_claire).registered_state != ClaireRegisteredState::Active) {
-                            continue;
-                          }
-                        }
-                        blob.currently = rhs.currently;
-                        blob.service = service;
-                        blob.codename = codename;
-                        blob.location = resolved_codenames[codename];
-                        for (const auto& dep : rhs.dependencies) {
-                          const auto cit = service_key_into_codename.find(dep);
-                          if (cit != service_key_into_codename.end()) {
-                            blob.dependencies.push_back(cit->second);
-                          } else {
-                            blob.unresolved_dependencies.push_back(dep.StatusPageURL());
-                          }
-                        }
-
-                        {
-                          const auto optional_build = fields.builds[codename];
-                          if (Exists(optional_build)) {
-                            const auto& info = Value(optional_build).build;
-                            blob.build_time = info.build_time;
-                            blob.build_time_epoch_microseconds = info.build_time_epoch_microseconds;
-                            blob.git_commit = info.git_commit_hash;
-                            blob.git_branch = info.git_branch;
-                            blob.git_dirty = Exists(info.git_dirty_files) && !Value(info.git_dirty_files).empty();
-                          }
-                        }
-
-                        if (has_nginx_config_file_) {
-                          blob.url_status_page_proxied =
-                              actual_public_url_ + nginx_parameters_.route_prefix + '/' + codename;
-                        }
-                        blob.url_status_page_direct = blob.location.StatusPageURL();
-                        blob.location = resolved_codenames[codename];
-                        blob.runtime = rhs.runtime;
-                        result.machines[blob.location.ip].services[codename] = std::move(blob);
-                      }
+                  }
+                  blob.currently = rhs.currently;
+                  blob.service = service;
+                  blob.codename = codename;
+                  blob.location = resolved_codenames[codename];
+                  for (const auto& dep : rhs.dependencies) {
+                    const auto cit = service_key_into_codename.find(dep);
+                    if (cit != service_key_into_codename.end()) {
+                      blob.dependencies.push_back(cit->second);
+                    } else {
+                      blob.unresolved_dependencies.push_back(dep.StatusPageURL());
                     }
-                    // Update per-server information.
-                    for (auto& iterating_over_reported_servers : result.machines) {
-                      const std::string& ip = iterating_over_reported_servers.first;
-                      auto& server = iterating_over_reported_servers.second;
-                      const auto& optional_persisted_server_info = fields.servers[ip];
-                      if (Exists(optional_persisted_server_info)) {
-                        const auto& persisted_server_info = Value(optional_persisted_server_info);
-                        server.cloud_instance_name = persisted_server_info.cloud_instance_name;
-                        server.cloud_availability_group = persisted_server_info.cloud_availability_group;
-                        const int64_t behind_this_by_us = persisted_server_info.behind_this_by.count();
-                        if (std::abs(behind_this_by_us) < 100000) {
-                          server.time_skew = "NTP OK";
-                        } else if (behind_this_by_us > 0) {
-                          server.time_skew = current::strings::Printf("behind by %.1lfs", 1e-6 * behind_this_by_us);
-                        } else {
-                          server.time_skew = current::strings::Printf("ahead by %.1lfs", 1e-6 * behind_this_by_us);
-                        }
-                      }
+                  }
+
+                  {
+                    const auto optional_build = fields.builds[codename];
+                    if (Exists(optional_build)) {
+                      const auto& info = Value(optional_build).build;
+                      blob.build_time = info.build_time;
+                      blob.build_time_epoch_microseconds = info.build_time_epoch_microseconds;
+                      blob.git_commit = info.git_commit_hash;
+                      blob.git_branch = info.git_branch;
+                      blob.git_dirty = Exists(info.git_dirty_files) && !Value(info.git_dirty_files).empty();
                     }
-                    result.generation_time = current::time::Now() - now;
-                    return fleet_view_renderer_ref_.RenderResponse(response_format, parameters_, std::move(result));
-                  },
-                  std::move(r))
+                  }
+
+                  if (has_nginx_config_file_) {
+                    blob.url_status_page_proxied = actual_public_url_ + nginx_parameters_.route_prefix + '/' + codename;
+                  }
+                  blob.url_status_page_direct = blob.location.StatusPageURL();
+                  blob.location = resolved_codenames[codename];
+                  blob.runtime = rhs.runtime;
+                  result.machines[blob.location.ip].services[codename] = std::move(blob);
+                }
+              }
+              // Update per-server information.
+              for (auto& iterating_over_reported_servers : result.machines) {
+                const std::string& ip = iterating_over_reported_servers.first;
+                auto& server = iterating_over_reported_servers.second;
+                const auto& optional_persisted_server_info = fields.servers[ip];
+                if (Exists(optional_persisted_server_info)) {
+                  const auto& persisted_server_info = Value(optional_persisted_server_info);
+                  server.cloud_instance_name = persisted_server_info.cloud_instance_name;
+                  server.cloud_availability_group = persisted_server_info.cloud_availability_group;
+                  const int64_t behind_this_by_us = persisted_server_info.behind_this_by.count();
+                  if (std::abs(behind_this_by_us) < 100000) {
+                    server.time_skew = "NTP OK";
+                  } else if (behind_this_by_us > 0) {
+                    server.time_skew = current::strings::Printf("behind by %.1lfs", 1e-6 * behind_this_by_us);
+                  } else {
+                    server.time_skew = current::strings::Printf("ahead by %.1lfs", 1e-6 * behind_this_by_us);
+                  }
+                }
+              }
+              result.generation_time = current::time::Now() - now;
+              return fleet_view_renderer_ref_.RenderResponse(response_format, parameters_, std::move(result));
+            },
+            std::move(r))
         .Wait();  // NOTE(dkorolev): Could be `.Detach()`, but staying "safe" within Karl for now.
   }
 
@@ -991,7 +1009,7 @@ class GenericKarl final : private KarlStorage<STORAGE_TYPE>,
 
 using Karl = GenericKarl<UseOwnStorage, default_user_status::status>;
 
-}  // namespace current::karl
+}  // namespace karl
 }  // namespace current
 
 #endif  // KARL_KARL_H
diff --git a/karl/locator.h b/karl/locator.h
index e5ddf1ea6..122c96cd9 100644
--- a/karl/locator.h
+++ b/karl/locator.h
@@ -46,7 +46,7 @@ inline Locator LocalKarl() {
   return Locator("http://localhost:" + current::ToString(constants::kDefaultKarlPort) + '/');
 };
 
-}  // namespace current::karl
+}  // namespace karl
 }  // namespace current
 
 #endif  // KARL_LOCATOR_H
diff --git a/karl/render.h b/karl/render.h
index 55df08be1..2f232e01c 100644
--- a/karl/render.h
+++ b/karl/render.h
@@ -289,7 +289,7 @@ class DefaultFleetViewRenderer : public IKarlFleetViewRenderer<INNER_STATUSES_VA
   }
 };
 
-}  // namespace current::karl
+}  // namespace karl
 }  // namespace current
 
 #endif  // KARL_RENDER_H
diff --git a/karl/respond_with_schema.h b/karl/respond_with_schema.h
index d6f04bf6f..f90f15f18 100644
--- a/karl/respond_with_schema.h
+++ b/karl/respond_with_schema.h
@@ -42,7 +42,7 @@ void RespondWithSchema(Request r) {
   r(schema.GetSchemaInfo().Describe<L>());
 }
 
-}  // namespace current::karl
+}  // namespace karl
 }  // namespace current
 
 #endif  // KARL_RESPOND_WITH_SCHEMA_H
diff --git a/karl/schema_claire.h b/karl/schema_claire.h
index dd61179db..9d17ea392 100644
--- a/karl/schema_claire.h
+++ b/karl/schema_claire.h
@@ -159,7 +159,7 @@ CURRENT_STRUCT(status) {
   // clang-format on
   // LCOV_EXCL_STOP
 };
-}  // namespace current::karl::default_user_status
+}  // namespace default_user_status
 
 // For now, Karl parses the passed in JSON twice: once as `ClaireStatus` for generic response,
 // and once as `ClaireServiceStatus<T>`, where `T` is a `Variant` containing the client-, service-side blob.
@@ -173,7 +173,7 @@ CURRENT_STRUCT_T_DERIVED(ClaireServiceStatus, ClaireStatus) {
 
 // clang-format on
 
-}  // namespace current::karl
+}  // namespace karl
 }  // namespace current
 
 #endif  // KARL_SCHEMA_CLAIRE_H
diff --git a/karl/schema_karl.h b/karl/schema_karl.h
index aa282d2de..77c0d19f3 100644
--- a/karl/schema_karl.h
+++ b/karl/schema_karl.h
@@ -44,8 +44,8 @@ CURRENT_STRUCT(KarlNginxParameters) {
   CURRENT_FIELD(route_prefix, std::string);
   CURRENT_FIELD_DESCRIPTION(route_prefix, "Non-standard top-level route, if set.");
 
-  CURRENT_CONSTRUCTOR(KarlNginxParameters)(
-      uint16_t port, const std::string& config_file, const std::string& route_prefix = "/live")
+  CURRENT_CONSTRUCTOR(KarlNginxParameters)
+  (uint16_t port, const std::string& config_file, const std::string& route_prefix = "/live")
       : port(port), config_file(config_file), route_prefix(route_prefix) {}
 };
 
@@ -226,10 +226,11 @@ CURRENT_STRUCT(up) {
   CURRENT_FIELD_DESCRIPTION(uptime, "The uptime of the service based on the most recent keepalive, human-readable.");
 
   CURRENT_DEFAULT_CONSTRUCTOR(up) {}
-  CURRENT_CONSTRUCTOR(up)(const std::chrono::microseconds start_time_epoch_microseconds,
-                          const std::string& last_keepalive_received,
-                          const std::chrono::microseconds last_keepalive_received_epoch_microseconds,
-                          const std::string& uptime)
+  CURRENT_CONSTRUCTOR(up)
+  (const std::chrono::microseconds start_time_epoch_microseconds,
+   const std::string& last_keepalive_received,
+   const std::chrono::microseconds last_keepalive_received_epoch_microseconds,
+   const std::string& uptime)
       : start_time_epoch_microseconds(start_time_epoch_microseconds),
         last_keepalive_received(last_keepalive_received),
         last_keepalive_received_epoch_microseconds(last_keepalive_received_epoch_microseconds),
@@ -254,10 +255,11 @@ CURRENT_STRUCT(down) {
                             "The uptime of the service as of right before it went offline, human-readable.");
 
   CURRENT_DEFAULT_CONSTRUCTOR(down) {}
-  CURRENT_CONSTRUCTOR(down)(const std::chrono::microseconds start_time_epoch_microseconds,
-                            const std::string& last_keepalive_received,
-                            const std::chrono::microseconds last_keepalive_received_epoch_microseconds,
-                            const std::string& last_confirmed_uptime)
+  CURRENT_CONSTRUCTOR(down)
+  (const std::chrono::microseconds start_time_epoch_microseconds,
+   const std::string& last_keepalive_received,
+   const std::chrono::microseconds last_keepalive_received_epoch_microseconds,
+   const std::string& last_confirmed_uptime)
       : start_time_epoch_microseconds(start_time_epoch_microseconds),
         last_keepalive_received(last_keepalive_received),
         last_keepalive_received_epoch_microseconds(last_keepalive_received_epoch_microseconds),
@@ -267,7 +269,7 @@ CURRENT_STRUCT(down) {
 // TODO(dkorolev): `Variant<up, down, done>`, where `done` == "has been shut down gracefully".
 using state_variant_t = Variant<up, down>;
 
-}  // namespace current::karl::current_service_state
+}  // namespace current_service_state
 
 CURRENT_STRUCT_T(ServiceToReport) {
   CURRENT_FIELD(currently, current_service_state::state_variant_t);
@@ -369,12 +371,12 @@ CURRENT_STRUCT_T(SnapshotOfKeepalive) {
   CURRENT_FIELD(snapshot, ClaireServiceStatus<T>);
   CURRENT_FIELD_DESCRIPTION(snapshot, "The snapshot itself.");
 
-  CURRENT_CONSTRUCTOR_T(SnapshotOfKeepalive)(std::chrono::microseconds dt,
-                                             const ClaireServiceStatus<T>& data = ClaireServiceStatus<T>())
+  CURRENT_CONSTRUCTOR_T(SnapshotOfKeepalive)
+  (std::chrono::microseconds dt, const ClaireServiceStatus<T>& data = ClaireServiceStatus<T>())
       : age(strings::TimeDifferenceAsHumanReadableString(dt)), snapshot(data) {}
 };
 
-}  // namespace current::karl
+}  // namespace karl
 }  // namespace current
 
 #endif  // KARL_SCHEMA_KARL_H
diff --git a/karl/test.cc b/karl/test.cc
index f826bad97..d8e8725e9 100644
--- a/karl/test.cc
+++ b/karl/test.cc
@@ -53,8 +53,12 @@ inline uint16_t MimicPickPortForUnitTest() {
   return port;
 }
 
-DEFINE_uint16(karl_test_keepalives_port, MimicPickPortForUnitTest(), "Local test port for the `Karl` keepalive listener.");
-DEFINE_uint16(karl_test_fleet_view_port, MimicPickPortForUnitTest(), "Local test port for the `Karl` fleet view listener.");
+DEFINE_uint16(karl_test_keepalives_port,
+              MimicPickPortForUnitTest(),
+              "Local test port for the `Karl` keepalive listener.");
+DEFINE_uint16(karl_test_fleet_view_port,
+              MimicPickPortForUnitTest(),
+              "Local test port for the `Karl` fleet view listener.");
 DEFINE_uint16(karl_generator_test_port, MimicPickPortForUnitTest(), "Local test port for the `generator` service.");
 DEFINE_uint16(karl_is_prime_test_port, MimicPickPortForUnitTest(), "Local test port for the `is_prime` service.");
 DEFINE_uint16(karl_annotator_test_port, MimicPickPortForUnitTest(), "Local test port for the `annotator` service.");
@@ -82,9 +86,8 @@ DEFINE_bool(karl_run_test_forever, false, "Set to `true` to run the Karl test fo
 
 DEFINE_bool(karl_overwrite_golden_files, false, "Set to true to have SVG golden files created/overwritten.");
 
-using unittest_karl_t = current::karl::GenericKarl<current::karl::UseOwnStorage,
-                                                   current::karl::default_user_status::status,
-                                                   karl_unittest::is_prime>;
+using unittest_karl_t = current::karl::
+    GenericKarl<current::karl::UseOwnStorage, current::karl::default_user_status::status, karl_unittest::is_prime>;
 using unittest_karl_status_t = typename unittest_karl_t::karl_status_t;
 
 static current::karl::KarlParameters UnittestKarlParameters() {
@@ -193,20 +196,22 @@ TEST(Karl, SmokeAnnotator) {
                                                   Printf("http://localhost:%d", FLAGS_karl_generator_test_port),
                                                   Printf("http://localhost:%d", FLAGS_karl_is_prime_test_port),
                                                   karl_locator);
-  ASSERT_NO_THROW(const auto x37 = ParseJSON<karl_unittest::Number>(
-                      current::strings::Split(HTTP(GET(Printf("http://localhost:%d/annotated?i=37&n=1",
-                                                              FLAGS_karl_annotator_test_port))).body,
-                                              '\t').back());
-                  EXPECT_EQ(37, x37.x);
-                  ASSERT_TRUE(Exists(x37.is_prime));
-                  EXPECT_TRUE(Value(x37.is_prime)););
-  ASSERT_NO_THROW(const auto x39 = ParseJSON<karl_unittest::Number>(
-                      current::strings::Split(HTTP(GET(Printf("http://localhost:%d/annotated?i=39&n=1",
-                                                              FLAGS_karl_annotator_test_port))).body,
-                                              '\t').back());
-                  EXPECT_EQ(39, x39.x);
-                  ASSERT_TRUE(Exists(x39.is_prime));
-                  EXPECT_FALSE(Value(x39.is_prime)););
+  ASSERT_NO_THROW(
+      const auto x37 = ParseJSON<karl_unittest::Number>(
+          current::strings::Split(
+              HTTP(GET(Printf("http://localhost:%d/annotated?i=37&n=1", FLAGS_karl_annotator_test_port))).body, '\t')
+              .back());
+      EXPECT_EQ(37, x37.x);
+      ASSERT_TRUE(Exists(x37.is_prime));
+      EXPECT_TRUE(Value(x37.is_prime)););
+  ASSERT_NO_THROW(
+      const auto x39 = ParseJSON<karl_unittest::Number>(
+          current::strings::Split(
+              HTTP(GET(Printf("http://localhost:%d/annotated?i=39&n=1", FLAGS_karl_annotator_test_port))).body, '\t')
+              .back());
+      EXPECT_EQ(39, x39.x);
+      ASSERT_TRUE(Exists(x39.is_prime));
+      EXPECT_FALSE(Value(x39.is_prime)););
 
   {
     current::karl::ClaireStatus status;
@@ -253,7 +258,8 @@ TEST(Karl, SmokeFilter) {
       // 10-th (index=9 for 0-based) prime is `29`.
       const auto x29 = ParseJSON<karl_unittest::Number>(
           current::strings::Split(
-              HTTP(GET(Printf("http://localhost:%d/primes?i=9&n=1", FLAGS_karl_filter_test_port))).body, '\t').back());
+              HTTP(GET(Printf("http://localhost:%d/primes?i=9&n=1", FLAGS_karl_filter_test_port))).body, '\t')
+              .back());
       EXPECT_EQ(29, x29.x);
       ASSERT_TRUE(Exists(x29.is_prime));
       EXPECT_TRUE(Value(x29.is_prime)));
@@ -261,7 +267,8 @@ TEST(Karl, SmokeFilter) {
       // 20-th (index=19 for 0-based) prime is `71`.
       const auto x71 = ParseJSON<karl_unittest::Number>(
           current::strings::Split(
-              HTTP(GET(Printf("http://localhost:%d/primes?i=19&n=1", FLAGS_karl_filter_test_port))).body, '\t').back());
+              HTTP(GET(Printf("http://localhost:%d/primes?i=19&n=1", FLAGS_karl_filter_test_port))).body, '\t')
+              .back());
       EXPECT_EQ(71, x71.x);
       ASSERT_TRUE(Exists(x71.is_prime));
       EXPECT_TRUE(Value(x71.is_prime)););
@@ -329,8 +336,9 @@ TEST(Karl, Deregister) {
       {
         unittest_karl_status_t status;
         ASSERT_NO_THROW(
-            status = ParseJSON<unittest_karl_status_t>(HTTP(GET(Printf("http://localhost:%d?from=0&full&active_only",
-                                                                       FLAGS_karl_test_fleet_view_port))).body));
+            status = ParseJSON<unittest_karl_status_t>(
+                HTTP(GET(Printf("http://localhost:%d?from=0&full&active_only", FLAGS_karl_test_fleet_view_port)))
+                    .body));
         EXPECT_EQ(1u, status.machines.size()) << JSON(status);
         ASSERT_TRUE(status.machines.count("127.0.0.1")) << JSON(status);
         auto& per_ip_services = status.machines["127.0.0.1"].services;
@@ -436,8 +444,9 @@ TEST(Karl, DeregisterWithNginx) {
       {
         unittest_karl_status_t status;
         ASSERT_NO_THROW(
-            status = ParseJSON<unittest_karl_status_t>(HTTP(GET(Printf("http://localhost:%d?from=0&full&active_only",
-                                                                       FLAGS_karl_test_fleet_view_port))).body));
+            status = ParseJSON<unittest_karl_status_t>(
+                HTTP(GET(Printf("http://localhost:%d?from=0&full&active_only", FLAGS_karl_test_fleet_view_port)))
+                    .body));
         EXPECT_EQ(1u, status.machines.size()) << JSON(status);
         ASSERT_TRUE(status.machines.count("127.0.0.1")) << JSON(status);
         auto& per_ip_services = status.machines["127.0.0.1"].services;
@@ -529,24 +538,27 @@ TEST(Karl, DisconnectedByTimout) {
     while (karl.ActiveServicesCount() == 0u) {
       std::this_thread::yield();
     }
-    const auto result =
-        karl.BorrowStorage()->ReadOnlyTransaction([&](ImmutableFields<unittest_karl_t::storage_t> fields) {
-          ASSERT_TRUE(Exists(fields.claires[claire.codename]));
-          EXPECT_EQ(current::karl::ClaireRegisteredState::Active,
-                    Value(fields.claires[claire.codename]).registered_state);
-        }).Go();
+    const auto result = karl.BorrowStorage()
+                            ->ReadOnlyTransaction([&](ImmutableFields<unittest_karl_t::storage_t> fields) {
+                              ASSERT_TRUE(Exists(fields.claires[claire.codename]));
+                              EXPECT_EQ(current::karl::ClaireRegisteredState::Active,
+                                        Value(fields.claires[claire.codename]).registered_state);
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
   }
 
   current::time::SetNow(std::chrono::microseconds(100 * 1000 * 1000), std::chrono::microseconds(101 * 1000 * 1000));
   bool is_timeouted_persisted = false;
   while (!is_timeouted_persisted) {
-    is_timeouted_persisted = Value(
-        karl.BorrowStorage()->ReadOnlyTransaction([&](ImmutableFields<unittest_karl_t::storage_t> fields) -> bool {
-          EXPECT_TRUE(Exists(fields.claires[claire.codename]));
-          return Value(fields.claires[claire.codename]).registered_state ==
-                 current::karl::ClaireRegisteredState::DisconnectedByTimeout;
-        }).Go());
+    is_timeouted_persisted =
+        Value(karl.BorrowStorage()
+                  ->ReadOnlyTransaction([&](ImmutableFields<unittest_karl_t::storage_t> fields) -> bool {
+                    EXPECT_TRUE(Exists(fields.claires[claire.codename]));
+                    return Value(fields.claires[claire.codename]).registered_state ==
+                           current::karl::ClaireRegisteredState::DisconnectedByTimeout;
+                  })
+                  .Go());
   }
 }
 
@@ -574,7 +586,8 @@ TEST(Karl, DisconnectedByTimoutWithNginx) {
   claire.codename = "ABCDEF";
   claire.local_port = MimicPickPortForUnitTest();
   // Register a fake service.
-  auto http_scope = HTTP(current::net::BarePort(claire.local_port)).Register("/.current", [](Request r) { r("GOTIT\n"); });
+  auto http_scope =
+      HTTP(current::net::BarePort(claire.local_port)).Register("/.current", [](Request r) { r("GOTIT\n"); });
 
   {
     const std::string keepalive_url = Printf(
@@ -584,12 +597,13 @@ TEST(Karl, DisconnectedByTimoutWithNginx) {
     while (karl.ActiveServicesCount() == 0u) {
       std::this_thread::yield();
     }
-    const auto result =
-        karl.BorrowStorage()->ReadOnlyTransaction([&](ImmutableFields<unittest_karl_t::storage_t> fields) {
-          ASSERT_TRUE(Exists(fields.claires[claire.codename]));
-          EXPECT_EQ(current::karl::ClaireRegisteredState::Active,
-                    Value(fields.claires[claire.codename]).registered_state);
-        }).Go();
+    const auto result = karl.BorrowStorage()
+                            ->ReadOnlyTransaction([&](ImmutableFields<unittest_karl_t::storage_t> fields) {
+                              ASSERT_TRUE(Exists(fields.claires[claire.codename]));
+                              EXPECT_EQ(current::karl::ClaireRegisteredState::Active,
+                                        Value(fields.claires[claire.codename]).registered_state);
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
   }
 
@@ -613,12 +627,14 @@ TEST(Karl, DisconnectedByTimoutWithNginx) {
   current::time::SetNow(std::chrono::microseconds(100 * 1000 * 1000), std::chrono::microseconds(101 * 1000 * 1000));
   bool is_timeouted_persisted = false;
   while (!is_timeouted_persisted) {
-    is_timeouted_persisted = Value(
-        karl.BorrowStorage()->ReadOnlyTransaction([&](ImmutableFields<unittest_karl_t::storage_t> fields) -> bool {
-          EXPECT_TRUE(Exists(fields.claires[claire.codename]));
-          return Value(fields.claires[claire.codename]).registered_state ==
-                 current::karl::ClaireRegisteredState::DisconnectedByTimeout;
-        }).Go());
+    is_timeouted_persisted =
+        Value(karl.BorrowStorage()
+                  ->ReadOnlyTransaction([&](ImmutableFields<unittest_karl_t::storage_t> fields) -> bool {
+                    EXPECT_TRUE(Exists(fields.claires[claire.codename]));
+                    return Value(fields.claires[claire.codename]).registered_state ==
+                           current::karl::ClaireRegisteredState::DisconnectedByTimeout;
+                  })
+                  .Go());
   }
 
   // This is a bit flaky.
@@ -673,8 +689,9 @@ TEST(Karl, ChangeKarlWhichClaireReportsTo) {
   {
     unittest_karl_status_t status;
     ASSERT_NO_THROW(
-        status = ParseJSON<unittest_karl_status_t>(HTTP(GET(Printf("http://localhost:%d?from=0&full&active_only",
-                                                                   secondary_karl_params.fleet_view_port))).body));
+        status = ParseJSON<unittest_karl_status_t>(
+            HTTP(GET(Printf("http://localhost:%d?from=0&full&active_only", secondary_karl_params.fleet_view_port)))
+                .body));
     EXPECT_TRUE(status.machines.empty()) << JSON(status);
   }
 
@@ -723,8 +740,9 @@ TEST(Karl, ChangeKarlWhichClaireReportsTo) {
   {
     unittest_karl_status_t status;
     ASSERT_NO_THROW(
-        status = ParseJSON<unittest_karl_status_t>(HTTP(GET(Printf("http://localhost:%d?from=0&full&active_only",
-                                                                   secondary_karl_params.fleet_view_port))).body));
+        status = ParseJSON<unittest_karl_status_t>(
+            HTTP(GET(Printf("http://localhost:%d?from=0&full&active_only", secondary_karl_params.fleet_view_port)))
+                .body));
     EXPECT_EQ(1u, status.machines.size()) << JSON(status);
     ASSERT_TRUE(status.machines.count("127.0.0.1")) << JSON(status);
     auto& per_ip_services = status.machines["127.0.0.1"].services;
@@ -1141,12 +1159,13 @@ TEST(Karl, KarlNotifiesUserObject) {
     EXPECT_EQ(current::strings::Join(expected, ", "), current::strings::Join(karl_notifications_receiver.events, ", "));
 
     current::time::SetNow(std::chrono::microseconds(100 * 1000 * 1000), std::chrono::microseconds(101 * 1000 * 1000));
-    while (Value(
-        karl.BorrowStorage()->ReadOnlyTransaction([&](ImmutableFields<unittest_karl_t::storage_t> fields) -> bool {
-          EXPECT_TRUE(Exists(fields.claires[claire.codename]));
-          return Value(fields.claires[claire.codename]).registered_state ==
-                 current::karl::ClaireRegisteredState::DisconnectedByTimeout;
-        }).Go())) {
+    while (Value(karl.BorrowStorage()
+                     ->ReadOnlyTransaction([&](ImmutableFields<unittest_karl_t::storage_t> fields) -> bool {
+                       EXPECT_TRUE(Exists(fields.claires[claire.codename]));
+                       return Value(fields.claires[claire.codename]).registered_state ==
+                              current::karl::ClaireRegisteredState::DisconnectedByTimeout;
+                     })
+                     .Go())) {
       std::this_thread::yield();
     }
 
@@ -1198,9 +1217,11 @@ TEST(Karl, CustomStorage) {
   auto storage = custom_storage_t::CreateMasterStorage(params.storage_persistence_file);
 
   {
-    const auto result = storage->ReadWriteTransaction([](MutableFields<custom_storage_t> fields) {
-      fields.custom_field.Add(CustomField(42, "UnitTest"));
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<custom_storage_t> fields) {
+                              fields.custom_field.Add(CustomField(42, "UnitTest"));
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
   }
 
@@ -1212,24 +1233,28 @@ TEST(Karl, CustomStorage) {
         FLAGS_karl_generator_test_port, std::chrono::microseconds(1000), karl_locator);
     generator_codename = generator.ClaireCodename();
 
-    const auto result = karl.BorrowStorage()->ReadOnlyTransaction([&](ImmutableFields<custom_storage_t> fields) {
-      ASSERT_TRUE(Exists(fields.claires[generator_codename]));
-      EXPECT_EQ(current::karl::ClaireRegisteredState::Active,
-                Value(fields.claires[generator_codename]).registered_state);
-    }).Go();
+    const auto result = karl.BorrowStorage()
+                            ->ReadOnlyTransaction([&](ImmutableFields<custom_storage_t> fields) {
+                              ASSERT_TRUE(Exists(fields.claires[generator_codename]));
+                              EXPECT_EQ(current::karl::ClaireRegisteredState::Active,
+                                        Value(fields.claires[generator_codename]).registered_state);
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
   }
 
   {
-    const auto result = storage->ReadOnlyTransaction([&](ImmutableFields<custom_storage_t> fields) {
-      // `generator` has deregistered itself on destruction.
-      ASSERT_TRUE(Exists(fields.claires[generator_codename]));
-      EXPECT_EQ(current::karl::ClaireRegisteredState::Deregistered,
-                Value(fields.claires[generator_codename]).registered_state);
-      // Our `custom_field` is fine.
-      ASSERT_TRUE(Exists(fields.custom_field[42]));
-      EXPECT_EQ("UnitTest", Value(fields.custom_field[42]).s);
-    }).Go();
+    const auto result = storage
+                            ->ReadOnlyTransaction([&](ImmutableFields<custom_storage_t> fields) {
+                              // `generator` has deregistered itself on destruction.
+                              ASSERT_TRUE(Exists(fields.claires[generator_codename]));
+                              EXPECT_EQ(current::karl::ClaireRegisteredState::Deregistered,
+                                        Value(fields.claires[generator_codename]).registered_state);
+                              // Our `custom_field` is fine.
+                              ASSERT_TRUE(Exists(fields.custom_field[42]));
+                              EXPECT_EQ("UnitTest", Value(fields.custom_field[42]).s);
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
   }
 }
diff --git a/karl/test_service/annotator.h b/karl/test_service/annotator.h
index 6b9966a78..6e2835c77 100644
--- a/karl/test_service/annotator.h
+++ b/karl/test_service/annotator.h
@@ -47,7 +47,7 @@ class ServiceAnnotator final {
         stream_(current::stream::Stream<Number>::CreateStream()),
         http_scope_(HTTP(current::net::BarePort(port)).Register("/annotated", *stream_)),
         destructing_(false),
-        http_stream_subscriber_(source_numbers_stream_, [this](idxts_t, Number && n) { OnNumber(std::move(n)); }),
+        http_stream_subscriber_(source_numbers_stream_, [this](idxts_t, Number&& n) { OnNumber(std::move(n)); }),
         claire_(karl, "annotator", port, {service_generator, service_is_prime}) {
 #ifdef CURRENT_MOCK_TIME
     // In unit test mode, wait for Karl's response and callback, and fail if Karl is not available.
diff --git a/karl/test_service/filter.h b/karl/test_service/filter.h
index ca0eb667b..04a5b526a 100644
--- a/karl/test_service/filter.h
+++ b/karl/test_service/filter.h
@@ -47,7 +47,7 @@ class ServiceFilter final {
         http_scope_(HTTP(current::net::BarePort(port)).Register("/primes", *stream_primes_) +
                     HTTP(current::net::BarePort(port)).Register("/composites", *stream_composites_)),
         http_stream_subscriber_(source_annotated_numbers_stream_,
-                                [this](idxts_t, Number && n) { OnNumber(std::move(n)); }),
+                                [this](idxts_t, Number&& n) { OnNumber(std::move(n)); }),
         claire_(karl, "filter", port, {service_annotated}) {
     claire_.BoilerplateStatus().cloud_instance_name = "Computer";
     claire_.BoilerplateStatus().cloud_availability_group = "Earth";
diff --git a/karl/test_service/http_subscriber.h b/karl/test_service/http_subscriber.h
index 118f22732..cad555d9a 100644
--- a/karl/test_service/http_subscriber.h
+++ b/karl/test_service/http_subscriber.h
@@ -63,10 +63,11 @@ class HTTPStreamSubscriber {
   void Thread() {
     const std::string url = remote_stream_url_ + "?i=" + current::ToString(index_);
     try {
-      HTTP(ChunkedGET(url,
-                      [this](const std::string& header, const std::string& value) { OnHeader(header, value); },
-                      [this](const std::string& chunk_body) { OnChunk(chunk_body); },
-                      []() {}));
+      HTTP(ChunkedGET(
+          url,
+          [this](const std::string& header, const std::string& value) { OnHeader(header, value); },
+          [this](const std::string& chunk_body) { OnChunk(chunk_body); },
+          []() {}));
     } catch (current::net::NetworkException& e) {
       std::cerr << e.DetailedDescription() << std::endl;
       CURRENT_ASSERT(false);
diff --git a/karl/test_service/is_prime.h b/karl/test_service/is_prime.h
index b5efe708a..82fb3ac97 100644
--- a/karl/test_service/is_prime.h
+++ b/karl/test_service/is_prime.h
@@ -52,12 +52,12 @@ class ServiceIsPrime final {
  public:
   explicit ServiceIsPrime(uint16_t port, const current::karl::Locator& karl)
       : counter_(0ull),
-        http_scope_(HTTP(current::net::BarePort(port)).Register("/is_prime",
-                                        [this](Request r) {
-                                          ++counter_;
-                                          r(IsPrime(current::FromString<int>(r.url.query.get("x", "0"))) ? "YES\n"
-                                                                                                         : "NO\n");
-                                        })),
+        http_scope_(HTTP(current::net::BarePort(port))
+                        .Register("/is_prime",
+                                  [this](Request r) {
+                                    ++counter_;
+                                    r(IsPrime(current::FromString<int>(r.url.query.get("x", "0"))) ? "YES\n" : "NO\n");
+                                  })),
         claire_(karl, "is_prime", port) {
     const auto status_reporter = [this]() -> is_prime { return is_prime(counter_); };
 #ifdef CURRENT_MOCK_TIME
diff --git a/midichlorians/client/ios/midichlorians_impl.h b/midichlorians/client/ios/midichlorians_impl.h
index d28dfa106..4ffd6eca4 100644
--- a/midichlorians/client/ios/midichlorians_impl.h
+++ b/midichlorians/client/ios/midichlorians_impl.h
@@ -52,14 +52,14 @@
 #import <Foundation/Foundation.h>
 #import <CoreLocation/CoreLocation.h>
 
-using current::midichlorians::ios::iOSBaseEvent;
-using current::midichlorians::ios::iOSFirstLaunchEvent;
+using current::midichlorians::ios::ios_events_t;
 using current::midichlorians::ios::iOSAppLaunchEvent;
+using current::midichlorians::ios::iOSBaseEvent;
 using current::midichlorians::ios::iOSDeviceInfo;
-using current::midichlorians::ios::iOSIdentifyEvent;
+using current::midichlorians::ios::iOSFirstLaunchEvent;
 using current::midichlorians::ios::iOSFocusEvent;
 using current::midichlorians::ios::iOSGenericEvent;
-using current::midichlorians::ios::ios_events_t;
+using current::midichlorians::ios::iOSIdentifyEvent;
 
 // Define the iOS interface, being comfortably within a C++ header file included exclusively from an `.mm` one.
 @interface midichlorians_impl : NSObject
diff --git a/midichlorians/client/test.cc b/midichlorians/client/test.cc
index 64d82f3fb..0a22bddc0 100644
--- a/midichlorians/client/test.cc
+++ b/midichlorians/client/test.cc
@@ -56,17 +56,15 @@ class Server {
   using events_variant_t = Variant<ios_events_t>;
 
   Server(current::net::ReservedLocalPort reserved_port, const std::string& http_route)
-      : http_server_(HTTP(std::move(reserved_port))),
-        routes_(http_server_.Register(http_route,
-                                       [this](Request r) {
-                                         events_variant_t event;
-                                         try {
-                                           event = ParseJSON<events_variant_t>(r.body);
-                                           std::lock_guard<std::mutex> lock(mutex_);
-                                           event.Call(*this);
-                                         } catch (const current::Exception&) {
-                                         }
-                                       })) {}
+      : http_server_(HTTP(std::move(reserved_port))), routes_(http_server_.Register(http_route, [this](Request r) {
+          events_variant_t event;
+          try {
+            event = ParseJSON<events_variant_t>(r.body);
+            std::lock_guard<std::mutex> lock(mutex_);
+            event.Call(*this);
+          } catch (const current::Exception&) {
+          }
+        })) {}
 
   void operator()(const iOSAppLaunchEvent& event) {
     EXPECT_FALSE(event.device_id.empty());
@@ -138,7 +136,7 @@ TEST(midichloriansClient, iOSSmokeTest) {
   [midichlorians identify:@"unit_test"];
 
   current::time::SetNow(std::chrono::microseconds(5000));
-  NSDictionary* eventParams = @{ @"s" : @"str", @"b" : @true, @"x" : @1 };
+  NSDictionary* eventParams = @{@"s" : @"str", @"b" : @true, @"x" : @1};
   [midichlorians trackEvent:@"CustomEvent1" source:@"SmokeTest" properties:eventParams];
 
   current::time::SetNow(std::chrono::microseconds(15000));
diff --git a/midichlorians/midichlorians_data_dictionary.h b/midichlorians/midichlorians_data_dictionary.h
index 45a086842..ceed230b8 100644
--- a/midichlorians/midichlorians_data_dictionary.h
+++ b/midichlorians/midichlorians_data_dictionary.h
@@ -76,8 +76,8 @@ CURRENT_STRUCT(iOSAppLaunchEvent, iOSBaseEvent) {
   CURRENT_FIELD(app_install_time, uint64_t, 0ull);
   CURRENT_FIELD(app_update_time, uint64_t, 0ull);
   CURRENT_DEFAULT_CONSTRUCTOR(iOSAppLaunchEvent) {}
-  CURRENT_CONSTRUCTOR(iOSAppLaunchEvent)(
-      const std::string& cf_version, uint64_t app_install_time, uint64_t app_update_time)
+  CURRENT_CONSTRUCTOR(iOSAppLaunchEvent)
+  (const std::string& cf_version, uint64_t app_install_time, uint64_t app_update_time)
       : binary_version(__DATE__ " " __TIME__),
         cf_version(cf_version),
         app_install_time(app_install_time),
@@ -99,8 +99,8 @@ CURRENT_STRUCT(iOSIdentifyEvent, iOSBaseEvent){};
 CURRENT_STRUCT(iOSFocusEvent, iOSBaseEvent) {
   CURRENT_FIELD(gained_focus, bool);
   CURRENT_FIELD(source, std::string);
-  CURRENT_CONSTRUCTOR(iOSFocusEvent)(bool gained_focus = false, const std::string& source = "")
-      : gained_focus(gained_focus), source(source) {}
+  CURRENT_CONSTRUCTOR(iOSFocusEvent)
+  (bool gained_focus = false, const std::string& source = "") : gained_focus(gained_focus), source(source) {}
 };
 
 CURRENT_STRUCT(iOSGenericEvent, iOSBaseEvent) {
@@ -172,8 +172,8 @@ CURRENT_STRUCT(WebGenericEvent, WebBaseEvent) {
   CURRENT_FIELD(event_category, std::string);
   CURRENT_FIELD(event_action, std::string);
   CURRENT_DEFAULT_CONSTRUCTOR(WebGenericEvent) {}
-  CURRENT_CONSTRUCTOR(WebGenericEvent)(const std::string& category, const std::string& action)
-      : event_category(category), event_action(action) {}
+  CURRENT_CONSTRUCTOR(WebGenericEvent)
+  (const std::string& category, const std::string& action) : event_category(category), event_action(action) {}
 };
 
 using web_events_t = TypeList<WebEnterEvent, WebExitEvent, WebForegroundEvent, WebBackgroundEvent, WebGenericEvent>;
diff --git a/midichlorians/server/server.h b/midichlorians/server/server.h
index 5ec46e190..6b48e462e 100644
--- a/midichlorians/server/server.h
+++ b/midichlorians/server/server.h
@@ -118,18 +118,18 @@ class midichloriansHTTPServer {
     bool is_allowed_method = false;
     const std::map<std::string, std::string>& q =
         [&r, &extracted_q, &is_allowed_method]() -> const std::map<std::string, std::string>& {
-          if (r.method == "GET" || r.method == "HEAD") {
-            is_allowed_method = true;
-            return r.url.AllQueryParameters();
-          } else if (r.method == "POST") {
-            is_allowed_method = true;
-            extracted_q = current::url::URL::ParseQueryString(r.body);
-            for (const auto& cit : r.url.AllQueryParameters()) {
-              extracted_q.insert(cit);
-            }
-          }
-          return extracted_q;
-        }();
+      if (r.method == "GET" || r.method == "HEAD") {
+        is_allowed_method = true;
+        return r.url.AllQueryParameters();
+      } else if (r.method == "POST") {
+        is_allowed_method = true;
+        extracted_q = current::url::URL::ParseQueryString(r.body);
+        for (const auto& cit : r.url.AllQueryParameters()) {
+          extracted_q.insert(cit);
+        }
+      }
+      return extracted_q;
+    }();
 
     if (!is_allowed_method) {
       return false;  // LCOV_EXCL_LINE
diff --git a/midichlorians/server/test.cc b/midichlorians/server/test.cc
index d14eb7fb6..c580d66b6 100644
--- a/midichlorians/server/test.cc
+++ b/midichlorians/server/test.cc
@@ -263,8 +263,7 @@ TEST(midichloriansServer, iOSEventsFromNativeClientSmokeTest) {
   midichloriansHTTPServer<GenericConsumer> server(port, consumer, std::chrono::milliseconds(100), "/log", "OK\n");
 
   NSDictionary* launchOptions = [NSDictionary new];
-  [midichlorians setup:[NSString stringWithFormat:@"http://localhost:%d/log", port]
-      withLaunchOptions:launchOptions];
+  [midichlorians setup:[NSString stringWithFormat:@"http://localhost:%d/log", port] withLaunchOptions:launchOptions];
 
   current::time::SetNow(std::chrono::microseconds(1000));
   [midichlorians focusEvent:YES source:@"applicationDidBecomeActive"];
@@ -273,7 +272,7 @@ TEST(midichloriansServer, iOSEventsFromNativeClientSmokeTest) {
   [midichlorians identify:@"unit_test"];
 
   current::time::SetNow(std::chrono::microseconds(5000));
-  NSDictionary* eventParams = @{ @"s" : @"str", @"b" : @true, @"x" : @1 };
+  NSDictionary* eventParams = @{@"s" : @"str", @"b" : @true, @"x" : @1};
   [midichlorians trackEvent:@"CustomEvent1" source:@"SmokeTest" properties:eventParams];
 
   current::time::SetNow(std::chrono::microseconds(15000));
diff --git a/nlp/nlp.h b/nlp/nlp.h
index 5a7276abd..364d0a1df 100644
--- a/nlp/nlp.h
+++ b/nlp/nlp.h
@@ -496,7 +496,7 @@ struct FilterImpl {
   }
 };
 
-}  // namespace current::nlp::impl
+}  // namespace impl
 
 template <typename ANNOTATED_QUERY_TERM, class IMPL>
 struct SchemaBlock {
@@ -660,7 +660,7 @@ Optional<typename IMPL::emitted_t> JustMatchQuery(const SchemaBlock<ANNOTATED_QU
   }
 }
 
-}  // namespace current::nlp
+}  // namespace nlp
 }  // namespace current
 
 // `UseNLPSchema` injects names defined in the Current NLP schema into user's namespace.
diff --git a/port.h b/port.h
index 584fe0d26..475da9f87 100644
--- a/port.h
+++ b/port.h
@@ -41,7 +41,7 @@ SOFTWARE.
 
 #ifndef NOMINMAX
 #define NOMINMAX  // Tell Visual Studio to not mess with std::min() / std::max().
-#endif  // NOMINMAX
+#endif            // NOMINMAX
 
 #ifdef _MSC_VER
 // clang-format off
@@ -53,10 +53,10 @@ SOFTWARE.
 #endif  // !_CRT_SECURE_NO_WARNINGS
 #endif
 
-#include <limits>  // For data type implementation details.
-#include <string>  // For architecture names.
-#include <memory>  // For `std::unique_ptr`.
-#include <type_traits> // For `std::is_same_v`
+#include <limits>       // For data type implementation details.
+#include <string>       // For architecture names.
+#include <memory>       // For `std::unique_ptr`.
+#include <type_traits>  // For `std::is_same_v`
 
 #ifdef CURRENT_FOR_CPP14
 namespace current_injected_cpp17 {
@@ -76,8 +76,12 @@ constexpr bool is_arithmetic_v = ::std::is_arithmetic<T>::value;
 template <class T, class... TS>
 constexpr bool is_constructible_v = ::std::is_constructible<T, TS...>::value;
 
-template<typename... TS> struct make_void { typedef void type;};
-template<typename... TS> using void_t = typename make_void<TS...>::type;
+template <typename... TS>
+struct make_void {
+  typedef void type;
+};
+template <typename... TS>
+using void_t = typename make_void<TS...>::type;
 
 }  // namespace current_injected_cpp17
 
@@ -118,8 +122,9 @@ using namespace current_injected_cpp17;
 #define COUNT_CURRENT_WINDOWS_DEFINED 0
 #endif
 
-#define CURRENT_PORT_COUNT \
-   (COUNT_CURRENT_POSIX_DEFINED + COUNT_CURRENT_APPLE_DEFINED + COUNT_CURRENT_JAVA_DEFINED + COUNT_CURRENT_WINDOWS_DEFINED)
+#define CURRENT_PORT_COUNT                                                                  \
+  (COUNT_CURRENT_POSIX_DEFINED + COUNT_CURRENT_APPLE_DEFINED + COUNT_CURRENT_JAVA_DEFINED + \
+   COUNT_CURRENT_WINDOWS_DEFINED)
 
 #if defined(ANDROID)
 
@@ -240,7 +245,7 @@ struct is_same_or_compile_error {
   enum { value = std::is_same_v<T1, T2> };
   char is_same_static_assert_failed[value ? 1 : -1];
 };
-#define CURRENT_FAIL_IF_NOT_SAME_TYPE(A,B) static_assert(sizeof(is_same_or_compile_error<A, B>), "")
+#define CURRENT_FAIL_IF_NOT_SAME_TYPE(A, B) static_assert(sizeof(is_same_or_compile_error<A, B>), "")
 
 #ifdef CURRENT_JAVA
 #error "Current has not been tested with Java for a while, and would likely require a bit of TLC. Thank you."
diff --git a/profiler/profiler.h b/profiler/profiler.h
index 2fb602d35..7a1fc2679 100644
--- a/profiler/profiler.h
+++ b/profiler/profiler.h
@@ -280,7 +280,7 @@ struct Profiler {
     scope += HTTP(port).Register(route, ::current::profiler::Profiler::HTTPRoute); \
   } while (false)
 
-}  // namespace current::profiler
+}  // namespace profiler
 }  // namespace current
 
 #endif
diff --git a/regression_tests/typesystem/struct_fields.cc b/regression_tests/typesystem/struct_fields.cc
index b9185ced8..4ccf49aa4 100644
--- a/regression_tests/typesystem/struct_fields.cc
+++ b/regression_tests/typesystem/struct_fields.cc
@@ -39,8 +39,8 @@ namespace type_test {
 
 TEST(TypeTest, StructFields) {
   using namespace type_test;
-  using current::reflection::StructSchema;
   using current::reflection::Language;
+  using current::reflection::StructSchema;
 
   StructWithManyFields foo;
   foo.z1 = 42u;
diff --git a/regression_tests/typesystem/typelist_dynamic.cc b/regression_tests/typesystem/typelist_dynamic.cc
index bf5d075b9..b7cebf012 100644
--- a/regression_tests/typesystem/typelist_dynamic.cc
+++ b/regression_tests/typesystem/typelist_dynamic.cc
@@ -44,8 +44,8 @@ TEST(TypeTest, TypeListImpl) {
   using namespace type_test;
 #include "include/typelist_dynamic.cc"
 
-  using current::metaprogramming::map;
   using current::metaprogramming::Flatten;
+  using current::metaprogramming::map;
   typedef Flatten<map<ST, DATA_TYPES>> STORAGE_TYPES;
 
   static_assert(TypeListSize<STORAGE_TYPES> == TypeListSize<DATA_TYPES> * 2, "");
diff --git a/ripcurrent/ripcurrent.h b/ripcurrent/ripcurrent.h
index fca1b5d32..ab608671e 100644
--- a/ripcurrent/ripcurrent.h
+++ b/ripcurrent/ripcurrent.h
@@ -127,7 +127,9 @@ class UniqueDefinition<LHSTypes<LHS_TYPES...>, RHSTypes<RHS_TYPES...>> final : p
   explicit UniqueDefinition(const UniqueDefinition&) = default;
 
   // Can be marked as used in any way.
-  void MarkAs(BlockUsageBit bit) { mask_ = BlockUsageBitMask(size_t(mask_) | (static_cast<size_t>(1) << static_cast<size_t>(bit))); }
+  void MarkAs(BlockUsageBit bit) {
+    mask_ = BlockUsageBitMask(size_t(mask_) | (static_cast<size_t>(1) << static_cast<size_t>(bit)));
+  }
 
   // Builds the full description of this `Definition`, down to source code file names and line numbers.
   void FullDescription(std::ostream& os = std::cerr) const {
@@ -592,8 +594,8 @@ class UserCodeInstantiator<LHSTypes<LHS_TYPES...>, RHSTypes<RHS_TYPES...>, USER_
   UserCodeInstantiator(Definition definition, ARGS_AS_TUPLE&& params)
       : AbstractCurrent<instantiator_input_t, instantiator_output_t>(definition),
         lazy_instance_(current::DelayedInstantiateWithExtraParameterFromTuple<
-            UserClassInstantiator<instantiator_input_t, instantiator_output_t, USER_CLASS>,
-            std::shared_ptr<BlockOutgoingInterface<ThreadUnsafeOutgoingTypes<RHS_TYPES...>>>>(
+                       UserClassInstantiator<instantiator_input_t, instantiator_output_t, USER_CLASS>,
+                       std::shared_ptr<BlockOutgoingInterface<ThreadUnsafeOutgoingTypes<RHS_TYPES...>>>>(
             std::forward<ARGS_AS_TUPLE>(params))) {}
 
   class Scope final : public SubCurrentScope<instantiator_input_t, instantiator_output_t> {
@@ -1016,7 +1018,7 @@ struct Drop : UserCodeImpl<LHSTypes<T, TS...>, RHSTypes<>, DropImpl<T, TS...>> {
   Drop() : super_t(Definition("DROP", __FILE__, __LINE__), std::make_tuple()) {}
 };
 
-}  // namespace current::ripcurrent
+}  // namespace ripcurrent
 }  // namespace current
 
 // Macros to wrap user code into RipCurrent building blocks.
@@ -1047,12 +1049,11 @@ struct Drop : UserCodeImpl<LHSTypes<T, TS...>, RHSTypes<>, DropImpl<T, TS...>> {
                                         ::current::ripcurrent::VoidOrRHSTypes<CURRENT_REMOVE_PARENTHESES(RHS_TS)>, \
                                         USER_CLASS_T<T>>
 
-#define RIPCURRENT_MACRO_T(USER_CLASS, T, ...)                                                         \
-  ::current::ripcurrent::UserCodeImpl<typename USER_CLASS<T>::input_t,                                 \
-                                      typename USER_CLASS<T>::output_t,                                \
-                                      USER_CLASS<T>>(                                                  \
-      ::current::ripcurrent::Definition(#USER_CLASS "<" #T ">(" #__VA_ARGS__ ")", __FILE__, __LINE__), \
-      std::make_tuple(__VA_ARGS__))
+#define RIPCURRENT_MACRO_T(USER_CLASS, T, ...)                                                             \
+  ::current::ripcurrent::                                                                                  \
+      UserCodeImpl<typename USER_CLASS<T>::input_t, typename USER_CLASS<T>::output_t, USER_CLASS<T>>(      \
+          ::current::ripcurrent::Definition(#USER_CLASS "<" #T ">(" #__VA_ARGS__ ")", __FILE__, __LINE__), \
+          std::make_tuple(__VA_ARGS__))
 
 // A shortcut for `current::ripcurrent::Pass<...>()`, with the benefit of listing types as RipCurrent node name.
 #define RIPCURRENT_PASS(...)                                                                                     \
diff --git a/ripcurrent/test.cc b/ripcurrent/test.cc
index b7c83a94f..3238ac385 100644
--- a/ripcurrent/test.cc
+++ b/ripcurrent/test.cc
@@ -299,56 +299,44 @@ TEST(RipCurrent, MoreTypeSystemGuarantees) {
   const auto emit_mult_mult_dump_3 = ((emit | mult) | mult) | dump;
   const auto emit_mult_mult_dump_4 = emit | (mult | (mult | dump));
 
-  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult)::input_t, current::ripcurrent::LHSTypes<>>,
+  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult)::input_t, current::ripcurrent::LHSTypes<>>, "");
+  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult)::output_t, current::ripcurrent::RHSTypes<Integer>>,
                 "");
-  static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult)::output_t, current::ripcurrent::RHSTypes<Integer>>, "");
 
-  static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(mult_dump)::input_t, current::ripcurrent::LHSTypes<Integer>>, "");
-  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(mult_dump)::output_t, current::ripcurrent::RHSTypes<>>,
+  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(mult_dump)::input_t, current::ripcurrent::LHSTypes<Integer>>,
                 "");
+  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(mult_dump)::output_t, current::ripcurrent::RHSTypes<>>, "");
+
+  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_dump)::input_t, current::ripcurrent::LHSTypes<>>, "");
+  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_dump)::output_t, current::ripcurrent::RHSTypes<>>, "");
 
-  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_dump)::input_t, current::ripcurrent::LHSTypes<>>,
+  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_dump_1)::input_t, current::ripcurrent::LHSTypes<>>,
                 "");
-  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_dump)::output_t, current::ripcurrent::RHSTypes<>>,
+  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_dump_1)::output_t, current::ripcurrent::RHSTypes<>>,
                 "");
 
+  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_dump_2)::input_t, current::ripcurrent::LHSTypes<>>,
+                "");
+  static_assert(std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_dump_2)::output_t, current::ripcurrent::RHSTypes<>>,
+                "");
   static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_dump_1)::input_t, current::ripcurrent::LHSTypes<>>, "");
-  static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_dump_1)::output_t, current::ripcurrent::RHSTypes<>>, "");
-
-  static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_dump_2)::input_t, current::ripcurrent::LHSTypes<>>, "");
-  static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_dump_2)::output_t, current::ripcurrent::RHSTypes<>>, "");
-  static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_1)::input_t, current::ripcurrent::LHSTypes<>>,
-      "");
+      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_1)::input_t, current::ripcurrent::LHSTypes<>>, "");
   static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_1)::output_t, current::ripcurrent::RHSTypes<>>,
-      "");
+      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_1)::output_t, current::ripcurrent::RHSTypes<>>, "");
 
   static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_2)::input_t, current::ripcurrent::LHSTypes<>>,
-      "");
+      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_2)::input_t, current::ripcurrent::LHSTypes<>>, "");
   static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_2)::output_t, current::ripcurrent::RHSTypes<>>,
-      "");
+      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_2)::output_t, current::ripcurrent::RHSTypes<>>, "");
   static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_3)::input_t, current::ripcurrent::LHSTypes<>>,
-      "");
+      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_3)::input_t, current::ripcurrent::LHSTypes<>>, "");
   static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_3)::output_t, current::ripcurrent::RHSTypes<>>,
-      "");
+      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_3)::output_t, current::ripcurrent::RHSTypes<>>, "");
 
   static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_4)::input_t, current::ripcurrent::LHSTypes<>>,
-      "");
+      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_4)::input_t, current::ripcurrent::LHSTypes<>>, "");
   static_assert(
-      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_4)::output_t, current::ripcurrent::RHSTypes<>>,
-      "");
+      std::is_same_v<RIPCURRENT_UNDERLYING_TYPE(emit_mult_mult_dump_4)::output_t, current::ripcurrent::RHSTypes<>>, "");
 
   emit_mult.Dismiss();
   mult_dump.Dismiss();
@@ -598,31 +586,36 @@ TEST(RipCurrent, PlusIntrospection) {
       "DumpString() + DumpBool()",
       ((EmitInteger() + EmitString() + EmitBool()) |
        (RIPCURRENT_PASS(Integer) + RIPCURRENT_PASS(String) + RIPCURRENT_PASS(Bool)) |
-       (DumpInteger() + DumpString() + DumpBool())).Describe());
+       (DumpInteger() + DumpString() + DumpBool()))
+          .Describe());
 
   EXPECT_EQ(
       "EmitInteger() + EmitString() + EmitBool() | Pass(Integer, String, Bool) | DumpInteger() + DumpString() + "
       "DumpBool()",
       ((EmitInteger() + EmitString() + EmitBool()) | RIPCURRENT_PASS(Integer, String, Bool) |
-       (DumpInteger() + DumpString() + DumpBool())).Describe());
+       (DumpInteger() + DumpString() + DumpBool()))
+          .Describe());
 
   EXPECT_EQ(
       "EmitInteger() + EmitString() + EmitBool() | Pass(Integer, String) + DumpBool() | DumpInteger() + DumpString()",
       ((EmitInteger() + EmitString() + EmitBool()) | (RIPCURRENT_PASS(Integer, String) + DumpBool()) |
-       (DumpInteger() + DumpString())).Describe());
+       (DumpInteger() + DumpString()))
+          .Describe());
 
   EXPECT_EQ(
       "EmitInteger() + EmitString() + EmitBool() | DumpInteger() + Pass(String, Bool) | Pass(String) + DumpBool() | "
       "DumpString()",
       ((EmitInteger() + EmitString() + EmitBool()) | (DumpInteger() + RIPCURRENT_PASS(String, Bool)) |
-       ((RIPCURRENT_PASS(String) + DumpBool()) | DumpString())).Describe());
+       ((RIPCURRENT_PASS(String) + DumpBool()) | DumpString()))
+          .Describe());
 
   EXPECT_EQ("EmitInteger() + EmitString() + EmitBool() | DumpInteger() + Drop(String, Bool)",
             ((EmitInteger() + EmitString() + EmitBool()) | (DumpInteger() + RIPCURRENT_DROP(String, Bool))).Describe());
 
   EXPECT_EQ("EmitInteger() + EmitString() + EmitBool() | Pass(Integer) + Drop(String, Bool) | Drop(Integer)",
             ((EmitInteger() + EmitString() + EmitBool()) | (RIPCURRENT_PASS(Integer) + RIPCURRENT_DROP(String, Bool)) |
-             RIPCURRENT_DROP(Integer)).Describe());
+             RIPCURRENT_DROP(Integer))
+                .Describe());
 
   EXPECT_EQ("EmitInteger() + EmitString() => { Integer, String } | ...",
             (EmitInteger() + EmitString()).DescribeWithTypes());
@@ -798,8 +791,9 @@ CURRENT_STRUCT(RequestContainer) {
 
 RIPCURRENT_NODE(RCHTTPAcceptor, void, RequestContainer) {
   RCHTTPAcceptor(uint16_t port)
-      : scope(HTTP(current::net::BarePort(port))
-                  .Register("/ripcurrent", [this](Request request) { emit<RequestContainer>(std::move(request)); })) {
+      : scope(HTTP(current::net::BarePort(port)).Register("/ripcurrent", [this](Request request) {
+          emit<RequestContainer>(std::move(request));
+        })) {
     const std::string base_url = Printf("http://localhost:%d/ripcurrent", static_cast<int>(port));
     EXPECT_EQ("1\n", HTTP(GET(base_url)).body);
     EXPECT_EQ("2\n", HTTP(HEAD(base_url)).body);
diff --git a/ripcurrent/types.h b/ripcurrent/types.h
index cd0a62a4a..fbf4fffbe 100644
--- a/ripcurrent/types.h
+++ b/ripcurrent/types.h
@@ -155,7 +155,7 @@ template <typename T>
 struct LHSTypesFromTypeListImpl;
 
 template <typename... TS>
-struct LHSTypesFromTypeListImpl<TypeListImpl<TS...>> {
+struct LHSTypesFromTypeListImpl<TypeListImpl<TS...> > {
   using type = LHSTypes<TS...>;
 };
 
@@ -166,7 +166,7 @@ template <typename T>
 struct RHSTypesFromTypeListImpl;
 
 template <typename... TS>
-struct RHSTypesFromTypeListImpl<TypeListImpl<TS...>> {
+struct RHSTypesFromTypeListImpl<TypeListImpl<TS...> > {
   using type = RHSTypes<TS...>;
 };
 
@@ -219,7 +219,7 @@ struct FileLine final {
   const size_t line;
 };
 
-}  // namespace current::ripcurrent
+}  // namespace ripcurrent
 }  // namespace current
 
 #endif  // CURRENT_RIPCURRENT_TYPES_H
diff --git a/storage/api.h b/storage/api.h
index bbb230388..7b40a7107 100644
--- a/storage/api.h
+++ b/storage/api.h
@@ -160,51 +160,49 @@ struct PerFieldRESTfulHandlerGenerator {
               const specific_field_t& field = generic_input.storage(::current::storage::ImmutableFieldByIndex<INDEX>());
               generic_input.storage
                   .template ReadOnlyTransaction<current::locks::MutexLockStatus::AlreadyLocked>(
-                       // Capture local variables by value for safe async transactions.
-                       [&storage, handler, generic_input, &field, url_key, field_name, requested_export_params](
-                           immutable_fields_t fields) -> Response {
-                         using GETInput = RESTfulGETInput<STORAGE, specific_field_t>;
-                         const GETInput input(
-                             std::move(generic_input),
-                             fields,
-                             field,
-                             field_name,
-                             url_key,
-                             storage.template IsMasterStorage<current::locks::MutexLockStatus::AlreadyLocked>(),
-                             requested_export_params);
-                         return handler.Run(input);
-                       },
-                       std::move(request))
+                      // Capture local variables by value for safe async transactions.
+                      [&storage, handler, generic_input, &field, url_key, field_name, requested_export_params](
+                          immutable_fields_t fields) -> Response {
+                        using GETInput = RESTfulGETInput<STORAGE, specific_field_t>;
+                        const GETInput input(
+                            std::move(generic_input),
+                            fields,
+                            field,
+                            field_name,
+                            url_key,
+                            storage.template IsMasterStorage<current::locks::MutexLockStatus::AlreadyLocked>(),
+                            requested_export_params);
+                        return handler.Run(input);
+                      },
+                      std::move(request))
                   .Detach();
             });
       } else if (request.method == "POST" && is_master) {
         POSTHandler handler;
-        handler.Enter(
-            std::move(request),
-            // Capture by reference since this lambda is run synchronously.
-            [&handler, &generic_input, &field_name](Request request) {
-              try {
-                const bool overwrite = request.url.query.has("overwrite");
-                auto mutable_entry = ParseJSON<entry_t>(request.body);
-                specific_field_t& field = generic_input.storage(::current::storage::MutableFieldByIndex<INDEX>());
-                generic_input.storage.template ReadWriteTransaction<current::locks::MutexLockStatus::AlreadyLocked>(
-                                          // Capture local variables by value for safe async transactions.
-                                          [handler, generic_input, &field, mutable_entry, field_name, overwrite](
-                                              mutable_fields_t fields) mutable -> Response {
-                                            using POSTInput = RESTfulPOSTInput<STORAGE, specific_field_t, entry_t>;
-                                            const POSTInput input(std::move(generic_input),
-                                                                  fields,
-                                                                  field,
-                                                                  field_name,
-                                                                  mutable_entry,
-                                                                  overwrite);
-                                            return handler.Run(input);
-                                          },
-                                          std::move(request)).Detach();
-              } catch (const TypeSystemParseJSONException& e) {
-                request(handler.ErrorBadJSON(e.OriginalDescription()));
-              }
-            });
+        handler.Enter(std::move(request),
+                      // Capture by reference since this lambda is run synchronously.
+                      [&handler, &generic_input, &field_name](Request request) {
+                        try {
+                          const bool overwrite = request.url.query.has("overwrite");
+                          auto mutable_entry = ParseJSON<entry_t>(request.body);
+                          specific_field_t& field =
+                              generic_input.storage(::current::storage::MutableFieldByIndex<INDEX>());
+                          generic_input.storage
+                              .template ReadWriteTransaction<current::locks::MutexLockStatus::AlreadyLocked>(
+                                  // Capture local variables by value for safe async transactions.
+                                  [handler, generic_input, &field, mutable_entry, field_name, overwrite](
+                                      mutable_fields_t fields) mutable -> Response {
+                                    using POSTInput = RESTfulPOSTInput<STORAGE, specific_field_t, entry_t>;
+                                    const POSTInput input(
+                                        std::move(generic_input), fields, field, field_name, mutable_entry, overwrite);
+                                    return handler.Run(input);
+                                  },
+                                  std::move(request))
+                              .Detach();
+                        } catch (const TypeSystemParseJSONException& e) {
+                          request(handler.ErrorBadJSON(e.OriginalDescription()));
+                        }
+                      });
       } else if (request.method == "PUT" && is_master) {
         PUTHandler handler;
         handler.Enter(
@@ -218,21 +216,18 @@ struct PerFieldRESTfulHandlerGenerator {
                 const auto entry = ParseJSON<entry_t>(request.body);
                 const auto entry_key = field_type_dependent_t<specific_field_t>::ExtractOrComposeKey(entry);
                 specific_field_t& field = generic_input.storage(::current::storage::MutableFieldByIndex<INDEX>());
-                generic_input.storage.template ReadWriteTransaction<current::locks::MutexLockStatus::AlreadyLocked>(
-                                          // Capture local variables by value for safe async transactions.
-                                          [handler, generic_input, &field, url_key, entry, entry_key, field_name](
-                                              mutable_fields_t fields) -> Response {
-                                            using PUTInput = RESTfulPUTInput<STORAGE, specific_field_t, entry_t, key_t>;
-                                            const PUTInput input(std::move(generic_input),
-                                                                 fields,
-                                                                 field,
-                                                                 field_name,
-                                                                 url_key,
-                                                                 entry,
-                                                                 entry_key);
-                                            return handler.Run(input);
-                                          },
-                                          std::move(request)).Detach();
+                generic_input.storage
+                    .template ReadWriteTransaction<current::locks::MutexLockStatus::AlreadyLocked>(
+                        // Capture local variables by value for safe async transactions.
+                        [handler, generic_input, &field, url_key, entry, entry_key, field_name](
+                            mutable_fields_t fields) -> Response {
+                          using PUTInput = RESTfulPUTInput<STORAGE, specific_field_t, entry_t, key_t>;
+                          const PUTInput input(
+                              std::move(generic_input), fields, field, field_name, url_key, entry, entry_key);
+                          return handler.Run(input);
+                        },
+                        std::move(request))
+                    .Detach();
               } catch (const TypeSystemParseJSONException& e) {          // LCOV_EXCL_LINE
                 request(handler.ErrorBadJSON(e.OriginalDescription()));  // LCOV_EXCL_LINE
               }
@@ -247,17 +242,18 @@ struct PerFieldRESTfulHandlerGenerator {
               const auto url_key = field_type_dependent_t<specific_field_t>::template ParseURLKey<key_t>(input_url_key);
               const std::string patch_body = request.body;
               specific_field_t& field = generic_input.storage(::current::storage::MutableFieldByIndex<INDEX>());
-              generic_input.storage.template ReadWriteTransaction<current::locks::MutexLockStatus::AlreadyLocked>(
-                                        // Capture local variables by value for safe async transactions.
-                                        [handler, generic_input, &field, url_key, field_name, patch_body](
-                                            mutable_fields_t fields) -> Response {
-                                          using PATCHInput =
-                                              RESTfulPATCHInput<STORAGE, specific_field_t, entry_t, key_t>;
-                                          const PATCHInput input(
-                                              std::move(generic_input), fields, field, field_name, url_key, patch_body);
-                                          return handler.Run(input);
-                                        },
-                                        std::move(request)).Detach();
+              generic_input.storage
+                  .template ReadWriteTransaction<current::locks::MutexLockStatus::AlreadyLocked>(
+                      // Capture local variables by value for safe async transactions.
+                      [handler, generic_input, &field, url_key, field_name, patch_body](
+                          mutable_fields_t fields) -> Response {
+                        using PATCHInput = RESTfulPATCHInput<STORAGE, specific_field_t, entry_t, key_t>;
+                        const PATCHInput input(
+                            std::move(generic_input), fields, field, field_name, url_key, patch_body);
+                        return handler.Run(input);
+                      },
+                      std::move(request))
+                  .Detach();
             });
       } else if (request.method == "DELETE" && is_master) {
         DELETEHandler handler;
@@ -268,16 +264,16 @@ struct PerFieldRESTfulHandlerGenerator {
                 Request request, const typename field_type_dependent_t<specific_field_t>::url_key_t& input_url_key) {
               const auto url_key = field_type_dependent_t<specific_field_t>::template ParseURLKey<key_t>(input_url_key);
               specific_field_t& field = generic_input.storage(::current::storage::MutableFieldByIndex<INDEX>());
-              generic_input.storage.template ReadWriteTransaction<current::locks::MutexLockStatus::AlreadyLocked>(
-                                        // Capture local variables by value for safe async transactions.
-                                        [handler, generic_input, &field, url_key, field_name](mutable_fields_t fields)
-                                            -> Response {
-                                              using DELETEInput = RESTfulDELETEInput<STORAGE, specific_field_t, key_t>;
-                                              const DELETEInput input(
-                                                  std::move(generic_input), fields, field, field_name, url_key);
-                                              return handler.Run(input);
-                                            },
-                                        std::move(request)).Detach();
+              generic_input.storage
+                  .template ReadWriteTransaction<current::locks::MutexLockStatus::AlreadyLocked>(
+                      // Capture local variables by value for safe async transactions.
+                      [handler, generic_input, &field, url_key, field_name](mutable_fields_t fields) -> Response {
+                        using DELETEInput = RESTfulDELETEInput<STORAGE, specific_field_t, key_t>;
+                        const DELETEInput input(std::move(generic_input), fields, field, field_name, url_key);
+                        return handler.Run(input);
+                      },
+                      std::move(request))
+                  .Detach();
             });
       } else {
         const std::string error_message =
@@ -295,8 +291,7 @@ struct PerFieldRESTfulHandlerGenerator {
     // Schema handlers.
 
     SchemaHandlerImpl<entry_t>().RegisterRoutes(
-        storage,
-        [&](const std::string& route_suffix, const std::function<void(Request)> handler) {
+        storage, [&](const std::string& route_suffix, const std::function<void(Request)> handler) {
           registerer(storage_handlers_map_entry_t(
               input_field_name,
               RESTfulRoute(kRESTfulSchemaURLComponent, route_suffix, URLPathArgs::CountMask::None, handler)));
@@ -338,19 +333,18 @@ struct PerFieldRESTfulHandlerGenerator {
             // Capture by reference since this lambda is run synchronously.
             [&handler, &generic_input, &field_name](Request request, const Optional<std::string>& url_key) {
               const specific_field_t& field = generic_input.storage(::current::storage::ImmutableFieldByIndex<INDEX>());
-              generic_input.storage.template ReadOnlyTransaction<current::locks::MutexLockStatus::AlreadyLocked>(
-                                        // Capture local variables by value for safe async transactions.
-                                        [handler, generic_input, &field, url_key, field_name](
-                                            immutable_fields_t fields) -> Response {
-                                          using RowColGETInput =
-                                              RESTfulGETRowColInput<STORAGE,
-                                                                    typename PARTIAL_KEY_OPERATION::key_completeness_t,
-                                                                    specific_field_t>;
-                                          const RowColGETInput input(
-                                              std::move(generic_input), fields, field, field_name, url_key);
-                                          return handler.Run(input);
-                                        },
-                                        std::move(request)).Detach();
+              generic_input.storage
+                  .template ReadOnlyTransaction<current::locks::MutexLockStatus::AlreadyLocked>(
+                      // Capture local variables by value for safe async transactions.
+                      [handler, generic_input, &field, url_key, field_name](immutable_fields_t fields) -> Response {
+                        using RowColGETInput = RESTfulGETRowColInput<STORAGE,
+                                                                     typename PARTIAL_KEY_OPERATION::key_completeness_t,
+                                                                     specific_field_t>;
+                        const RowColGETInput input(std::move(generic_input), fields, field, field_name, url_key);
+                        return handler.Run(input);
+                      },
+                      std::move(request))
+                  .Detach();
             });
       } else {
         request(
@@ -395,7 +389,7 @@ void GenerateRESTfulHandler(registerer_t registerer, STORAGE& storage, const std
           PerFieldRESTfulHandlerGenerator<REST_IMPL, INDEX, STORAGE>(registerer, storage, restful_url_prefix));
 }
 
-}  // namespace current::storage::rest::impl
+}  // namespace impl
 
 template <class STORAGE_IMPL, class REST_IMPL = plain::Plain>
 class RESTfulStorage {
@@ -549,8 +543,9 @@ class RESTfulStorage {
       using specific_entry_type_t =
           typename impl::PerFieldRESTfulHandlerGenerator<REST_IMPL, I - 1, STORAGE_IMPL>::specific_entry_type_t;
       current::metaprogramming::CallIf<FieldExposedViaREST<STORAGE_IMPL, specific_entry_type_t>::exposed>::With([&] {
-        const auto registerer =
-            [&handlers](const impl::storage_handlers_map_entry_t& restful_route) { handlers.insert(restful_route); };
+        const auto registerer = [&handlers](const impl::storage_handlers_map_entry_t& restful_route) {
+          handlers.insert(restful_route);
+        };
         impl::GenerateRESTfulHandler<REST_IMPL, I - 1, STORAGE_IMPL>(registerer, storage, restful_url_prefix);
       });
     }
@@ -565,7 +560,8 @@ class RESTfulStorage {
     const auto path = data_->route_prefix_ + '/' + route.resource_prefix +
                       (field_name.empty() ? "" : '/' + field_name) + route.resource_suffix;
     data_->handler_routes_.emplace_back(path, route.resource_args_mask);
-    data_->handlers_scope_ += HTTP(current::net::BarePort(data_->port_)).Register(path, route.resource_args_mask, route.handler);
+    data_->handlers_scope_ +=
+        HTTP(current::net::BarePort(data_->port_)).Register(path, route.resource_args_mask, route.handler);
   }
 
   template <typename T, url::FillObjectMode MODE>
@@ -609,23 +605,24 @@ class RESTfulStorage {
           std::shared_ptr<CurrentStruct> type_erased_query = f_parse_query_body(request);
           if (type_erased_query) {
             typename CQSHandlerImpl::Context context;
-            handler.Enter(
-                std::move(request),
-                context,
-                // Capture by reference since this lambda is run synchronously.
-                [&handler, &f_run_query, &generic_input, &type_erased_query, &context](Request request) {
-                  const STORAGE_IMPL& storage = generic_input.storage;
-                  const cqs::CQSParameters cqs_parameters(generic_input.restful_url_prefix, request);
-                  storage.template ReadOnlyTransaction<current::locks::MutexLockStatus::AlreadyLocked>(
-                              // TODO(dkorolev): Revisit this as Owned/Borrowed are the organic part of Storage.
-                              // Capture local variables by value for safe async transactions.
-                              [&f_run_query, handler, cqs_parameters, type_erased_query, context](
-                                  immutable_fields_t fields) -> Response {
-                                return handler.RunQuery(
-                                    context, f_run_query, fields, std::move(type_erased_query), cqs_parameters);
-                              },
-                              std::move(request)).Detach();
-                });
+            handler.Enter(std::move(request),
+                          context,
+                          // Capture by reference since this lambda is run synchronously.
+                          [&handler, &f_run_query, &generic_input, &type_erased_query, &context](Request request) {
+                            const STORAGE_IMPL& storage = generic_input.storage;
+                            const cqs::CQSParameters cqs_parameters(generic_input.restful_url_prefix, request);
+                            storage
+                                .template ReadOnlyTransaction<current::locks::MutexLockStatus::AlreadyLocked>(
+                                    // TODO(dkorolev): Revisit this as Owned/Borrowed are the organic part of Storage.
+                                    // Capture local variables by value for safe async transactions.
+                                    [&f_run_query, handler, cqs_parameters, type_erased_query, context](
+                                        immutable_fields_t fields) -> Response {
+                                      return handler.RunQuery(
+                                          context, f_run_query, fields, std::move(type_erased_query), cqs_parameters);
+                                    },
+                                    std::move(request))
+                                .Detach();
+                          });
           }
         } else {
           request(Response(cqs::CQSHandlerNotFound(), HTTPResponseCode.NotFound));
@@ -658,23 +655,24 @@ class RESTfulStorage {
           std::shared_ptr<CurrentStruct> type_erased_command = f_parse_command_body(request);
           if (type_erased_command) {
             typename CQSHandlerImpl::Context ctx;
-            handler.Enter(
-                std::move(request),
-                ctx,
-                // Capture by reference since this lambda is run synchronously.
-                [&handler, &f_run_command, &generic_input, &type_erased_command, &ctx](Request request) {
-                  STORAGE_IMPL& storage = generic_input.storage;
-                  const cqs::CQSParameters cqs_parameters(generic_input.restful_url_prefix, request);
-                  storage.template ReadWriteTransaction<current::locks::MutexLockStatus::AlreadyLocked>(
-                              // TODO(dkorolev): Revisit this as Owned/Borrowed are the organic part of Storage.
-                              // Capture local variables by value for safe async transactions.
-                              [&f_run_command, handler, cqs_parameters, type_erased_command, ctx](
-                                  mutable_fields_t fields) -> Response {
-                                return handler.RunCommand(
-                                    ctx, f_run_command, fields, std::move(type_erased_command), cqs_parameters);
-                              },
-                              std::move(request)).Detach();
-                });
+            handler.Enter(std::move(request),
+                          ctx,
+                          // Capture by reference since this lambda is run synchronously.
+                          [&handler, &f_run_command, &generic_input, &type_erased_command, &ctx](Request request) {
+                            STORAGE_IMPL& storage = generic_input.storage;
+                            const cqs::CQSParameters cqs_parameters(generic_input.restful_url_prefix, request);
+                            storage
+                                .template ReadWriteTransaction<current::locks::MutexLockStatus::AlreadyLocked>(
+                                    // TODO(dkorolev): Revisit this as Owned/Borrowed are the organic part of Storage.
+                                    // Capture local variables by value for safe async transactions.
+                                    [&f_run_command, handler, cqs_parameters, type_erased_command, ctx](
+                                        mutable_fields_t fields) -> Response {
+                                      return handler.RunCommand(
+                                          ctx, f_run_command, fields, std::move(type_erased_command), cqs_parameters);
+                                    },
+                                    std::move(request))
+                                .Detach();
+                          });
           }
         } else {
           request(Response(cqs::CQSHandlerNotFound(), HTTPResponseCode.NotFound));
@@ -692,8 +690,8 @@ class RESTfulStorage {
   }
 };
 
-}  // namespace current::storage::rest
-}  // namespace current::storage
+}  // namespace rest
+}  // namespace storage
 }  // namespace current
 
 using current::storage::rest::RESTfulStorage;
diff --git a/storage/api_types.h b/storage/api_types.h
index 90572304c..e5ce0c87c 100644
--- a/storage/api_types.h
+++ b/storage/api_types.h
@@ -149,15 +149,15 @@ struct FieldTypeDependent : FieldTypeDependentImpl<PRIMARY_KEY_TYPE> {
           proxied_request_rref("Need resource key in the URL.\n", HTTPResponseCode.BadRequest);
         }
         // LCOV_EXCL_STOP
-        );
+    );
   }
 
   template <typename F>
   static void CallWithOptionalKeyFromURL(Request&& request_rref, F&& next) {
     FieldTypeDependentImpl<PRIMARY_KEY_TYPE>::CallWithOrWithoutKeyFromURL(
-        std::move(request_rref),
-        std::forward<F>(next),
-        [&next](Request&& proxied_request_rref) { next(std::move(proxied_request_rref), nullptr); });
+        std::move(request_rref), std::forward<F>(next), [&next](Request&& proxied_request_rref) {
+          next(std::move(proxied_request_rref), nullptr);
+        });
   }
 };
 
@@ -713,7 +713,7 @@ struct CQSParameters {
   const current::net::http::Headers& http_headers;
 };
 
-}  // namespace current::storage::rest::cqs
+}  // namespace cqs
 
 }  // namespace rest
 }  // namespace storage
diff --git a/storage/base.h b/storage/base.h
index 82d16a515..173ed65ba 100644
--- a/storage/base.h
+++ b/storage/base.h
@@ -168,7 +168,7 @@ struct TypeListMapperImpl<FIELDS, current::variadic_indexes::indexes<NS...>> {
   using result = TypeList<typename std::invoke_result_t<FIELDS, FieldInfoByIndex<NS>>::update_event_t...,
                           typename std::invoke_result_t<FIELDS, FieldInfoByIndex<NS>>::delete_event_t...>;
 #endif  // CURRENT_STORAGE_PATCH_SUPPORT
-#else  // CURRENT_FOR_CPP14
+#else   // CURRENT_FOR_CPP14
 #ifdef CURRENT_STORAGE_PATCH_SUPPORT
   using result = TypeList<typename weed::call_with_type<FIELDS, FieldInfoByIndex<NS>>::update_event_t...,
                           typename weed::call_with_type<FIELDS, FieldInfoByIndex<NS>>::delete_event_t...,
@@ -251,7 +251,7 @@ struct FieldsBase : BASE {
 // Default custom persister parameter, to enable binding Storage to a custom Stream.
 namespace persister {
 struct NoCustomPersisterParam {};
-}  // namespace current::storage::persister
+}  // namespace persister
 
 }  // namespace storage
 }  // namespace current
diff --git a/storage/container/dictionary.h b/storage/container/dictionary.h
index 3924bed10..23fe6327c 100644
--- a/storage/container/dictionary.h
+++ b/storage/container/dictionary.h
@@ -43,7 +43,8 @@ template <typename T,
 #ifdef CURRENT_STORAGE_PATCH_SUPPORT
           typename PATCH_EVENT_OR_VOID,
 #endif  // CURRENT_STORAGE_PATCH_SUPPORT
-          template <typename...> class MAP>
+          template <typename...>
+          class MAP>
 class GenericDictionary {
  public:
   using entry_t = T;
@@ -87,25 +88,22 @@ class GenericDictionary {
       const T& previous_object = map_iterator->second;
       CURRENT_ASSERT(lm_iterator != last_modified_.end());
       const auto previous_timestamp = lm_iterator->second;
-      journal_.LogMutation(UPDATE_EVENT(now, object),
-                           [this, key, previous_object, previous_timestamp]() {
-                             last_modified_[key] = previous_timestamp;
-                             map_[key] = previous_object;
-                           });
+      journal_.LogMutation(UPDATE_EVENT(now, object), [this, key, previous_object, previous_timestamp]() {
+        last_modified_[key] = previous_timestamp;
+        map_[key] = previous_object;
+      });
     } else {
       if (lm_iterator != last_modified_.end()) {
         const auto previous_timestamp = lm_iterator->second;
-        journal_.LogMutation(UPDATE_EVENT(now, object),
-                             [this, key, previous_timestamp]() {
-                               last_modified_[key] = previous_timestamp;
-                               map_.erase(key);
-                             });
+        journal_.LogMutation(UPDATE_EVENT(now, object), [this, key, previous_timestamp]() {
+          last_modified_[key] = previous_timestamp;
+          map_.erase(key);
+        });
       } else {
-        journal_.LogMutation(UPDATE_EVENT(now, object),
-                             [this, key]() {
-                               last_modified_.erase(key);
-                               map_.erase(key);
-                             });
+        journal_.LogMutation(UPDATE_EVENT(now, object), [this, key]() {
+          last_modified_.erase(key);
+          map_.erase(key);
+        });
       }
     }
     last_modified_[key] = now;
@@ -120,18 +118,17 @@ class GenericDictionary {
       const auto lm_iterator = last_modified_.find(key);
       CURRENT_ASSERT(lm_iterator != last_modified_.end());
       const auto previous_timestamp = lm_iterator->second;
-      journal_.LogMutation(DELETE_EVENT(now, previous_object),
-                           [this, key, previous_object, previous_timestamp]() {
-                             last_modified_[key] = previous_timestamp;
-                             map_[key] = previous_object;
-                           });
+      journal_.LogMutation(DELETE_EVENT(now, previous_object), [this, key, previous_object, previous_timestamp]() {
+        last_modified_[key] = previous_timestamp;
+        map_[key] = previous_object;
+      });
       last_modified_[key] = now;
       map_.erase(map_iterator);
     }
   }
 
 #ifdef CURRENT_STORAGE_PATCH_SUPPORT
-  // NOTE(dkorolev): The `patch_object` parameter should be passed by value, 
+  // NOTE(dkorolev): The `patch_object` parameter should be passed by value,
   // as otherwise it won't be valid during the possible rollback.
   template <typename E = entry_t>
   std::enable_if_t<HasPatch<E>(), bool>::type Patch(sfinae::CF<key_t> key,
@@ -179,9 +176,8 @@ class GenericDictionary {
   }
 #ifdef CURRENT_STORAGE_PATCH_SUPPORT
   struct DummyStructForNonExistentPatch {};  // Essential, as can't form a reference to `void` even if disabled.
-  void operator()(const std::conditional_t<HasPatch<entry_t>(),
-                                           PATCH_EVENT_OR_VOID,
-                                           DummyStructForNonExistentPatch>& e) {
+  void operator()(
+      const std::conditional_t<HasPatch<entry_t>(), PATCH_EVENT_OR_VOID, DummyStructForNonExistentPatch>& e) {
     auto it = map_.find(e.key);
     if (it != map_.end()) {
       last_modified_[e.key] = e.us;
@@ -264,7 +260,7 @@ struct StorageFieldTypeSelector<container::OrderedDictionary<T, E1, E2>> {
 }  // namespace storage
 }  // namespace current
 
-using current::storage::container::UnorderedDictionary;
 using current::storage::container::OrderedDictionary;
+using current::storage::container::UnorderedDictionary;
 
 #endif  // CURRENT_STORAGE_CONTAINER_DICTIONARY_H
diff --git a/storage/container/many_to_many.h b/storage/container/many_to_many.h
index 12441774d..a3343ce2c 100644
--- a/storage/container/many_to_many.h
+++ b/storage/container/many_to_many.h
@@ -46,8 +46,10 @@ template <typename T,
 #ifdef CURRENT_STORAGE_PATCH_SUPPORT
           typename PATCH_EVENT_OR_VOID,
 #endif  // CURRENT_STORAGE_PATCH_SUPPORT
-          template <typename...> class ROW_MAP,
-          template <typename...> class COL_MAP>
+          template <typename...>
+          class ROW_MAP,
+          template <typename...>
+          class COL_MAP>
 class GenericManyToMany {
  public:
   using entry_t = T;
@@ -83,21 +85,19 @@ class GenericManyToMany {
       const T& previous_object = *(map_cit->second);
       CURRENT_ASSERT(lm_cit != last_modified_.end());
       const auto previous_timestamp = lm_cit->second;
-      journal_.LogMutation(UPDATE_EVENT(now, object),
-                           [this, key, previous_object, previous_timestamp]() {
-                             DoUpdateWithLastModified(previous_timestamp, key, previous_object);
-                           });
+      journal_.LogMutation(UPDATE_EVENT(now, object), [this, key, previous_object, previous_timestamp]() {
+        DoUpdateWithLastModified(previous_timestamp, key, previous_object);
+      });
     } else {
       if (lm_cit != last_modified_.end()) {
         const auto previous_timestamp = lm_cit->second;
         journal_.LogMutation(UPDATE_EVENT(now, object),
                              [this, key, previous_timestamp]() { DoEraseWithLastModified(previous_timestamp, key); });
       } else {
-        journal_.LogMutation(UPDATE_EVENT(now, object),
-                             [this, key]() {
-                               last_modified_.erase(key);
-                               DoEraseWithoutTouchingLastModified(key);
-                             });
+        journal_.LogMutation(UPDATE_EVENT(now, object), [this, key]() {
+          last_modified_.erase(key);
+          DoEraseWithoutTouchingLastModified(key);
+        });
       }
     }
     DoUpdateWithLastModified(now, key, object);
@@ -112,10 +112,9 @@ class GenericManyToMany {
       const auto lm_cit = last_modified_.find(key);
       CURRENT_ASSERT(lm_cit != last_modified_.end());
       const auto previous_timestamp = lm_cit->second;
-      journal_.LogMutation(DELETE_EVENT(now, previous_object),
-                           [this, key, previous_object, previous_timestamp]() {
-                             DoUpdateWithLastModified(previous_timestamp, key, previous_object);
-                           });
+      journal_.LogMutation(DELETE_EVENT(now, previous_object), [this, key, previous_object, previous_timestamp]() {
+        DoUpdateWithLastModified(previous_timestamp, key, previous_object);
+      });
       DoEraseWithLastModified(now, key);
     }
   }
@@ -257,36 +256,20 @@ class GenericManyToMany {
 #ifdef CURRENT_STORAGE_PATCH_SUPPORT
 
 template <typename T, typename UPDATE_EVENT, typename DELETE_EVENT, typename PATCH_EVENT_OR_VOID>
-using UnorderedManyToUnorderedMany = GenericManyToMany<T, 
-                                                       UPDATE_EVENT,
-                                                       DELETE_EVENT,
-                                                       PATCH_EVENT_OR_VOID,
-                                                       Unordered,
-                                                       Unordered>;
+using UnorderedManyToUnorderedMany =
+    GenericManyToMany<T, UPDATE_EVENT, DELETE_EVENT, PATCH_EVENT_OR_VOID, Unordered, Unordered>;
 
 template <typename T, typename UPDATE_EVENT, typename DELETE_EVENT, typename PATCH_EVENT_OR_VOID>
-using OrderedManyToOrderedMany = GenericManyToMany<T,
-                                                   UPDATE_EVENT,
-                                                   DELETE_EVENT,
-                                                   PATCH_EVENT_OR_VOID,
-                                                   Ordered,
-                                                   Ordered>;
+using OrderedManyToOrderedMany =
+    GenericManyToMany<T, UPDATE_EVENT, DELETE_EVENT, PATCH_EVENT_OR_VOID, Ordered, Ordered>;
 
 template <typename T, typename UPDATE_EVENT, typename DELETE_EVENT, typename PATCH_EVENT_OR_VOID>
-using UnorderedManyToOrderedMany = GenericManyToMany<T,
-                                                     UPDATE_EVENT,
-                                                     DELETE_EVENT,
-                                                     PATCH_EVENT_OR_VOID,
-                                                     Unordered,
-                                                     Ordered>;
+using UnorderedManyToOrderedMany =
+    GenericManyToMany<T, UPDATE_EVENT, DELETE_EVENT, PATCH_EVENT_OR_VOID, Unordered, Ordered>;
 
 template <typename T, typename UPDATE_EVENT, typename DELETE_EVENT, typename PATCH_EVENT_OR_VOID>
-using OrderedManyToUnorderedMany = GenericManyToMany<T,
-                                                     UPDATE_EVENT,
-                                                     DELETE_EVENT,
-                                                     PATCH_EVENT_OR_VOID,
-                                                     Ordered,
-                                                     Unordered>;
+using OrderedManyToUnorderedMany =
+    GenericManyToMany<T, UPDATE_EVENT, DELETE_EVENT, PATCH_EVENT_OR_VOID, Ordered, Unordered>;
 
 #else
 
@@ -355,9 +338,9 @@ struct StorageFieldTypeSelector<container::OrderedManyToUnorderedMany<T, E1, E2>
 }  // namespace storage
 }  // namespace current
 
-using current::storage::container::UnorderedManyToUnorderedMany;
 using current::storage::container::OrderedManyToOrderedMany;
-using current::storage::container::UnorderedManyToOrderedMany;
 using current::storage::container::OrderedManyToUnorderedMany;
+using current::storage::container::UnorderedManyToOrderedMany;
+using current::storage::container::UnorderedManyToUnorderedMany;
 
 #endif  // CURRENT_STORAGE_CONTAINER_MANY_TO_MANY_H
diff --git a/storage/container/one_to_many.h b/storage/container/one_to_many.h
index d3e9b41fc..acad6c90c 100644
--- a/storage/container/one_to_many.h
+++ b/storage/container/one_to_many.h
@@ -46,8 +46,10 @@ template <typename T,
 #ifdef CURRENT_STORAGE_PATCH_SUPPORT
           typename PATCH_EVENT_OR_VOID,
 #endif  // CURRENT_STORAGE_PATCH_SUPPORT
-          template <typename...> class ROW_MAP,
-          template <typename...> class COL_MAP>
+          template <typename...>
+          class ROW_MAP,
+          template <typename...>
+          class COL_MAP>
 class GenericOneToMany {
  public:
   using entry_t = T;
@@ -85,10 +87,9 @@ class GenericOneToMany {
       const T& previous_object = *(map_cit->second);
       CURRENT_ASSERT(lm_cit != last_modified_.end());
       const auto previous_timestamp = lm_cit->second;
-      journal_.LogMutation(UPDATE_EVENT(now, object),
-                           [this, key, previous_object, previous_timestamp]() {
-                             DoUpdateWithLastModified(previous_timestamp, key, previous_object);
-                           });
+      journal_.LogMutation(UPDATE_EVENT(now, object), [this, key, previous_object, previous_timestamp]() {
+        DoUpdateWithLastModified(previous_timestamp, key, previous_object);
+      });
     } else {
       const auto transposed_cit = transposed_.find(col);
       if (transposed_cit != transposed_.end()) {
@@ -110,11 +111,10 @@ class GenericOneToMany {
         journal_.LogMutation(UPDATE_EVENT(now, object),
                              [this, key, previous_timestamp]() { DoEraseWithLastModified(previous_timestamp, key); });
       } else {
-        journal_.LogMutation(UPDATE_EVENT(now, object),
-                             [this, key]() {
-                               last_modified_.erase(key);
-                               DoEraseWithoutTouchingLastModified(key);
-                             });
+        journal_.LogMutation(UPDATE_EVENT(now, object), [this, key]() {
+          last_modified_.erase(key);
+          DoEraseWithoutTouchingLastModified(key);
+        });
       }
     }
     DoUpdateWithLastModified(now, key, object);
@@ -129,10 +129,9 @@ class GenericOneToMany {
       const auto lm_cit = last_modified_.find(key);
       CURRENT_ASSERT(lm_cit != last_modified_.end());
       const auto previous_timestamp = lm_cit->second;
-      journal_.LogMutation(DELETE_EVENT(now, previous_object),
-                           [this, key, previous_object, previous_timestamp]() {
-                             DoUpdateWithLastModified(previous_timestamp, key, previous_object);
-                           });
+      journal_.LogMutation(DELETE_EVENT(now, previous_object), [this, key, previous_object, previous_timestamp]() {
+        DoUpdateWithLastModified(previous_timestamp, key, previous_object);
+      });
       DoEraseWithLastModified(now, key);
     }
   }
@@ -147,10 +146,9 @@ class GenericOneToMany {
       const auto lm_cit = last_modified_.find(key);
       CURRENT_ASSERT(lm_cit != last_modified_.end());
       const auto previous_timestamp = lm_cit->second;
-      journal_.LogMutation(DELETE_EVENT(now, previous_object),
-                           [this, key, previous_object, previous_timestamp]() {
-                             DoUpdateWithLastModified(previous_timestamp, key, previous_object);
-                           });
+      journal_.LogMutation(DELETE_EVENT(now, previous_object), [this, key, previous_object, previous_timestamp]() {
+        DoUpdateWithLastModified(previous_timestamp, key, previous_object);
+      });
       DoEraseWithLastModified(now, key);
     }
   }
@@ -295,36 +293,19 @@ class GenericOneToMany {
 #ifdef CURRENT_STORAGE_PATCH_SUPPORT
 
 template <typename T, typename UPDATE_EVENT, typename DELETE_EVENT, typename PATCH_EVENT_OR_VOID>
-using UnorderedOneToUnorderedMany = GenericOneToMany<T,
-                                                     UPDATE_EVENT,
-                                                     DELETE_EVENT,
-                                                     PATCH_EVENT_OR_VOID,
-                                                     Unordered,
-                                                     Unordered>;
+using UnorderedOneToUnorderedMany =
+    GenericOneToMany<T, UPDATE_EVENT, DELETE_EVENT, PATCH_EVENT_OR_VOID, Unordered, Unordered>;
 
 template <typename T, typename UPDATE_EVENT, typename DELETE_EVENT, typename PATCH_EVENT_OR_VOID>
-using OrderedOneToOrderedMany = GenericOneToMany<T,
-                                                 UPDATE_EVENT,
-                                                 DELETE_EVENT,
-                                                 PATCH_EVENT_OR_VOID,
-                                                 Ordered,
-                                                 Ordered>;
+using OrderedOneToOrderedMany = GenericOneToMany<T, UPDATE_EVENT, DELETE_EVENT, PATCH_EVENT_OR_VOID, Ordered, Ordered>;
 
 template <typename T, typename UPDATE_EVENT, typename DELETE_EVENT, typename PATCH_EVENT_OR_VOID>
-using UnorderedOneToOrderedMany = GenericOneToMany<T,
-                                                   UPDATE_EVENT,
-                                                   DELETE_EVENT,
-                                                   PATCH_EVENT_OR_VOID,
-                                                   Unordered,
-                                                   Ordered>;
+using UnorderedOneToOrderedMany =
+    GenericOneToMany<T, UPDATE_EVENT, DELETE_EVENT, PATCH_EVENT_OR_VOID, Unordered, Ordered>;
 
 template <typename T, typename UPDATE_EVENT, typename DELETE_EVENT, typename PATCH_EVENT_OR_VOID>
-using OrderedOneToUnorderedMany = GenericOneToMany<T,
-                                                   UPDATE_EVENT,
-                                                   DELETE_EVENT,
-                                                   PATCH_EVENT_OR_VOID,
-                                                   Ordered,
-                                                   Unordered>;
+using OrderedOneToUnorderedMany =
+    GenericOneToMany<T, UPDATE_EVENT, DELETE_EVENT, PATCH_EVENT_OR_VOID, Ordered, Unordered>;
 
 #else
 
@@ -393,9 +374,9 @@ struct StorageFieldTypeSelector<container::OrderedOneToUnorderedMany<T, E1, E2>>
 }  // namespace storage
 }  // namespace current
 
-using current::storage::container::UnorderedOneToUnorderedMany;
 using current::storage::container::OrderedOneToOrderedMany;
-using current::storage::container::UnorderedOneToOrderedMany;
 using current::storage::container::OrderedOneToUnorderedMany;
+using current::storage::container::UnorderedOneToOrderedMany;
+using current::storage::container::UnorderedOneToUnorderedMany;
 
 #endif  // CURRENT_STORAGE_CONTAINER_ONE_TO_MANY_H
diff --git a/storage/container/one_to_one.h b/storage/container/one_to_one.h
index 7bf402554..4fa24ede0 100644
--- a/storage/container/one_to_one.h
+++ b/storage/container/one_to_one.h
@@ -44,9 +44,11 @@ template <typename T,
           typename DELETE_EVENT,
 #ifdef CURRENT_STORAGE_PATCH_SUPPORT
           typename PATCH_EVENT_OR_VOID,
-#endif // CURRENT_STORAGE_PATCH_SUPPORT
-          template <typename...> class ROW_MAP,
-          template <typename...> class COL_MAP>
+#endif  // CURRENT_STORAGE_PATCH_SUPPORT
+          template <typename...>
+          class ROW_MAP,
+          template <typename...>
+          class COL_MAP>
 class GenericOneToOne {
  public:
   using entry_t = T;
@@ -80,10 +82,9 @@ class GenericOneToOne {
       const T& previous_object = *(map_cit->second);
       CURRENT_ASSERT(lm_cit != last_modified_.end());
       const auto previous_timestamp = lm_cit->second;
-      journal_.LogMutation(UPDATE_EVENT(now, object),
-                           [this, key, previous_object, previous_timestamp]() {
-                             DoUpdateWithLastModified(previous_timestamp, key, previous_object);
-                           });
+      journal_.LogMutation(UPDATE_EVENT(now, object), [this, key, previous_object, previous_timestamp]() {
+        DoUpdateWithLastModified(previous_timestamp, key, previous_object);
+      });
     } else {
       const auto cit_row = forward_.find(row);
       const auto cit_col = transposed_.find(col);
@@ -133,11 +134,10 @@ class GenericOneToOne {
         journal_.LogMutation(UPDATE_EVENT(now, object),
                              [this, key, previous_timestamp]() { DoEraseWithLastModified(previous_timestamp, key); });
       } else {
-        journal_.LogMutation(UPDATE_EVENT(now, object),
-                             [this, key]() {
-                               last_modified_.erase(key);
-                               DoEraseWithoutTouchingLastModified(key);
-                             });
+        journal_.LogMutation(UPDATE_EVENT(now, object), [this, key]() {
+          last_modified_.erase(key);
+          DoEraseWithoutTouchingLastModified(key);
+        });
       }
     }
     DoUpdateWithLastModified(now, key, object);
@@ -152,10 +152,9 @@ class GenericOneToOne {
       const auto lm_cit = last_modified_.find(key);
       CURRENT_ASSERT(lm_cit != last_modified_.end());
       const auto previous_timestamp = lm_cit->second;
-      journal_.LogMutation(DELETE_EVENT(now, previous_object),
-                           [this, key, previous_object, previous_timestamp]() {
-                             DoUpdateWithLastModified(previous_timestamp, key, previous_object);
-                           });
+      journal_.LogMutation(DELETE_EVENT(now, previous_object), [this, key, previous_object, previous_timestamp]() {
+        DoUpdateWithLastModified(previous_timestamp, key, previous_object);
+      });
       DoEraseWithLastModified(now, key);
     }
   }
@@ -170,10 +169,9 @@ class GenericOneToOne {
       const auto lm_cit = last_modified_.find(key);
       CURRENT_ASSERT(lm_cit != last_modified_.end());
       const auto previous_timestamp = lm_cit->second;
-      journal_.LogMutation(DELETE_EVENT(now, previous_object),
-                           [this, key, previous_object, previous_timestamp]() {
-                             DoUpdateWithLastModified(previous_timestamp, key, previous_object);
-                           });
+      journal_.LogMutation(DELETE_EVENT(now, previous_object), [this, key, previous_object, previous_timestamp]() {
+        DoUpdateWithLastModified(previous_timestamp, key, previous_object);
+      });
       DoEraseWithLastModified(now, key);
     }
   }
@@ -187,10 +185,9 @@ class GenericOneToOne {
       const auto lm_cit = last_modified_.find(key);
       CURRENT_ASSERT(lm_cit != last_modified_.end());
       const auto previous_timestamp = lm_cit->second;
-      journal_.LogMutation(DELETE_EVENT(now, previous_object),
-                           [this, key, previous_object, previous_timestamp]() {
-                             DoUpdateWithLastModified(previous_timestamp, key, previous_object);
-                           });
+      journal_.LogMutation(DELETE_EVENT(now, previous_object), [this, key, previous_object, previous_timestamp]() {
+        DoUpdateWithLastModified(previous_timestamp, key, previous_object);
+      });
       DoEraseWithLastModified(now, key);
     }
   }
@@ -292,36 +289,19 @@ class GenericOneToOne {
 #ifdef CURRENT_STORAGE_PATCH_SUPPORT
 
 template <typename T, typename UPDATE_EVENT, typename DELETE_EVENT, typename PATCH_EVENT_OR_VOID>
-using UnorderedOneToUnorderedOne = GenericOneToOne<T,
-                                                   UPDATE_EVENT,
-                                                   DELETE_EVENT,
-                                                   PATCH_EVENT_OR_VOID,
-                                                   Unordered,
-                                                   Unordered>;
+using UnorderedOneToUnorderedOne =
+    GenericOneToOne<T, UPDATE_EVENT, DELETE_EVENT, PATCH_EVENT_OR_VOID, Unordered, Unordered>;
 
 template <typename T, typename UPDATE_EVENT, typename DELETE_EVENT, typename PATCH_EVENT_OR_VOID>
-using OrderedOneToOrderedOne = GenericOneToOne<T,
-                                               UPDATE_EVENT,
-                                               DELETE_EVENT,
-                                               PATCH_EVENT_OR_VOID,
-                                               Ordered,
-                                               Ordered>;
+using OrderedOneToOrderedOne = GenericOneToOne<T, UPDATE_EVENT, DELETE_EVENT, PATCH_EVENT_OR_VOID, Ordered, Ordered>;
 
 template <typename T, typename UPDATE_EVENT, typename DELETE_EVENT, typename PATCH_EVENT_OR_VOID>
-using UnorderedOneToOrderedOne = GenericOneToOne<T,
-                                                 UPDATE_EVENT,
-                                                 DELETE_EVENT,
-                                                 PATCH_EVENT_OR_VOID,
-                                                 Unordered,
-                                                 Ordered>;
+using UnorderedOneToOrderedOne =
+    GenericOneToOne<T, UPDATE_EVENT, DELETE_EVENT, PATCH_EVENT_OR_VOID, Unordered, Ordered>;
 
 template <typename T, typename UPDATE_EVENT, typename DELETE_EVENT, typename PATCH_EVENT_OR_VOID>
-using OrderedOneToUnorderedOne = GenericOneToOne<T,
-                                                 UPDATE_EVENT,
-                                                 DELETE_EVENT,
-                                                 PATCH_EVENT_OR_VOID,
-                                                 Ordered,
-                                                 Unordered>;
+using OrderedOneToUnorderedOne =
+    GenericOneToOne<T, UPDATE_EVENT, DELETE_EVENT, PATCH_EVENT_OR_VOID, Ordered, Unordered>;
 
 #else
 
@@ -390,9 +370,9 @@ struct StorageFieldTypeSelector<container::OrderedOneToUnorderedOne<T, E1, E2>>
 }  // namespace storage
 }  // namespace current
 
-using current::storage::container::UnorderedOneToUnorderedOne;
 using current::storage::container::OrderedOneToOrderedOne;
-using current::storage::container::UnorderedOneToOrderedOne;
 using current::storage::container::OrderedOneToUnorderedOne;
+using current::storage::container::UnorderedOneToOrderedOne;
+using current::storage::container::UnorderedOneToUnorderedOne;
 
 #endif  // CURRENT_STORAGE_CONTAINER_ONE_TO_ONE_H
diff --git a/storage/container/sfinae.h b/storage/container/sfinae.h
index e745c7cfa..9ff0d47b7 100644
--- a/storage/container/sfinae.h
+++ b/storage/container/sfinae.h
@@ -250,7 +250,7 @@ void SetCol(ENTRY& entry, typename col_accessor_t<ENTRY>::cf_col_t col) {
 
 #ifdef CURRENT_STORAGE_PATCH_SUPPORT
 
-CURRENT_STRUCT(DummyPatchObjectForNonPatchableEntries) {};
+CURRENT_STRUCT(DummyPatchObjectForNonPatchableEntries){};
 
 template <bool, class>
 struct patch_object_t_accessor {
diff --git a/storage/exceptions.h b/storage/exceptions.h
index e6e0bc72d..2043b9e6a 100644
--- a/storage/exceptions.h
+++ b/storage/exceptions.h
@@ -76,7 +76,7 @@ struct StorageInGracefulShutdownException : InGracefulShutdownException {
   using InGracefulShutdownException::InGracefulShutdownException;
 };
 
-}  // namespace current::storage
+}  // namespace storage
 }  // namespace current
 
 #define CURRENT_STORAGE_THROW_ROLLBACK() throw ::current::storage::StorageRollbackExceptionWithNoValue()
diff --git a/storage/persister/stream.h b/storage/persister/stream.h
index 3a7627dbe..595a50de5 100644
--- a/storage/persister/stream.h
+++ b/storage/persister/stream.h
@@ -43,9 +43,8 @@ class StreamStreamPersisterImpl final {
  public:
   using variant_t = MUTATIONS_VARIANT;
   using transaction_t = Transaction<variant_t>;
-  using stream_entry_t = std::conditional_t<std::is_same_v<STREAM_RECORD_TYPE, NoCustomPersisterParam>,
-                                            transaction_t,
-                                            STREAM_RECORD_TYPE>;
+  using stream_entry_t =
+      std::conditional_t<std::is_same_v<STREAM_RECORD_TYPE, NoCustomPersisterParam>, transaction_t, STREAM_RECORD_TYPE>;
   using stream_t = stream::Stream<stream_entry_t, UNDERLYING_PERSISTER>;
   using fields_update_function_t = std::function<void(const variant_t&)>;
 
@@ -140,10 +139,10 @@ class StreamStreamPersisterImpl final {
   }
 
   void ExposeRawLogViaHTTP(uint16_t port, const std::string& route) {
-    handlers_scope_ += HTTP(current::net::BarePort(port)).Register(
-        route,
-        URLPathArgs::CountMask::None | URLPathArgs::CountMask::One,
-        [this](Request r) { (*Borrowed<stream_t>(stream_))(std::move(r)); });
+    handlers_scope_ += HTTP(current::net::BarePort(port))
+                           .Register(route,
+                                     URLPathArgs::CountMask::None | URLPathArgs::CountMask::One,
+                                     [this](Request r) { (*Borrowed<stream_t>(stream_))(std::move(r)); });
   }
 
   Borrowed<stream_t> BorrowStream() const { return stream_; }
diff --git a/storage/rest/hypermedia.h b/storage/rest/hypermedia.h
index b583cdb9f..a0aa1bdab 100644
--- a/storage/rest/hypermedia.h
+++ b/storage/rest/hypermedia.h
@@ -175,7 +175,7 @@ struct HypermediaResponseFormatter {
   }
 };
 
-}  // namespace current::storage::rest::hypermedia
+}  // namespace hypermedia
 
 struct Hypermedia : generic::Structured<hypermedia::HypermediaResponseFormatter> {
   using STRUCTURED = generic::Structured<hypermedia::HypermediaResponseFormatter>;
@@ -205,8 +205,8 @@ struct Hypermedia : generic::Structured<hypermedia::HypermediaResponseFormatter>
   };
 };
 
-}  // namespace current::storage::rest
-}  // namespace current::storage
+}  // namespace rest
+}  // namespace storage
 }  // namespace current
 
 #endif  // CURRENT_STORAGE_REST_HYPERMEDIA_H
diff --git a/storage/rest/plain.h b/storage/rest/plain.h
index 8bc123223..be9652280 100644
--- a/storage/rest/plain.h
+++ b/storage/rest/plain.h
@@ -274,13 +274,12 @@ struct Plain {
       explicit LanguageIterator(registerer_t registerer) : registerer(registerer) {}
       template <current::reflection::Language LANGUAGE>
       void PerLanguage() {
-        registerer('.' + current::ToString(LANGUAGE),
-                   [](Request r) {
-                     // TODO(dkorolev): Add caching one day.
-                     reflection::StructSchema underlying_type_schema;
-                     underlying_type_schema.AddType<entry_t>();
-                     r(underlying_type_schema.GetSchemaInfo().Describe<LANGUAGE>());
-                   });
+        registerer('.' + current::ToString(LANGUAGE), [](Request r) {
+          // TODO(dkorolev): Add caching one day.
+          reflection::StructSchema underlying_type_schema;
+          underlying_type_schema.AddType<entry_t>();
+          r(underlying_type_schema.GetSchemaInfo().Describe<LANGUAGE>());
+        });
       }
     };
 
@@ -330,9 +329,9 @@ struct Plain {
   // LCOV_EXCL_STOP
 };
 
-}  // namespace current::storage::rest::plain
-}  // namespace current::storage::rest
-}  // namespace current::storage
+}  // namespace plain
+}  // namespace rest
+}  // namespace storage
 }  // namespace current
 
 #endif  // CURRENT_STORAGE_REST_PLAIN_H
diff --git a/storage/rest/simple.h b/storage/rest/simple.h
index ca98f5f93..29fbd45bc 100644
--- a/storage/rest/simple.h
+++ b/storage/rest/simple.h
@@ -59,12 +59,12 @@ struct SimpleResponseFormatter {
   }
 };
 
-}  // namespace current::storage::rest::simple
+}  // namespace simple
 
 using Simple = generic::Structured<simple::SimpleResponseFormatter>;
 
-}  // namespace current::storage::rest
-}  // namespace current::storage
+}  // namespace rest
+}  // namespace storage
 }  // namespace current
 
 #endif  // CURRENT_STORAGE_REST_SIMPLE_H
diff --git a/storage/rest/structured.h b/storage/rest/structured.h
index 28532ed4a..c0f37860b 100644
--- a/storage/rest/structured.h
+++ b/storage/rest/structured.h
@@ -57,24 +57,20 @@ struct Structured {
 
   template <class INPUT>
   static void RegisterTopLevel(const INPUT& input) {
-    input.scope += HTTP(input.port)
-                       .Register(input.route_prefix,
-                                 [input](Request request) {
-                                   const bool up = input.up_status;
-                                   RESTTopLevel response(input.restful_url_prefix, up);
-                                   for (const auto& f : input.field_names) {
-                                     response.url_data[f] =
-                                         input.restful_url_prefix + '/' + kRESTfulDataURLComponent + '/' + f;
-                                   }
-                                   request(response, up ? HTTPResponseCode.OK : HTTPResponseCode.ServiceUnavailable);
-                                 });
+    input.scope += HTTP(input.port).Register(input.route_prefix, [input](Request request) {
+      const bool up = input.up_status;
+      RESTTopLevel response(input.restful_url_prefix, up);
+      for (const auto& f : input.field_names) {
+        response.url_data[f] = input.restful_url_prefix + '/' + kRESTfulDataURLComponent + '/' + f;
+      }
+      request(response, up ? HTTPResponseCode.OK : HTTPResponseCode.ServiceUnavailable);
+    });
     input.scope +=
         HTTP(input.port)
-            .Register(input.route_prefix == "/" ? "/status" : input.route_prefix + "/status",
-                      [input](Request request) {
-                        const bool up = input.up_status;
-                        request(RESTStatus(up), up ? HTTPResponseCode.OK : HTTPResponseCode.ServiceUnavailable);
-                      });
+            .Register(input.route_prefix == "/" ? "/status" : input.route_prefix + "/status", [input](Request request) {
+              const bool up = input.up_status;
+              request(RESTStatus(up), up ? HTTPResponseCode.OK : HTTPResponseCode.ServiceUnavailable);
+            });
   }
 
   // Returns `false` on error.
@@ -260,10 +256,9 @@ struct Structured {
         // Pass the same `url` twice, as the collection ("specific row/col") and pagination have the same base URL.
         const std::string url = input.restful_url_prefix + '/' + kRESTfulDataURLComponent + '/' + input.field_name +
                                 '.' + MatrixContainerProxy<KEY_COMPLETENESS>::PartialKeySuffix();
-        return RESPONSE_FORMATTER::template BuildResponseWithCollection<PARTICULAR_FIELD,
-                                                                        ENTRY,
-                                                                        RESTSubCollection<ENTRY>>(
-            context, url, url, GenericMatrixIterator<KEY_COMPLETENESS, FIELD_SEMANTICS>::RowsOrCols(input.field));
+        return RESPONSE_FORMATTER::
+            template BuildResponseWithCollection<PARTICULAR_FIELD, ENTRY, RESTSubCollection<ENTRY>>(
+                context, url, url, GenericMatrixIterator<KEY_COMPLETENESS, FIELD_SEMANTICS>::RowsOrCols(input.field));
       }
     }
 
@@ -514,9 +509,9 @@ struct Structured {
   }
 };
 
-}  // namespace current::storage::rest::generic
-}  // namespace current::storage::rest
-}  // namespace current::storage
+}  // namespace generic
+}  // namespace rest
+}  // namespace storage
 }  // namespace current
 
 #endif  // CURRENT_STORAGE_REST_STRUCTURED_H
diff --git a/storage/rest/types.h b/storage/rest/types.h
index dbe1bd958..c7e8fcbdb 100644
--- a/storage/rest/types.h
+++ b/storage/rest/types.h
@@ -42,8 +42,8 @@ CURRENT_STRUCT(RESTTopLevel) {
   CURRENT_FIELD(url_data, (std::map<std::string, std::string>));
   CURRENT_FIELD(up, bool);
 
-  CURRENT_CONSTRUCTOR(RESTTopLevel)(const std::string& url_prefix = "", bool up = false)
-      : url(url_prefix), url_status(url_prefix + "/status"), up(up) {}
+  CURRENT_CONSTRUCTOR(RESTTopLevel)
+  (const std::string& url_prefix = "", bool up = false) : url(url_prefix), url_status(url_prefix + "/status"), up(up) {}
 };
 
 CURRENT_STRUCT(RESTStatus) {
@@ -60,7 +60,8 @@ CURRENT_STRUCT(RESTError) {
 
   CURRENT_DEFAULT_CONSTRUCTOR(RESTError) {}
   CURRENT_CONSTRUCTOR(RESTError)(const std::string& name, const std::string& message) : name(name), message(message) {}
-  CURRENT_CONSTRUCTOR(RESTError)(const std::string& name, const std::string& message, const details_t& details)
+  CURRENT_CONSTRUCTOR(RESTError)
+  (const std::string& name, const std::string& message, const details_t& details)
       : name(name), message(message), details(details) {}
 };
 
@@ -76,9 +77,10 @@ CURRENT_STRUCT(RESTGenericResponse) {
 
   CURRENT_DEFAULT_CONSTRUCTOR(RESTGenericResponse) {}
   CURRENT_CONSTRUCTOR(RESTGenericResponse)(bool success) : success(success) {}
-  CURRENT_CONSTRUCTOR(RESTGenericResponse)(bool success, const std::string& message)
-      : success(success), message(message) {}
-  CURRENT_CONSTRUCTOR(RESTGenericResponse)(bool success, const std::string& message, const RESTError& error)
+  CURRENT_CONSTRUCTOR(RESTGenericResponse)
+  (bool success, const std::string& message) : success(success), message(message) {}
+  CURRENT_CONSTRUCTOR(RESTGenericResponse)
+  (bool success, const std::string& message, const RESTError& error)
       : success(success), message(message), error(error) {}
   CURRENT_CONSTRUCTOR(RESTGenericResponse)(bool success, const RESTError& error) : success(success), error(error) {}
 };
@@ -88,14 +90,14 @@ CURRENT_STRUCT(RESTResourceUpdateResponse, RESTGenericResponse) {
 
   CURRENT_CONSTRUCTOR(RESTResourceUpdateResponse)(bool success = true) : SUPER(success) {}
   CURRENT_CONSTRUCTOR(RESTResourceUpdateResponse)(bool success, const std::string& message) : SUPER(success, message) {}
-  CURRENT_CONSTRUCTOR(RESTResourceUpdateResponse)(
-      bool success, const std::string& message, const std::string& resource_url)
+  CURRENT_CONSTRUCTOR(RESTResourceUpdateResponse)
+  (bool success, const std::string& message, const std::string& resource_url)
       : SUPER(success, message), resource_url(resource_url) {}
-  CURRENT_CONSTRUCTOR(RESTResourceUpdateResponse)(bool success, const std::string& message, const RESTError& error)
-      : SUPER(success, message, error) {}
+  CURRENT_CONSTRUCTOR(RESTResourceUpdateResponse)
+  (bool success, const std::string& message, const RESTError& error) : SUPER(success, message, error) {}
 };
 
-}  // namespace current::storage::rest::generic
+}  // namespace generic
 
 namespace helpers {
 
@@ -159,7 +161,7 @@ inline generic::RESTError ResourceWasModifiedError(const std::string& message,
                              {"resource_last_modified_us", ToString(last_modified)}});
 }
 
-}  // namespace current::storage::rest::helpers
+}  // namespace helpers
 
 namespace simple {
 
@@ -178,13 +180,13 @@ CURRENT_STRUCT(SimpleRESTContainerResponse, generic::RESTGenericResponse) {
   CURRENT_FIELD(data, std::vector<std::string>);
 
   CURRENT_DEFAULT_CONSTRUCTOR(SimpleRESTContainerResponse) : SUPER(true) {}
-  CURRENT_CONSTRUCTOR(SimpleRESTContainerResponse)(const std::string& url, const std::vector<std::string>& data)
-      : SUPER(true), url(url), data(data) {}
-  CURRENT_CONSTRUCTOR(SimpleRESTContainerResponse)(const std::string& url, std::vector<std::string>&& data)
-      : SUPER(true), url(url), data(std::move(data)) {}
+  CURRENT_CONSTRUCTOR(SimpleRESTContainerResponse)
+  (const std::string& url, const std::vector<std::string>& data) : SUPER(true), url(url), data(data) {}
+  CURRENT_CONSTRUCTOR(SimpleRESTContainerResponse)
+  (const std::string& url, std::vector<std::string>&& data) : SUPER(true), url(url), data(std::move(data)) {}
 };
 
-}  // namespace current::storage::rest:simple
+}  // namespace simple
 
 namespace hypermedia {
 
@@ -205,8 +207,8 @@ CURRENT_STRUCT_T(HypermediaRESTSingleRecordResponse) {
   CURRENT_FIELD(data, T);
 
   CURRENT_DEFAULT_CONSTRUCTOR_T(HypermediaRESTSingleRecordResponse) {}
-  CURRENT_CONSTRUCTOR_T(HypermediaRESTSingleRecordResponse)(
-      const std::string& url, const std::string& url_directory, const T& data)
+  CURRENT_CONSTRUCTOR_T(HypermediaRESTSingleRecordResponse)
+  (const std::string& url, const std::string& url_directory, const T& data)
       : url(url), url_full(url + "?full"), url_brief(url + "?brief"), url_directory(url_directory), data(data) {}
 };
 
@@ -266,7 +268,8 @@ CURRENT_STRUCT_T(HypermediaRESTDetailedExportEntry) {
   CURRENT_FIELD(timestamp_us, std::chrono::microseconds, std::chrono::microseconds(0));
   CURRENT_FIELD(timestamp_http, std::string);
   CURRENT_FIELD(data, typename DetailedExportEntryHelperWrapper<T>::entry_cref_t);
-  CURRENT_CONSTRUCTOR_T(HypermediaRESTDetailedExportEntry)(std::chrono::microseconds timestamp, const T& helper)
+  CURRENT_CONSTRUCTOR_T(HypermediaRESTDetailedExportEntry)
+  (std::chrono::microseconds timestamp, const T& helper)
       : key(helper.key),
         timestamp_us(timestamp),
         timestamp_http(FormatDateTimeAsIMFFix(timestamp)),
@@ -275,7 +278,7 @@ CURRENT_STRUCT_T(HypermediaRESTDetailedExportEntry) {
 
 using HypermediaRESTGenericResponse = generic::RESTGenericResponse;
 
-}  // namespace current::storage::rest:hypermedia
+}  // namespace hypermedia
 
 using HypermediaRESTError = hypermedia::HypermediaRESTError;
 using HypermediaRESTStatus = hypermedia::HypermediaRESTStatus;
diff --git a/storage/semantics.h b/storage/semantics.h
index 94825815b..c23347167 100644
--- a/storage/semantics.h
+++ b/storage/semantics.h
@@ -43,17 +43,17 @@ namespace semantics {
 namespace rest {
 struct RESTWithSingleKey {};
 struct RESTWithPairedKey {};
-}  // namespace current::storage::semantics::rest
+}  // namespace rest
 
 namespace primary_key {
 struct Key {};
 struct RowCol {};
-}  // namespace current::storage::semantics::primary_key
+}  // namespace primary_key
 
 namespace matrix_dimension_type {
 struct IterableRange {};
 struct SingleElement {};
-}  // namespace current::storage::semantics::matrix_dimension_type
+}  // namespace matrix_dimension_type
 
 struct Dictionary {
   using url_key_t = std::string;
@@ -94,7 +94,7 @@ struct PartialRowKey {
 struct PartialColKey {
   using completeness_family_t = MatrixHalfKey;
 };
-}  // namespace current::storage::semantics::key_completeness
+}  // namespace key_completeness
 
 // TODO(dkorolev): These actually belong to REST, not to storage/container semantics.
 namespace rest {
@@ -131,14 +131,14 @@ template <typename FIELD>
 using top_level_operation_for_field_t =
     typename TopLevelOperationSelector<typename FIELD::semantics_t::primary_key_t>::type;
 
-}  // namespace current::storage::semantics::rest::operation
-}  // namespace current::storage::semantics::rest
+}  // namespace operation
+}  // namespace rest
 
-}  // namespace current::storage::semantics
+}  // namespace semantics
 
 // TODO(dkorolev): `FieldTypeDependentImpl` as `FieldKeyTypeDependentImpl` from `api_types.h` to be moved here.
 
-}  // namespace current::storage
+}  // namespace storage
 }  // namespace current
 
 #endif  // CURRENT_STORAGE_SEMANTICS_H
diff --git a/storage/storage.h b/storage/storage.h
index 635d3b280..090e6f410 100644
--- a/storage/storage.h
+++ b/storage/storage.h
@@ -71,80 +71,80 @@ namespace storage {
 
 #ifdef CURRENT_STORAGE_PATCH_SUPPORT
 
-#define CURRENT_STORAGE_FIELD_ENTRY_Dictionary_IMPL(dictionary_type, entry_type, entry_name)        \
-  struct entry_name;                                                                                \
-  CURRENT_STRUCT(entry_name##Updated) {                                                             \
-    CURRENT_FIELD(us, std::chrono::microseconds);                                                   \
-    CURRENT_FIELD(data, entry_type);                                                                \
-    CURRENT_DEFAULT_CONSTRUCTOR(entry_name##Updated) {}                                             \
-    CURRENT_CONSTRUCTOR(entry_name##Updated)(std::chrono::microseconds us, const entry_type& value) \
-        : us(us), data(value) {}                                                                    \
-    using storage_field_t = entry_name;                                                             \
-  };                                                                                                \
-  CURRENT_STRUCT(entry_name##Deleted) {                                                             \
-    CURRENT_FIELD(us, std::chrono::microseconds);                                                   \
-    CURRENT_FIELD(key, ::current::storage::sfinae::entry_key_t<entry_type>);                        \
-    CURRENT_DEFAULT_CONSTRUCTOR(entry_name##Deleted) {}                                             \
-    CURRENT_CONSTRUCTOR(entry_name##Deleted)(std::chrono::microseconds us, const entry_type& value) \
-        : us(us), key(::current::storage::sfinae::GetKey(value)) {}                                 \
-    using storage_field_t = entry_name;                                                             \
-  };                                                                                                \
-  CURRENT_STRUCT(entry_name##Patched) {                                                             \
-    CURRENT_FIELD(us, std::chrono::microseconds);                                                   \
-    CURRENT_FIELD(key, ::current::storage::sfinae::entry_key_t<entry_type>);                        \
-    CURRENT_FIELD(patch, ::current::storage::sfinae::entry_patch_object_t<entry_type>);             \
-    CURRENT_DEFAULT_CONSTRUCTOR(entry_name##Patched) {}                                             \
-    CURRENT_CONSTRUCTOR(entry_name##Patched)(                                                       \
-          std::chrono::microseconds us,                                                             \
-          ::current::copy_free<::current::storage::sfinae::entry_key_t<entry_type>> key,            \
-          ::current::copy_free<::current::storage::sfinae::entry_patch_object_t<entry_type>> patch) \
-        : us(us), key(key), patch(patch) {}                                                         \
-    using storage_field_t = entry_name;                                                             \
-  };                                                                                                \
-  struct entry_name {                                                                               \
-    template <typename T, typename E1, typename E2, typename E3>                                    \
-    using field_t = dictionary_type<T, E1, E2, E3>;                                                 \
-    using entry_t = entry_type;                                                                     \
-    using key_t = ::current::storage::sfinae::entry_key_t<entry_type>;                              \
-    using update_event_t = entry_name##Updated;                                                     \
-    using delete_event_t = entry_name##Deleted;                                                     \
-    using patch_event_t = std::conditional_t<current::HasPatch<entry_type>(),                       \
-                                             entry_name##Patched,                                   \
-                                             void>;                                                 \
-    using persisted_event_1_t = update_event_t;                                                     \
-    using persisted_event_2_t = delete_event_t;                                                     \
-    using persisted_event_3_t = patch_event_t;                                                      \
+#define CURRENT_STORAGE_FIELD_ENTRY_Dictionary_IMPL(dictionary_type, entry_type, entry_name)              \
+  struct entry_name;                                                                                      \
+  CURRENT_STRUCT(entry_name##Updated) {                                                                   \
+    CURRENT_FIELD(us, std::chrono::microseconds);                                                         \
+    CURRENT_FIELD(data, entry_type);                                                                      \
+    CURRENT_DEFAULT_CONSTRUCTOR(entry_name##Updated) {}                                                   \
+    CURRENT_CONSTRUCTOR(entry_name##Updated)                                                              \
+    (std::chrono::microseconds us, const entry_type& value) : us(us), data(value) {}                      \
+    using storage_field_t = entry_name;                                                                   \
+  };                                                                                                      \
+  CURRENT_STRUCT(entry_name##Deleted) {                                                                   \
+    CURRENT_FIELD(us, std::chrono::microseconds);                                                         \
+    CURRENT_FIELD(key, ::current::storage::sfinae::entry_key_t<entry_type>);                              \
+    CURRENT_DEFAULT_CONSTRUCTOR(entry_name##Deleted) {}                                                   \
+    CURRENT_CONSTRUCTOR(entry_name##Deleted)                                                              \
+    (std::chrono::microseconds us, const entry_type& value)                                               \
+        : us(us), key(::current::storage::sfinae::GetKey(value)) {}                                       \
+    using storage_field_t = entry_name;                                                                   \
+  };                                                                                                      \
+  CURRENT_STRUCT(entry_name##Patched) {                                                                   \
+    CURRENT_FIELD(us, std::chrono::microseconds);                                                         \
+    CURRENT_FIELD(key, ::current::storage::sfinae::entry_key_t<entry_type>);                              \
+    CURRENT_FIELD(patch, ::current::storage::sfinae::entry_patch_object_t<entry_type>);                   \
+    CURRENT_DEFAULT_CONSTRUCTOR(entry_name##Patched) {}                                                   \
+    CURRENT_CONSTRUCTOR(entry_name##Patched)                                                              \
+    (std::chrono::microseconds us,                                                                        \
+     ::current::copy_free<::current::storage::sfinae::entry_key_t<entry_type>> key,                       \
+     ::current::copy_free<::current::storage::sfinae::entry_patch_object_t<entry_type>> patch)            \
+        : us(us), key(key), patch(patch) {}                                                               \
+    using storage_field_t = entry_name;                                                                   \
+  };                                                                                                      \
+  struct entry_name {                                                                                     \
+    template <typename T, typename E1, typename E2, typename E3>                                          \
+    using field_t = dictionary_type<T, E1, E2, E3>;                                                       \
+    using entry_t = entry_type;                                                                           \
+    using key_t = ::current::storage::sfinae::entry_key_t<entry_type>;                                    \
+    using update_event_t = entry_name##Updated;                                                           \
+    using delete_event_t = entry_name##Deleted;                                                           \
+    using patch_event_t = std::conditional_t<current::HasPatch<entry_type>(), entry_name##Patched, void>; \
+    using persisted_event_1_t = update_event_t;                                                           \
+    using persisted_event_2_t = delete_event_t;                                                           \
+    using persisted_event_3_t = patch_event_t;                                                            \
   }
 
 #else
 
-#define CURRENT_STORAGE_FIELD_ENTRY_Dictionary_IMPL(dictionary_type, entry_type, entry_name)        \
-  struct entry_name;                                                                                \
-  CURRENT_STRUCT(entry_name##Updated) {                                                             \
-    CURRENT_FIELD(us, std::chrono::microseconds);                                                   \
-    CURRENT_FIELD(data, entry_type);                                                                \
-    CURRENT_DEFAULT_CONSTRUCTOR(entry_name##Updated) {}                                             \
-    CURRENT_CONSTRUCTOR(entry_name##Updated)(std::chrono::microseconds us, const entry_type& value) \
-        : us(us), data(value) {}                                                                    \
-    using storage_field_t = entry_name;                                                             \
-  };                                                                                                \
-  CURRENT_STRUCT(entry_name##Deleted) {                                                             \
-    CURRENT_FIELD(us, std::chrono::microseconds);                                                   \
-    CURRENT_FIELD(key, ::current::storage::sfinae::entry_key_t<entry_type>);                        \
-    CURRENT_DEFAULT_CONSTRUCTOR(entry_name##Deleted) {}                                             \
-    CURRENT_CONSTRUCTOR(entry_name##Deleted)(std::chrono::microseconds us, const entry_type& value) \
-        : us(us), key(::current::storage::sfinae::GetKey(value)) {}                                 \
-    using storage_field_t = entry_name;                                                             \
-  };                                                                                                \
-  struct entry_name {                                                                               \
-    template <typename T, typename E1, typename E2>                                                 \
-    using field_t = dictionary_type<T, E1, E2>;                                                     \
-    using entry_t = entry_type;                                                                     \
-    using key_t = ::current::storage::sfinae::entry_key_t<entry_type>;                              \
-    using update_event_t = entry_name##Updated;                                                     \
-    using delete_event_t = entry_name##Deleted;                                                     \
-    using persisted_event_1_t = entry_name##Updated;                                                \
-    using persisted_event_2_t = entry_name##Deleted;                                                \
+#define CURRENT_STORAGE_FIELD_ENTRY_Dictionary_IMPL(dictionary_type, entry_type, entry_name) \
+  struct entry_name;                                                                         \
+  CURRENT_STRUCT(entry_name##Updated) {                                                      \
+    CURRENT_FIELD(us, std::chrono::microseconds);                                            \
+    CURRENT_FIELD(data, entry_type);                                                         \
+    CURRENT_DEFAULT_CONSTRUCTOR(entry_name##Updated) {}                                      \
+    CURRENT_CONSTRUCTOR(entry_name##Updated)                                                 \
+    (std::chrono::microseconds us, const entry_type& value) : us(us), data(value) {}         \
+    using storage_field_t = entry_name;                                                      \
+  };                                                                                         \
+  CURRENT_STRUCT(entry_name##Deleted) {                                                      \
+    CURRENT_FIELD(us, std::chrono::microseconds);                                            \
+    CURRENT_FIELD(key, ::current::storage::sfinae::entry_key_t<entry_type>);                 \
+    CURRENT_DEFAULT_CONSTRUCTOR(entry_name##Deleted) {}                                      \
+    CURRENT_CONSTRUCTOR(entry_name##Deleted)                                                 \
+    (std::chrono::microseconds us, const entry_type& value)                                  \
+        : us(us), key(::current::storage::sfinae::GetKey(value)) {}                          \
+    using storage_field_t = entry_name;                                                      \
+  };                                                                                         \
+  struct entry_name {                                                                        \
+    template <typename T, typename E1, typename E2>                                          \
+    using field_t = dictionary_type<T, E1, E2>;                                              \
+    using entry_t = entry_type;                                                              \
+    using key_t = ::current::storage::sfinae::entry_key_t<entry_type>;                       \
+    using update_event_t = entry_name##Updated;                                              \
+    using delete_event_t = entry_name##Deleted;                                              \
+    using persisted_event_1_t = entry_name##Updated;                                         \
+    using persisted_event_2_t = entry_name##Deleted;                                         \
   }
 
 #endif  // CURRENT_STORAGE_PATCH_SUPPORT
@@ -164,8 +164,8 @@ namespace storage {
     CURRENT_FIELD(us, std::chrono::microseconds);                                                                      \
     CURRENT_FIELD(data, entry_type);                                                                                   \
     CURRENT_DEFAULT_CONSTRUCTOR(entry_name##Updated) {}                                                                \
-    CURRENT_CONSTRUCTOR(entry_name##Updated)(std::chrono::microseconds us, const entry_type& value)                    \
-        : us(us), data(value) {}                                                                                       \
+    CURRENT_CONSTRUCTOR(entry_name##Updated)                                                                           \
+    (std::chrono::microseconds us, const entry_type& value) : us(us), data(value) {}                                   \
     using storage_field_t = entry_name;                                                                                \
   };                                                                                                                   \
   CURRENT_STRUCT(entry_name##Deleted) {                                                                                \
@@ -174,7 +174,8 @@ namespace storage {
                   (std::pair<::current::storage::sfinae::entry_row_t<entry_type>,                                      \
                              ::current::storage::sfinae::entry_col_t<entry_type>>));                                   \
     CURRENT_DEFAULT_CONSTRUCTOR(entry_name##Deleted) {}                                                                \
-    CURRENT_CONSTRUCTOR(entry_name##Deleted)(std::chrono::microseconds us, const entry_type& value)                    \
+    CURRENT_CONSTRUCTOR(entry_name##Deleted)                                                                           \
+    (std::chrono::microseconds us, const entry_type& value)                                                            \
         : us(us),                                                                                                      \
           key(std::make_pair(::current::storage::sfinae::GetRow(value), ::current::storage::sfinae::GetCol(value))) {} \
     using storage_field_t = entry_name;                                                                                \
@@ -203,8 +204,8 @@ namespace storage {
     CURRENT_FIELD(us, std::chrono::microseconds);                                                                      \
     CURRENT_FIELD(data, entry_type);                                                                                   \
     CURRENT_DEFAULT_CONSTRUCTOR(entry_name##Updated) {}                                                                \
-    CURRENT_CONSTRUCTOR(entry_name##Updated)(std::chrono::microseconds us, const entry_type& value)                    \
-        : us(us), data(value) {}                                                                                       \
+    CURRENT_CONSTRUCTOR(entry_name##Updated)                                                                           \
+    (std::chrono::microseconds us, const entry_type& value) : us(us), data(value) {}                                   \
     using storage_field_t = entry_name;                                                                                \
   };                                                                                                                   \
   CURRENT_STRUCT(entry_name##Deleted) {                                                                                \
@@ -213,7 +214,8 @@ namespace storage {
                   (std::pair<::current::storage::sfinae::entry_row_t<entry_type>,                                      \
                              ::current::storage::sfinae::entry_col_t<entry_type>>));                                   \
     CURRENT_DEFAULT_CONSTRUCTOR(entry_name##Deleted) {}                                                                \
-    CURRENT_CONSTRUCTOR(entry_name##Deleted)(std::chrono::microseconds us, const entry_type& value)                    \
+    CURRENT_CONSTRUCTOR(entry_name##Deleted)                                                                           \
+    (std::chrono::microseconds us, const entry_type& value)                                                            \
         : us(us),                                                                                                      \
           key(std::make_pair(::current::storage::sfinae::GetRow(value), ::current::storage::sfinae::GetCol(value))) {} \
     using storage_field_t = entry_name;                                                                                \
@@ -289,7 +291,8 @@ using CURRENT_STORAGE_DEFAULT_TRANSACTION_POLICY = transaction_policy::Synchrono
 // Generic storage implementation.
 template <template <typename...> class PERSISTER,
           typename FIELDS,
-          template <typename> class TRANSACTION_POLICY,
+          template <typename>
+          class TRANSACTION_POLICY,
           typename CUSTOM_PERSISTER_PARAM>
 class StorageImpl {
  public:
@@ -339,7 +342,8 @@ class StorageImpl {
 
   template <typename CONSTRUCTION_TYPE>
   StorageImpl(CONSTRUCTION_TYPE, UseExistingStream, Borrowed<stream_t> stream)
-      : persister_(CONSTRUCTION_TYPE(), [this](const fields_variant_t& entry) { entry.Call(fields_); }, stream),
+      : persister_(
+            CONSTRUCTION_TYPE(), [this](const fields_variant_t& entry) { entry.Call(fields_); }, stream),
         transaction_policy_(persister_, fields_.current_storage_mutation_journal_) {}
 
   template <typename CONSTRUCTION_TYPE, typename... ARGS>
@@ -502,7 +506,7 @@ struct NullPersister {};
 template <typename MUTATIONS_VARIANT, typename STREAM_RECORD_TYPE = CURRENT_STORAGE_DEFAULT_PERSISTER_PARAM>
 using NullStoragePersister = NullStoragePersisterImpl<MUTATIONS_VARIANT, NullPersister, STREAM_RECORD_TYPE>;
 
-}  // namespace current::storage::persister
+}  // namespace persister
 
 template <template <template <typename...> class, template <typename> class, typename> class STORAGE>
 using transaction_t = typename STORAGE<persister::NullStoragePersister,
@@ -676,10 +680,10 @@ using MutableFields = typename STORAGE::fields_by_ref_t;
 template <typename STORAGE>
 using ImmutableFields = typename STORAGE::fields_by_cref_t;
 
-}  // namespace current::storage
+}  // namespace storage
 }  // namespace current
 
-using current::storage::MutableFields;
 using current::storage::ImmutableFields;
+using current::storage::MutableFields;
 
 #endif  // CURRENT_STORAGE_STORAGE_H
diff --git a/storage/test_helpers.cc b/storage/test_helpers.cc
index e09bcade3..6a8971e25 100644
--- a/storage/test_helpers.cc
+++ b/storage/test_helpers.cc
@@ -84,8 +84,8 @@ CURRENT_STRUCT(Cell) {
   CURRENT_USE_FIELD_AS_ROW(foo);
   CURRENT_USE_FIELD_AS_COL(bar);
 
-  CURRENT_CONSTRUCTOR(Cell)(int32_t foo = 0, const std::string& bar = "", int32_t phew = 0)
-      : foo(foo), bar(bar), phew(phew) {}
+  CURRENT_CONSTRUCTOR(Cell)
+  (int32_t foo = 0, const std::string& bar = "", int32_t phew = 0) : foo(foo), bar(bar), phew(phew) {}
 };
 
 CURRENT_STORAGE_FIELD_ENTRY(OrderedDictionary, Record, RecordDictionary);
@@ -152,16 +152,16 @@ CURRENT_STRUCT(SimplePost) {
 CURRENT_STRUCT(SimpleLikeBase) {
   CURRENT_FIELD(row, std::string);
   CURRENT_FIELD(col, std::string);
-  CURRENT_CONSTRUCTOR(SimpleLikeBase)(const std::string& who = "", const std::string& what = "")
-      : row(who), col(what) {}
+  CURRENT_CONSTRUCTOR(SimpleLikeBase)
+  (const std::string& who = "", const std::string& what = "") : row(who), col(what) {}
 };
 
 CURRENT_STRUCT(SimpleLike, SimpleLikeBase) {
   using brief_t = SimpleLikeBase;
   CURRENT_FIELD(details, Optional<std::string>);
   CURRENT_CONSTRUCTOR(SimpleLike)(const std::string& who = "", const std::string& what = "") : SUPER(who, what) {}
-  CURRENT_CONSTRUCTOR(SimpleLike)(const std::string& who, const std::string& what, const std::string& details)
-      : SUPER(who, what), details(details) {}
+  CURRENT_CONSTRUCTOR(SimpleLike)
+  (const std::string& who, const std::string& what, const std::string& details) : SUPER(who, what), details(details) {}
 };
 
 CURRENT_STRUCT(SimpleLikeValidPatch) {
@@ -177,8 +177,8 @@ CURRENT_STRUCT(SimpleLikeInvalidPatch) {
 CURRENT_STRUCT(SimpleComposite) {
   CURRENT_FIELD(row, std::string);
   CURRENT_FIELD(col, std::chrono::microseconds);
-  CURRENT_CONSTRUCTOR(SimpleComposite)(const std::string& row = "",
-                                       const std::chrono::microseconds col = std::chrono::microseconds(0))
+  CURRENT_CONSTRUCTOR(SimpleComposite)
+  (const std::string& row = "", const std::chrono::microseconds col = std::chrono::microseconds(0))
       : row(row), col(col) {}
 
   // Without this line, POST is not allowed in RESTful access to this container.
diff --git a/storage/tests_flip/test.cc b/storage/tests_flip/test.cc
index a29ae09ba..f9dc89e68 100644
--- a/storage/tests_flip/test.cc
+++ b/storage/tests_flip/test.cc
@@ -35,18 +35,21 @@ TEST(TransactionalStorage, UseExternallyProvidedStream) {
   using namespace transactional_storage_test;
   using storage_t = TestStorage<StreamInMemoryStreamPersister>;
 
-  static_assert(std::is_same<typename storage_t::persister_t::stream_t,
-                             current::stream::Stream<typename storage_t::persister_t::transaction_t,
-                                                       current::persistence::Memory>>::value,
-                "");
+  static_assert(
+      std::is_same<
+          typename storage_t::persister_t::stream_t,
+          current::stream::Stream<typename storage_t::persister_t::transaction_t, current::persistence::Memory>>::value,
+      "");
 
   auto storage = storage_t::CreateMasterStorage();
 
   {
     current::time::SetNow(std::chrono::microseconds(100));
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      fields.d.Add(Record{"own_stream", 42});
-    }).Go();
+    const auto result =
+        storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                 fields.d.Add(Record{"own_stream", 42});
+               })
+            .Go();
     EXPECT_TRUE(WasCommitted(result));
   }
 
@@ -95,25 +98,29 @@ TEST(TransactionalStorage, ReplicationViaHTTP) {
   // Perform a couple transactions.
   {
     current::time::SetNow(std::chrono::microseconds(100));
-    const auto result = master_storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      current::time::SetNow(std::chrono::microseconds(101));
-      fields.d.Add(Record{"one", 1});
-      current::time::SetNow(std::chrono::microseconds(102));
-      fields.d.Add(Record{"two", 2});
-      fields.SetTransactionMetaField("user", "dima");
-      current::time::SetNow(std::chrono::microseconds(103));
-    }).Go();
+    const auto result = master_storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              current::time::SetNow(std::chrono::microseconds(101));
+                              fields.d.Add(Record{"one", 1});
+                              current::time::SetNow(std::chrono::microseconds(102));
+                              fields.d.Add(Record{"two", 2});
+                              fields.SetTransactionMetaField("user", "dima");
+                              current::time::SetNow(std::chrono::microseconds(103));
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
   }
   {
     current::time::SetNow(std::chrono::microseconds(200));
-    const auto result = master_storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      current::time::SetNow(std::chrono::microseconds(201));
-      fields.d.Add(Record{"three", 3});
-      current::time::SetNow(std::chrono::microseconds(202));
-      fields.d.Erase("two");
-      current::time::SetNow(std::chrono::microseconds(203));
-    }).Go();
+    const auto result = master_storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              current::time::SetNow(std::chrono::microseconds(201));
+                              fields.d.Add(Record{"three", 3});
+                              current::time::SetNow(std::chrono::microseconds(202));
+                              fields.d.Erase("two");
+                              current::time::SetNow(std::chrono::microseconds(203));
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
     current::time::SetNow(std::chrono::microseconds(300));
     master_storage->PublisherUsed()->UpdateHead();
@@ -141,8 +148,7 @@ TEST(TransactionalStorage, ReplicationViaHTTP) {
   auto owned_replicated_stream(stream_t::CreateStream(replicated_stream_file_name));
 
   // Replicate data via subscription to master storage raw log.
-  current::stream::SubscribableRemoteStream<transaction_t> remote_stream(
-      Printf("http://localhost:%d/raw_log", port));
+  current::stream::SubscribableRemoteStream<transaction_t> remote_stream(Printf("http://localhost:%d/raw_log", port));
   EXPECT_TRUE(owned_replicated_stream->IsMasterStream());
   auto replicator = std::make_unique<replicator_t>(owned_replicated_stream);
   EXPECT_FALSE(owned_replicated_stream->IsMasterStream());
@@ -175,12 +181,14 @@ TEST(TransactionalStorage, ReplicationViaHTTP) {
   }
 
   // Test data consistency performing a transaction in the replicated storage.
-  const auto result = replicated_storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-    EXPECT_EQ(2u, fields.d.Size());
-    EXPECT_EQ(1, Value(fields.d["one"]).rhs);
-    EXPECT_EQ(3, Value(fields.d["three"]).rhs);
-    EXPECT_FALSE(Exists(fields.d["two"]));
-  }).Go();
+  const auto result = replicated_storage
+                          ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                            EXPECT_EQ(2u, fields.d.Size());
+                            EXPECT_EQ(1, Value(fields.d["one"]).rhs);
+                            EXPECT_EQ(3, Value(fields.d["three"]).rhs);
+                            EXPECT_FALSE(Exists(fields.d["two"]));
+                          })
+                          .Go();
   EXPECT_TRUE(WasCommitted(result));
 }
 
@@ -208,63 +216,67 @@ TEST(TransactionalStorage, UseExternallyProvidedStreamStreamOfBroaderType) {
 
   static_assert(std::is_same<typename storage_t::persister_t::stream_t,
                              current::stream::Stream<Variant<transaction_t, StreamEntryOutsideStorage>,
-                                                       current::persistence::Memory>>::value,
+                                                     current::persistence::Memory>>::value,
                 "");
 
   auto owned_stream = storage_t::stream_t::CreateStream();
   auto storage = storage_t::CreateMasterStorageAtopExistingStream(owned_stream);
 
-  {
-    // Add three records to the stream: first and third externally, second through the storage.
-    { storage->PublisherUsed()->Publish(StreamEntryOutsideStorage("one"), std::chrono::microseconds(1)); }
+  {// Add three records to the stream: first and third externally, second through the storage.
+   {storage->PublisherUsed()->Publish(StreamEntryOutsideStorage("one"), std::chrono::microseconds(1));
+}
 
-    {
-      current::time::SetNow(std::chrono::microseconds(2));
-      const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-        fields.d.Add(Record{"two", 2});
-      }).Go();
-      EXPECT_TRUE(WasCommitted(result));
-    }
-    { storage->PublisherUsed()->Publish(StreamEntryOutsideStorage("three"), std::chrono::microseconds(3)); }
-  }
+{
+  current::time::SetNow(std::chrono::microseconds(2));
+  const auto result =
+      storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+               fields.d.Add(Record{"two", 2});
+             })
+          .Go();
+  EXPECT_TRUE(WasCommitted(result));
+}
+{ storage->PublisherUsed()->Publish(StreamEntryOutsideStorage("three"), std::chrono::microseconds(3)); }
+}
 
-  {
-    // Subscribe to and collect transactions.
-    std::string collected_transactions;
-    StorageStreamTestProcessor<transaction_t> processor(collected_transactions);
-    processor.SetAllowTerminateOnOnMoreEntriesOfRightType();
-    storage->Subscribe<transaction_t>(processor);
-    EXPECT_EQ(
-        "{\"index\":1,\"us\":2}\t"
-        "{\"meta\":{\"begin_us\":2,\"end_us\":2,\"fields\":{}},\"mutations\":["
-        "{\"RecordDictionaryUpdated\":{\"us\":2,\"data\":{\"lhs\":\"two\",\"rhs\":2}},"
-        "\"\":\"T9200018162904582576\"}]}\n",
-        collected_transactions);
-  }
+{
+  // Subscribe to and collect transactions.
+  std::string collected_transactions;
+  StorageStreamTestProcessor<transaction_t> processor(collected_transactions);
+  processor.SetAllowTerminateOnOnMoreEntriesOfRightType();
+  storage->Subscribe<transaction_t>(processor);
+  EXPECT_EQ(
+      "{\"index\":1,\"us\":2}\t"
+      "{\"meta\":{\"begin_us\":2,\"end_us\":2,\"fields\":{}},\"mutations\":["
+      "{\"RecordDictionaryUpdated\":{\"us\":2,\"data\":{\"lhs\":\"two\",\"rhs\":2}},"
+      "\"\":\"T9200018162904582576\"}]}\n",
+      collected_transactions);
+}
 
-  {
-    // Subscribe to and collect non-transactions.
-    std::string collected_non_transactions;
-    StorageStreamTestProcessor<StreamEntryOutsideStorage> processor(collected_non_transactions);
-    processor.SetAllowTerminateOnOnMoreEntriesOfRightType();
-    storage->Subscribe<StreamEntryOutsideStorage>(processor);
-    EXPECT_EQ("{\"index\":0,\"us\":1}\t{\"s\":\"one\"}\n{\"index\":2,\"us\":3}\t{\"s\":\"three\"}\n",
-              collected_non_transactions);
-  }
+{
+  // Subscribe to and collect non-transactions.
+  std::string collected_non_transactions;
+  StorageStreamTestProcessor<StreamEntryOutsideStorage> processor(collected_non_transactions);
+  processor.SetAllowTerminateOnOnMoreEntriesOfRightType();
+  storage->Subscribe<StreamEntryOutsideStorage>(processor);
+  EXPECT_EQ("{\"index\":0,\"us\":1}\t{\"s\":\"one\"}\n{\"index\":2,\"us\":3}\t{\"s\":\"three\"}\n",
+            collected_non_transactions);
+}
 
-  {
-    // Confirm replaying storage with a mixed-content stream does its job.
-    auto replayed = storage_t::CreateFollowingStorageAtopExistingStream(storage->UnderlyingStream());
-    while (replayed->LastAppliedTimestamp() < std::chrono::microseconds(2)) {  // As `3` is a non-transaction.
-      std::this_thread::yield();
-    }
-    const auto result = replayed->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-      EXPECT_EQ(1u, fields.d.Size());
-      ASSERT_TRUE(Exists(fields.d["two"]));
-      EXPECT_EQ(2, Value(fields.d["two"]).rhs);
-    }).Go();
-    EXPECT_TRUE(WasCommitted(result));
+{
+  // Confirm replaying storage with a mixed-content stream does its job.
+  auto replayed = storage_t::CreateFollowingStorageAtopExistingStream(storage->UnderlyingStream());
+  while (replayed->LastAppliedTimestamp() < std::chrono::microseconds(2)) {  // As `3` is a non-transaction.
+    std::this_thread::yield();
   }
+  const auto result = replayed
+                          ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                            EXPECT_EQ(1u, fields.d.Size());
+                            ASSERT_TRUE(Exists(fields.d["two"]));
+                            EXPECT_EQ(2, Value(fields.d["two"]).rhs);
+                          })
+                          .Go();
+  EXPECT_TRUE(WasCommitted(result));
+}
 }
 
 TEST(TransactionalStorage, FollowingStorageFlipsToMaster) {
@@ -305,8 +317,7 @@ TEST(TransactionalStorage, FollowingStorageFlipsToMaster) {
   const auto base_url = current::strings::Printf("http://localhost:%d", port);
 
   // Start RESTful service atop follower storage.
-  auto rest = RESTfulStorage<storage_t>(
-      *follower_storage, port, "/api", "http://unittest.current.ai");
+  auto rest = RESTfulStorage<storage_t>(*follower_storage, port, "/api", "http://unittest.current.ai");
 
   // Launch the continuous replication process.
   {
@@ -322,9 +333,10 @@ TEST(TransactionalStorage, FollowingStorageFlipsToMaster) {
     // Publish one record.
     current::time::SetNow(std::chrono::microseconds(100));
     {
-      const auto result = master_storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-        fields.user.Add(SimpleUser("John", "JD"));
-      }).Go();
+      const auto result =
+          master_storage
+              ->ReadWriteTransaction([](MutableFields<storage_t> fields) { fields.user.Add(SimpleUser("John", "JD")); })
+              .Go();
       EXPECT_TRUE(WasCommitted(result));
     }
 
@@ -334,9 +346,9 @@ TEST(TransactionalStorage, FollowingStorageFlipsToMaster) {
       size_t user_size;
       user_size = 0u;
       do {
-        const auto result = follower_storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-          return fields.user.Size();
-        }).Go();
+        const auto result =
+            follower_storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) { return fields.user.Size(); })
+                .Go();
         EXPECT_TRUE(WasCommitted(result));
         user_size = Value(result);
       } while (user_size == 0u);
@@ -345,10 +357,12 @@ TEST(TransactionalStorage, FollowingStorageFlipsToMaster) {
 
     // Check that the the following storage now has the same record as the master one.
     {
-      const auto result = follower_storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-        ASSERT_TRUE(Exists(fields.user["John"]));
-        EXPECT_EQ("JD", Value(fields.user["John"]).name);
-      }).Go();
+      const auto result = follower_storage
+                              ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                                ASSERT_TRUE(Exists(fields.user["John"]));
+                                EXPECT_EQ("JD", Value(fields.user["John"]).name);
+                              })
+                              .Go();
       EXPECT_TRUE(WasCommitted(result));
     }
     {
@@ -400,9 +414,10 @@ TEST(TransactionalStorage, FollowingStorageFlipsToMaster) {
   // Publish record and check that everything goes well.
   current::time::SetNow(std::chrono::microseconds(200));
   {
-    const auto result = follower_storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      fields.user.Add(SimpleUser("max", "MZ"));
-    }).Go();
+    const auto result =
+        follower_storage
+            ->ReadWriteTransaction([](MutableFields<storage_t> fields) { fields.user.Add(SimpleUser("max", "MZ")); })
+            .Go();
     EXPECT_TRUE(WasCommitted(result));
   }
   current::time::SetNow(std::chrono::microseconds(300));
@@ -413,13 +428,15 @@ TEST(TransactionalStorage, FollowingStorageFlipsToMaster) {
     const auto user_key = post_response.body;
 
     // Ensure that all the records are in place.
-    const auto result = follower_storage->ReadOnlyTransaction([user_key](ImmutableFields<storage_t> fields) {
-      EXPECT_EQ(3u, fields.user.Size());
-      ASSERT_TRUE(Exists(fields.user["max"]));
-      EXPECT_EQ("MZ", Value(fields.user["max"]).name);
-      ASSERT_TRUE(Exists(fields.user[user_key]));
-      EXPECT_EQ("DK", Value(fields.user[user_key]).name);
-    }).Go();
+    const auto result = follower_storage
+                            ->ReadOnlyTransaction([user_key](ImmutableFields<storage_t> fields) {
+                              EXPECT_EQ(3u, fields.user.Size());
+                              ASSERT_TRUE(Exists(fields.user["max"]));
+                              EXPECT_EQ("MZ", Value(fields.user["max"]).name);
+                              ASSERT_TRUE(Exists(fields.user[user_key]));
+                              EXPECT_EQ("DK", Value(fields.user[user_key]).name);
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
   }
 }
diff --git a/storage/tests_rest/test.cc b/storage/tests_rest/test.cc
index af9e80695..513c65a00 100644
--- a/storage/tests_rest/test.cc
+++ b/storage/tests_rest/test.cc
@@ -124,8 +124,7 @@ TEST(TransactionalStorage, RESTfulAPITest) {
   // Run twice to make sure the `GET-POST-GET-DELETE` cycle is complete.
   for (size_t i = 0; i < 2; ++i) {
     // Register RESTful HTTP endpoints, in a scoped way.
-    auto rest = RESTfulStorage<storage_t>(
-        *storage, port, "/api_plain", "http://unittest.current.ai");
+    auto rest = RESTfulStorage<storage_t>(*storage, port, "/api_plain", "http://unittest.current.ai");
     const auto hypermedia_rest = RESTfulStorage<storage_t, current::storage::rest::Hypermedia>(
         *storage, port, "/api_hypermedia", "http://unittest.current.ai");
 
@@ -277,15 +276,17 @@ TEST(TransactionalStorage, RESTfulAPITest) {
       {
         EXPECT_EQ(200,
                   static_cast<int>(HTTP(PATCH(base_url + "/api_plain/data/like/max/beer",
-                                              SimpleLikeValidPatch(std::string("Cheers!")))).code));
+                                              SimpleLikeValidPatch(std::string("Cheers!"))))
+                                       .code));
         EXPECT_EQ(
             400,
             static_cast<int>(HTTP(PATCH(base_url + "/api_plain/data/like/max/beer", SimpleLikeInvalidPatch())).code));
       }
       {
-        EXPECT_EQ(200,
-                  static_cast<int>(HTTP(PATCH(base_url + "/api_hypermedia/data/like/dima/beer",
-                                              SimpleLikeValidPatch(nullptr))).code));
+        EXPECT_EQ(
+            200,
+            static_cast<int>(
+                HTTP(PATCH(base_url + "/api_hypermedia/data/like/dima/beer", SimpleLikeValidPatch(nullptr))).code));
         EXPECT_EQ(400,
                   static_cast<int>(
                       HTTP(PATCH(base_url + "/api_hypermedia/data/like/dima/beer", SimpleLikeInvalidPatch())).code));
@@ -413,255 +414,253 @@ TEST(TransactionalStorage, RESTfulAPIMatrixTest) {
   const auto base_url = current::strings::Printf("http://localhost:%d", port);
 
   const auto rest1 = RESTfulStorage<storage_t>(*storage, port, "/plain", "");
-  const auto rest2 = RESTfulStorage<storage_t, current::storage::rest::Simple>(
-      *storage, port, "/simple", "");
-  const auto rest3 = RESTfulStorage<storage_t, current::storage::rest::Hypermedia>(
-      *storage, port, "/hypermedia", "");
+  const auto rest2 = RESTfulStorage<storage_t, current::storage::rest::Simple>(*storage, port, "/simple", "");
+  const auto rest3 = RESTfulStorage<storage_t, current::storage::rest::Hypermedia>(*storage, port, "/hypermedia", "");
 
   {
     // Create { "!1", "!2", "!3" } x { 1, 2, 3 }, excluding the main diagonal.
     // Try all three REST implementations, as well as both POST and PUT.
     EXPECT_EQ(201,
               static_cast<int>(HTTP(POST(base_url + "/plain/data/composite_m2m",
-                                         SimpleComposite("!1", std::chrono::microseconds(2)))).code));
+                                         SimpleComposite("!1", std::chrono::microseconds(2))))
+                                   .code));
     EXPECT_EQ(201,
               static_cast<int>(HTTP(POST(base_url + "/simple/data/composite_m2m",
-                                         SimpleComposite("!1", std::chrono::microseconds(3)))).code));
+                                         SimpleComposite("!1", std::chrono::microseconds(3))))
+                                   .code));
     EXPECT_EQ(201,
               static_cast<int>(HTTP(POST(base_url + "/hypermedia/data/composite_m2m",
-                                         SimpleComposite("!2", std::chrono::microseconds(1)))).code));
+                                         SimpleComposite("!2", std::chrono::microseconds(1))))
+                                   .code));
     EXPECT_EQ(201,
               static_cast<int>(HTTP(PUT(base_url + "/plain/data/composite_m2m/!2/3",
-                                        SimpleComposite("!2", std::chrono::microseconds(3)))).code));
+                                        SimpleComposite("!2", std::chrono::microseconds(3))))
+                                   .code));
     EXPECT_EQ(201,
               static_cast<int>(HTTP(PUT(base_url + "/simple/data/composite_m2m/!3/1",
-                                        SimpleComposite("!3", std::chrono::microseconds(1)))).code));
+                                        SimpleComposite("!3", std::chrono::microseconds(1))))
+                                   .code));
     EXPECT_EQ(201,
               static_cast<int>(HTTP(PUT(base_url + "/hypermedia/data/composite_m2m/!3/2",
-                                        SimpleComposite("!3", std::chrono::microseconds(2)))).code));
+                                        SimpleComposite("!3", std::chrono::microseconds(2))))
+                                   .code));
   }
 
-  {
-    // Browse the collection in various ways using the `Plain` API.
-    {
-      const auto response = HTTP(GET(base_url + "/plain/data/composite_m2m"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      // The top-level container is still unordered, so meh.
-      std::vector<std::string> elements = current::strings::Split<current::strings::ByLines>(response.body);
-      std::sort(elements.begin(), elements.end());
-      EXPECT_EQ(
-          "!1\t2\t{\"row\":\"!1\",\"col\":2}\n"
-          "!1\t3\t{\"row\":\"!1\",\"col\":3}\n"
-          "!2\t1\t{\"row\":\"!2\",\"col\":1}\n"
-          "!2\t3\t{\"row\":\"!2\",\"col\":3}\n"
-          "!3\t1\t{\"row\":\"!3\",\"col\":1}\n"
-          "!3\t2\t{\"row\":\"!3\",\"col\":2}",
-          current::strings::Join(elements, '\n'));
-    }
-    {
-      const auto response = HTTP(GET(base_url + "/plain/data/composite_m2m.row"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      EXPECT_EQ("!1\t2\n!2\t2\n!3\t2\n", response.body);
-    }
-    {
-      const auto response = HTTP(GET(base_url + "/plain/data/composite_m2m.col"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      EXPECT_EQ("1\t2\n2\t2\n3\t2\n", response.body);
-    }
-    {
-      const auto response = HTTP(GET(base_url + "/plain/data/composite_m2m.row/!2"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      EXPECT_EQ("{\"row\":\"!2\",\"col\":1}\n{\"row\":\"!2\",\"col\":3}\n", response.body);
-    }
-    {
-      const auto response = HTTP(GET(base_url + "/plain/data/composite_m2m.col/3"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      EXPECT_EQ("{\"row\":\"!1\",\"col\":3}\n{\"row\":\"!2\",\"col\":3}\n", response.body);
-    }
-  }
+  {// Browse the collection in various ways using the `Plain` API.
+   {const auto response = HTTP(GET(base_url + "/plain/data/composite_m2m"));
+  EXPECT_EQ(200, static_cast<int>(response.code));
+  // The top-level container is still unordered, so meh.
+  std::vector<std::string> elements = current::strings::Split<current::strings::ByLines>(response.body);
+  std::sort(elements.begin(), elements.end());
+  EXPECT_EQ(
+      "!1\t2\t{\"row\":\"!1\",\"col\":2}\n"
+      "!1\t3\t{\"row\":\"!1\",\"col\":3}\n"
+      "!2\t1\t{\"row\":\"!2\",\"col\":1}\n"
+      "!2\t3\t{\"row\":\"!2\",\"col\":3}\n"
+      "!3\t1\t{\"row\":\"!3\",\"col\":1}\n"
+      "!3\t2\t{\"row\":\"!3\",\"col\":2}",
+      current::strings::Join(elements, '\n'));
+}
+{
+  const auto response = HTTP(GET(base_url + "/plain/data/composite_m2m.row"));
+  EXPECT_EQ(200, static_cast<int>(response.code));
+  EXPECT_EQ("!1\t2\n!2\t2\n!3\t2\n", response.body);
+}
+{
+  const auto response = HTTP(GET(base_url + "/plain/data/composite_m2m.col"));
+  EXPECT_EQ(200, static_cast<int>(response.code));
+  EXPECT_EQ("1\t2\n2\t2\n3\t2\n", response.body);
+}
+{
+  const auto response = HTTP(GET(base_url + "/plain/data/composite_m2m.row/!2"));
+  EXPECT_EQ(200, static_cast<int>(response.code));
+  EXPECT_EQ("{\"row\":\"!2\",\"col\":1}\n{\"row\":\"!2\",\"col\":3}\n", response.body);
+}
+{
+  const auto response = HTTP(GET(base_url + "/plain/data/composite_m2m.col/3"));
+  EXPECT_EQ(200, static_cast<int>(response.code));
+  EXPECT_EQ("{\"row\":\"!1\",\"col\":3}\n{\"row\":\"!2\",\"col\":3}\n", response.body);
+}
+}
+
+{// Browse the collection in various ways using the `Simple` API.
+ {const auto response = HTTP(GET(base_url + "/simple/data/composite_m2m"));
+EXPECT_EQ(200, static_cast<int>(response.code));
+using parsed_t = current::storage::rest::simple::SimpleRESTContainerResponse;
+parsed_t parsed;
+ASSERT_NO_THROW(ParseJSON<parsed_t>(response.body, parsed));
+// Don't test the body of `"/simple/data/composite_m2m"`, it's unordered and machine-dependent.
+std::vector<std::string> strings;
+for (const auto& resource : parsed.data) {
+  strings.push_back(JSON(resource));
+}
+std::sort(strings.begin(), strings.end());
+EXPECT_EQ(
+    "\"/data/composite_m2m/!1/2\"\n"
+    "\"/data/composite_m2m/!1/3\"\n"
+    "\"/data/composite_m2m/!2/1\"\n"
+    "\"/data/composite_m2m/!2/3\"\n"
+    "\"/data/composite_m2m/!3/1\"\n"
+    "\"/data/composite_m2m/!3/2\"",
+    current::strings::Join(strings, '\n'));
+}
+{
+  const auto response = HTTP(GET(base_url + "/simple/data/composite_m2m.row"));
+  EXPECT_EQ(200, static_cast<int>(response.code));
+  EXPECT_EQ(
+      "{\"success\":true,\"message\":null,\"error\":null,\"url\":\"/data/composite_m2m.1\",\"data\":[\"/"
+      "data/composite_m2m.1/!1\",\"/data/composite_m2m.1/!2\",\"/data/composite_m2m.1/!3\"]}\n",
+      response.body);
+}
+{
+  const auto response = HTTP(GET(base_url + "/simple/data/composite_m2m.col"));
+  EXPECT_EQ(200, static_cast<int>(response.code));
+  EXPECT_EQ(
+      "{\"success\":true,\"message\":null,\"error\":null,\"url\":\"/data/composite_m2m.2\",\"data\":[\"/"
+      "data/composite_m2m.2/1\",\"/data/composite_m2m.2/2\",\"/data/composite_m2m.2/3\"]}\n",
+      response.body);
+}
+{
+  const auto response = HTTP(GET(base_url + "/simple/data/composite_m2m.1/!2"));
+  EXPECT_EQ(200, static_cast<int>(response.code));
+  EXPECT_EQ(
+      "{\"success\":true,\"message\":null,\"error\":null,\"url\":\"/data/composite_m2m.1/!2\",\"data\":[\"/data/"
+      "composite_m2m/!2/1\",\"/data/composite_m2m/!2/3\"]}\n",
+      response.body);
+}
+{
+  const auto response = HTTP(GET(base_url + "/simple/data/composite_m2m.2/3"));
+  EXPECT_EQ(200, static_cast<int>(response.code));
+  EXPECT_EQ(
+      "{\"success\":true,\"message\":null,\"error\":null,\"url\":\"/data/composite_m2m.2/3\",\"data\":[\"/data/"
+      "composite_m2m/!1/3\",\"/data/composite_m2m/!2/3\"]}\n",
+      response.body);
+}
+}
+{// Browse the collection in various ways using the `Hypermedia` API.
+ {const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m"));
+EXPECT_EQ(200, static_cast<int>(response.code));
+using parsed_t =
+    hypermedia::HypermediaRESTCollectionResponse<hypermedia::HypermediaRESTFullCollectionRecord<SimpleComposite>>;
+parsed_t parsed;
+ASSERT_NO_THROW(ParseJSON<parsed_t>(response.body, parsed));
+std::vector<std::string> strings;
+for (const auto& resource : parsed.data) {
+  strings.push_back(JSON(resource.data));
+}
+std::sort(strings.begin(), strings.end());
+}
+{
+  const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m.1"));
+  EXPECT_EQ(200, static_cast<int>(response.code));
+  EXPECT_EQ(
+      "{\"success\":true,\"url\":\"/data/composite_m2m.1?i=0&n=10\",\"url_directory\":\"/data/"
+      "composite_m2m.1\",\"i\":0,\"n\":3,\"total\":3,\"url_next_page\":null,\"url_previous_page\":null,"
+      "\"data\":[{\"url\":\"/data/composite_m2m.1/"
+      "!1\",\"data\":{\"total\":2,\"preview\":[{\"row\":\"!1\",\"col\":2},{\"row\":\"!1\",\"col\":3}]}},{"
+      "\"url\":\"/data/composite_m2m.1/"
+      "!2\",\"data\":{\"total\":2,\"preview\":[{\"row\":\"!2\",\"col\":1},{\"row\":\"!2\",\"col\":3}]}},{"
+      "\"url\":\"/data/composite_m2m.1/"
+      "!3\",\"data\":{\"total\":2,\"preview\":[{\"row\":\"!3\",\"col\":1},{\"row\":\"!3\",\"col\":2}]}}]}"
+      "\n",
+      response.body);
+}
+{
+  const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m.2"));
+  EXPECT_EQ(200, static_cast<int>(response.code));
+  EXPECT_EQ(
+      "{\"success\":true,\"url\":\"/data/composite_m2m.2?i=0&n=10\",\"url_directory\":\"/data/"
+      "composite_m2m.2\",\"i\":0,\"n\":3,\"total\":3,\"url_next_page\":null,\"url_previous_page\":null,"
+      "\"data\":[{\"url\":\"/data/composite_m2m.2/"
+      "1\",\"data\":{\"total\":2,\"preview\":[{\"row\":\"!2\",\"col\":1},{\"row\":\"!3\",\"col\":1}]}},{"
+      "\"url\":\"/data/composite_m2m.2/"
+      "2\",\"data\":{\"total\":2,\"preview\":[{\"row\":\"!1\",\"col\":2},{\"row\":\"!3\",\"col\":2}]}},{"
+      "\"url\":\"/data/composite_m2m.2/"
+      "3\",\"data\":{\"total\":2,\"preview\":[{\"row\":\"!1\",\"col\":3},{\"row\":\"!2\",\"col\":3}]}}]}\n",
+      response.body);
+}
+{
+  const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m.1/!2"));
+  EXPECT_EQ(200, static_cast<int>(response.code));
+  EXPECT_EQ(
+      "{\"success\":true,\"url\":\"/data/composite_m2m.1/!2?i=0&n=10\",\"url_directory\":\"/data/"
+      "composite_m2m\",\"i\":0,\"n\":2,\"total\":2,\"url_next_page\":null,\"url_previous_page\":null,"
+      "\"data\":[{\"url\":\"/data/composite_m2m/!2/1\",\"data\":{\"row\":\"!2\",\"col\":1}},{\"url\":\"/"
+      "data/composite_m2m/!2/3\",\"data\":{\"row\":\"!2\",\"col\":3}}]}\n",
+      response.body);
+}
+{
+  const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m.2/3"));
+  EXPECT_EQ(200, static_cast<int>(response.code));
+  EXPECT_EQ(
+      "{\"success\":true,\"url\":\"/data/composite_m2m.2/3?i=0&n=10\",\"url_directory\":\"/data/"
+      "composite_m2m\",\"i\":0,\"n\":2,\"total\":2,\"url_next_page\":null,\"url_previous_page\":null,"
+      "\"data\":[{\"url\":\"/data/composite_m2m/!1/3\",\"data\":{\"row\":\"!1\",\"col\":3}},{\"url\":\"/"
+      "data/composite_m2m/!2/3\",\"data\":{\"row\":\"!2\",\"col\":3}}]}\n",
+      response.body);
+}
+// And some inner-level pagination tests.
+{
+  const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m.1/!2?n=1"));
+  EXPECT_EQ(200, static_cast<int>(response.code));
+  EXPECT_EQ(
+      "{\"success\":true,\"url\":\"/data/composite_m2m.1/!2?i=0&n=1\",\"url_directory\":\"/data/"
+      "composite_m2m\",\"i\":0,\"n\":1,\"total\":2,\"url_next_page\":\"/data/composite_m2m.1/"
+      "!2?i=1&n=1\",\"url_previous_page\":null,\"data\":[{\"url\":\"/data/composite_m2m/!2/"
+      "1\",\"data\":{\"row\":\"!2\",\"col\":1}}]}\n",
+      response.body);
+}
+{
+  const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m.1/!2?n=1&i=1"));
+  EXPECT_EQ(200, static_cast<int>(response.code));
+  EXPECT_EQ(
+      "{\"success\":true,\"url\":\"/data/composite_m2m.1/!2?i=1&n=1\",\"url_directory\":\"/data/"
+      "composite_m2m\",\"i\":1,\"n\":1,\"total\":2,\"url_next_page\":null,\"url_previous_page\":\"/data/"
+      "composite_m2m.1/!2?i=0&n=1\",\"data\":[{\"url\":\"/data/composite_m2m/!2/"
+      "3\",\"data\":{\"row\":\"!2\",\"col\":3}}]}\n",
+      response.body);
+}
+{
+  const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m.2/3?n=1"));
+  EXPECT_EQ(200, static_cast<int>(response.code));
+  EXPECT_EQ(
+      "{\"success\":true,\"url\":\"/data/composite_m2m.2/3?i=0&n=1\",\"url_directory\":\"/data/"
+      "composite_m2m\",\"i\":0,\"n\":1,\"total\":2,\"url_next_page\":\"/data/composite_m2m.2/"
+      "3?i=1&n=1\",\"url_previous_page\":null,\"data\":[{\"url\":\"/data/composite_m2m/!1/"
+      "3\",\"data\":{\"row\":\"!1\",\"col\":3}}]}\n",
+      response.body);
+}
+{
+  const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m.2/3?n=1&i=1"));
+  EXPECT_EQ(200, static_cast<int>(response.code));
+  EXPECT_EQ(
+      "{\"success\":true,\"url\":\"/data/composite_m2m.2/3?i=1&n=1\",\"url_directory\":\"/data/"
+      "composite_m2m\",\"i\":1,\"n\":1,\"total\":2,\"url_next_page\":null,\"url_previous_page\":\"/data/"
+      "composite_m2m.2/3?i=0&n=1\",\"data\":[{\"url\":\"/data/composite_m2m/!2/"
+      "3\",\"data\":{\"row\":\"!2\",\"col\":3}}]}\n",
+      response.body);
+}
+}
 
+{
+  // Test DELETE too.
   {
-    // Browse the collection in various ways using the `Simple` API.
-    {
-      const auto response = HTTP(GET(base_url + "/simple/data/composite_m2m"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      using parsed_t = current::storage::rest::simple::SimpleRESTContainerResponse;
-      parsed_t parsed;
-      ASSERT_NO_THROW(ParseJSON<parsed_t>(response.body, parsed));
-      // Don't test the body of `"/simple/data/composite_m2m"`, it's unordered and machine-dependent.
-      std::vector<std::string> strings;
-      for (const auto& resource : parsed.data) {
-        strings.push_back(JSON(resource));
-      }
-      std::sort(strings.begin(), strings.end());
-      EXPECT_EQ(
-          "\"/data/composite_m2m/!1/2\"\n"
-          "\"/data/composite_m2m/!1/3\"\n"
-          "\"/data/composite_m2m/!2/1\"\n"
-          "\"/data/composite_m2m/!2/3\"\n"
-          "\"/data/composite_m2m/!3/1\"\n"
-          "\"/data/composite_m2m/!3/2\"",
-          current::strings::Join(strings, '\n'));
-    }
-    {
-      const auto response = HTTP(GET(base_url + "/simple/data/composite_m2m.row"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      EXPECT_EQ(
-          "{\"success\":true,\"message\":null,\"error\":null,\"url\":\"/data/composite_m2m.1\",\"data\":[\"/"
-          "data/composite_m2m.1/!1\",\"/data/composite_m2m.1/!2\",\"/data/composite_m2m.1/!3\"]}\n",
-          response.body);
-    }
-    {
-      const auto response = HTTP(GET(base_url + "/simple/data/composite_m2m.col"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      EXPECT_EQ(
-          "{\"success\":true,\"message\":null,\"error\":null,\"url\":\"/data/composite_m2m.2\",\"data\":[\"/"
-          "data/composite_m2m.2/1\",\"/data/composite_m2m.2/2\",\"/data/composite_m2m.2/3\"]}\n",
-          response.body);
-    }
-    {
-      const auto response = HTTP(GET(base_url + "/simple/data/composite_m2m.1/!2"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      EXPECT_EQ(
-          "{\"success\":true,\"message\":null,\"error\":null,\"url\":\"/data/composite_m2m.1/!2\",\"data\":[\"/data/"
-          "composite_m2m/!2/1\",\"/data/composite_m2m/!2/3\"]}\n",
-          response.body);
-    }
-    {
-      const auto response = HTTP(GET(base_url + "/simple/data/composite_m2m.2/3"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      EXPECT_EQ(
-          "{\"success\":true,\"message\":null,\"error\":null,\"url\":\"/data/composite_m2m.2/3\",\"data\":[\"/data/"
-          "composite_m2m/!1/3\",\"/data/composite_m2m/!2/3\"]}\n",
-          response.body);
-    }
+    EXPECT_EQ(200, static_cast<int>(HTTP(GET(base_url + "/plain/data/composite_m2m/!1/2")).code));
+    EXPECT_EQ(200, static_cast<int>(HTTP(DELETE(base_url + "/plain/data/composite_m2m/!1/2")).code));
+    EXPECT_EQ(404, static_cast<int>(HTTP(GET(base_url + "/plain/data/composite_m2m/!1/2")).code));
   }
   {
-    // Browse the collection in various ways using the `Hypermedia` API.
-    {
-      const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      using parsed_t =
-          hypermedia::HypermediaRESTCollectionResponse<hypermedia::HypermediaRESTFullCollectionRecord<SimpleComposite>>;
-      parsed_t parsed;
-      ASSERT_NO_THROW(ParseJSON<parsed_t>(response.body, parsed));
-      std::vector<std::string> strings;
-      for (const auto& resource : parsed.data) {
-        strings.push_back(JSON(resource.data));
-      }
-      std::sort(strings.begin(), strings.end());
-    }
-    {
-      const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m.1"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      EXPECT_EQ(
-          "{\"success\":true,\"url\":\"/data/composite_m2m.1?i=0&n=10\",\"url_directory\":\"/data/"
-          "composite_m2m.1\",\"i\":0,\"n\":3,\"total\":3,\"url_next_page\":null,\"url_previous_page\":null,"
-          "\"data\":[{\"url\":\"/data/composite_m2m.1/"
-          "!1\",\"data\":{\"total\":2,\"preview\":[{\"row\":\"!1\",\"col\":2},{\"row\":\"!1\",\"col\":3}]}},{"
-          "\"url\":\"/data/composite_m2m.1/"
-          "!2\",\"data\":{\"total\":2,\"preview\":[{\"row\":\"!2\",\"col\":1},{\"row\":\"!2\",\"col\":3}]}},{"
-          "\"url\":\"/data/composite_m2m.1/"
-          "!3\",\"data\":{\"total\":2,\"preview\":[{\"row\":\"!3\",\"col\":1},{\"row\":\"!3\",\"col\":2}]}}]}"
-          "\n",
-          response.body);
-    }
-    {
-      const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m.2"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      EXPECT_EQ(
-          "{\"success\":true,\"url\":\"/data/composite_m2m.2?i=0&n=10\",\"url_directory\":\"/data/"
-          "composite_m2m.2\",\"i\":0,\"n\":3,\"total\":3,\"url_next_page\":null,\"url_previous_page\":null,"
-          "\"data\":[{\"url\":\"/data/composite_m2m.2/"
-          "1\",\"data\":{\"total\":2,\"preview\":[{\"row\":\"!2\",\"col\":1},{\"row\":\"!3\",\"col\":1}]}},{"
-          "\"url\":\"/data/composite_m2m.2/"
-          "2\",\"data\":{\"total\":2,\"preview\":[{\"row\":\"!1\",\"col\":2},{\"row\":\"!3\",\"col\":2}]}},{"
-          "\"url\":\"/data/composite_m2m.2/"
-          "3\",\"data\":{\"total\":2,\"preview\":[{\"row\":\"!1\",\"col\":3},{\"row\":\"!2\",\"col\":3}]}}]}\n",
-          response.body);
-    }
-    {
-      const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m.1/!2"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      EXPECT_EQ(
-          "{\"success\":true,\"url\":\"/data/composite_m2m.1/!2?i=0&n=10\",\"url_directory\":\"/data/"
-          "composite_m2m\",\"i\":0,\"n\":2,\"total\":2,\"url_next_page\":null,\"url_previous_page\":null,"
-          "\"data\":[{\"url\":\"/data/composite_m2m/!2/1\",\"data\":{\"row\":\"!2\",\"col\":1}},{\"url\":\"/"
-          "data/composite_m2m/!2/3\",\"data\":{\"row\":\"!2\",\"col\":3}}]}\n",
-          response.body);
-    }
-    {
-      const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m.2/3"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      EXPECT_EQ(
-          "{\"success\":true,\"url\":\"/data/composite_m2m.2/3?i=0&n=10\",\"url_directory\":\"/data/"
-          "composite_m2m\",\"i\":0,\"n\":2,\"total\":2,\"url_next_page\":null,\"url_previous_page\":null,"
-          "\"data\":[{\"url\":\"/data/composite_m2m/!1/3\",\"data\":{\"row\":\"!1\",\"col\":3}},{\"url\":\"/"
-          "data/composite_m2m/!2/3\",\"data\":{\"row\":\"!2\",\"col\":3}}]}\n",
-          response.body);
-    }
-    // And some inner-level pagination tests.
-    {
-      const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m.1/!2?n=1"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      EXPECT_EQ(
-          "{\"success\":true,\"url\":\"/data/composite_m2m.1/!2?i=0&n=1\",\"url_directory\":\"/data/"
-          "composite_m2m\",\"i\":0,\"n\":1,\"total\":2,\"url_next_page\":\"/data/composite_m2m.1/"
-          "!2?i=1&n=1\",\"url_previous_page\":null,\"data\":[{\"url\":\"/data/composite_m2m/!2/"
-          "1\",\"data\":{\"row\":\"!2\",\"col\":1}}]}\n",
-          response.body);
-    }
-    {
-      const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m.1/!2?n=1&i=1"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      EXPECT_EQ(
-          "{\"success\":true,\"url\":\"/data/composite_m2m.1/!2?i=1&n=1\",\"url_directory\":\"/data/"
-          "composite_m2m\",\"i\":1,\"n\":1,\"total\":2,\"url_next_page\":null,\"url_previous_page\":\"/data/"
-          "composite_m2m.1/!2?i=0&n=1\",\"data\":[{\"url\":\"/data/composite_m2m/!2/"
-          "3\",\"data\":{\"row\":\"!2\",\"col\":3}}]}\n",
-          response.body);
-    }
-    {
-      const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m.2/3?n=1"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      EXPECT_EQ(
-          "{\"success\":true,\"url\":\"/data/composite_m2m.2/3?i=0&n=1\",\"url_directory\":\"/data/"
-          "composite_m2m\",\"i\":0,\"n\":1,\"total\":2,\"url_next_page\":\"/data/composite_m2m.2/"
-          "3?i=1&n=1\",\"url_previous_page\":null,\"data\":[{\"url\":\"/data/composite_m2m/!1/"
-          "3\",\"data\":{\"row\":\"!1\",\"col\":3}}]}\n",
-          response.body);
-    }
-    {
-      const auto response = HTTP(GET(base_url + "/hypermedia/data/composite_m2m.2/3?n=1&i=1"));
-      EXPECT_EQ(200, static_cast<int>(response.code));
-      EXPECT_EQ(
-          "{\"success\":true,\"url\":\"/data/composite_m2m.2/3?i=1&n=1\",\"url_directory\":\"/data/"
-          "composite_m2m\",\"i\":1,\"n\":1,\"total\":2,\"url_next_page\":null,\"url_previous_page\":\"/data/"
-          "composite_m2m.2/3?i=0&n=1\",\"data\":[{\"url\":\"/data/composite_m2m/!2/"
-          "3\",\"data\":{\"row\":\"!2\",\"col\":3}}]}\n",
-          response.body);
-    }
+    EXPECT_EQ(200, static_cast<int>(HTTP(GET(base_url + "/simple/data/composite_m2m/!2/3")).code));
+    EXPECT_EQ(200, static_cast<int>(HTTP(DELETE(base_url + "/simple/data/composite_m2m/!2/3")).code));
+    EXPECT_EQ(404, static_cast<int>(HTTP(GET(base_url + "/simple/data/composite_m2m/!2/3")).code));
   }
-
   {
-    // Test DELETE too.
-    {
-      EXPECT_EQ(200, static_cast<int>(HTTP(GET(base_url + "/plain/data/composite_m2m/!1/2")).code));
-      EXPECT_EQ(200, static_cast<int>(HTTP(DELETE(base_url + "/plain/data/composite_m2m/!1/2")).code));
-      EXPECT_EQ(404, static_cast<int>(HTTP(GET(base_url + "/plain/data/composite_m2m/!1/2")).code));
-    }
-    {
-      EXPECT_EQ(200, static_cast<int>(HTTP(GET(base_url + "/simple/data/composite_m2m/!2/3")).code));
-      EXPECT_EQ(200, static_cast<int>(HTTP(DELETE(base_url + "/simple/data/composite_m2m/!2/3")).code));
-      EXPECT_EQ(404, static_cast<int>(HTTP(GET(base_url + "/simple/data/composite_m2m/!2/3")).code));
-    }
-    {
-      EXPECT_EQ(200, static_cast<int>(HTTP(GET(base_url + "/hypermedia/data/composite_m2m/!3/1")).code));
-      EXPECT_EQ(200, static_cast<int>(HTTP(DELETE(base_url + "/hypermedia/data/composite_m2m/!3/1")).code));
-      EXPECT_EQ(404, static_cast<int>(HTTP(GET(base_url + "/hypermedia/data/composite_m2m/!3/1")).code));
-    }
+    EXPECT_EQ(200, static_cast<int>(HTTP(GET(base_url + "/hypermedia/data/composite_m2m/!3/1")).code));
+    EXPECT_EQ(200, static_cast<int>(HTTP(DELETE(base_url + "/hypermedia/data/composite_m2m/!3/1")).code));
+    EXPECT_EQ(404, static_cast<int>(HTTP(GET(base_url + "/hypermedia/data/composite_m2m/!3/1")).code));
   }
 }
+}
 
 TEST(TransactionalStorage, CQSTest) {
   current::time::ResetToZero();
@@ -678,16 +677,18 @@ TEST(TransactionalStorage, CQSTest) {
   auto storage = storage_t::CreateMasterStorage();
 
   const auto base_url = current::strings::Printf("http://localhost:%d", port);
-  auto storage_http_interface = RESTfulStorage<storage_t, current::storage::rest::Simple>(
-      *storage, port, "/api", "http://unittest.current.ai");
+  auto storage_http_interface =
+      RESTfulStorage<storage_t, current::storage::rest::Simple>(*storage, port, "/api", "http://unittest.current.ai");
 
   {
     const std::string user_key = ([&]() {
       const auto post_response = HTTP(POST(base_url + "/api/data/user", SimpleUser("dima", "DK")));
       EXPECT_EQ(201, static_cast<int>(post_response.code));
-      return current::strings::Split(Value(ParseJSON<current::storage::rest::generic::RESTResourceUpdateResponse>(
-                                               post_response.body).resource_url),
-                                     '/').back();
+      return current::strings::Split(
+                 Value(ParseJSON<current::storage::rest::generic::RESTResourceUpdateResponse>(post_response.body)
+                           .resource_url),
+                 '/')
+          .back();
     })();
 
     {
@@ -703,9 +704,11 @@ TEST(TransactionalStorage, CQSTest) {
     const std::string user_key = ([&]() {
       const auto post_response = HTTP(POST(base_url + "/api/data/user", SimpleUser("max", "MZ")));
       EXPECT_EQ(201, static_cast<int>(post_response.code));
-      return current::strings::Split(Value(ParseJSON<current::storage::rest::generic::RESTResourceUpdateResponse>(
-                                               post_response.body).resource_url),
-                                     '/').back();
+      return current::strings::Split(
+                 Value(ParseJSON<current::storage::rest::generic::RESTResourceUpdateResponse>(post_response.body)
+                           .resource_url),
+                 '/')
+          .back();
     })();
 
     {
@@ -1005,11 +1008,9 @@ CURRENT_STRUCT(PatchableY) {
   CURRENT_FIELD(key, std::string);
   CURRENT_FIELD(y, int32_t);
   CURRENT_CONSTRUCTOR(PatchableY)(std::string key = "", int32_t y = 0) : key(std::move(key)), y(y) {}
-  
+
   using patch_object_t = PatchToY;
-  void PatchWith(const patch_object_t& patch) {
-    y += patch.dy;
-  }
+  void PatchWith(const patch_object_t& patch) { y += patch.dy; }
 };
 
 CURRENT_STORAGE_FIELD_ENTRY(OrderedDictionary, NonPatchableX, NonPatchableXDictionary);
@@ -1022,7 +1023,6 @@ CURRENT_STORAGE(PatchTestStorage) {
 
 }  // namespace transactional_storage_test
 
-
 TEST(TransactionalStorage, PatchMutation) {
   current::time::ResetToZero();
 
@@ -1046,121 +1046,143 @@ TEST(TransactionalStorage, PatchMutation) {
   EXPECT_TRUE(storage->IsMasterStorage());
 
   {
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      EXPECT_FALSE(fields.x.Has("a"));
-      fields.x.Add(NonPatchableX{"a", 1});
-      EXPECT_TRUE(fields.x.Has("a"));
-      EXPECT_TRUE(Exists(fields.x["a"]));
-      EXPECT_EQ(1, Value(fields.x["a"]).x);
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              EXPECT_FALSE(fields.x.Has("a"));
+                              fields.x.Add(NonPatchableX{"a", 1});
+                              EXPECT_TRUE(fields.x.Has("a"));
+                              EXPECT_TRUE(Exists(fields.x["a"]));
+                              EXPECT_EQ(1, Value(fields.x["a"]).x);
+                            })
+                            .Go();
 
     EXPECT_TRUE(WasCommitted(result));
     EXPECT_EQ(static_cast<uint64_t>(1), stream->Data()->Size());
   }
 
   {
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      EXPECT_FALSE(fields.y.Has("b"));
-      fields.y.Add(PatchableY{"b", 2});
-      ASSERT_TRUE(fields.y.Has("b"));
-      ASSERT_TRUE(Exists(fields.y["b"]));
-      EXPECT_EQ(2, Value(fields.y["b"]).y);
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              EXPECT_FALSE(fields.y.Has("b"));
+                              fields.y.Add(PatchableY{"b", 2});
+                              ASSERT_TRUE(fields.y.Has("b"));
+                              ASSERT_TRUE(Exists(fields.y["b"]));
+                              EXPECT_EQ(2, Value(fields.y["b"]).y);
+                            })
+                            .Go();
 
     EXPECT_TRUE(WasCommitted(result));
     EXPECT_EQ(static_cast<uint64_t>(2), stream->Data()->Size());
   }
 
   {
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      EXPECT_TRUE(fields.y.Patch("b", PatchToY(+10)));
-      ASSERT_TRUE(Exists(fields.y["b"]));
-      EXPECT_EQ(12, Value(fields.y["b"]).y);
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              EXPECT_TRUE(fields.y.Patch("b", PatchToY(+10)));
+                              ASSERT_TRUE(Exists(fields.y["b"]));
+                              EXPECT_EQ(12, Value(fields.y["b"]).y);
+                            })
+                            .Go();
 
     EXPECT_TRUE(WasCommitted(result));
     EXPECT_EQ(static_cast<uint64_t>(3), stream->Data()->Size());
   }
 
   {
-    const auto result = storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-      ASSERT_TRUE(Exists(fields.y["b"]));
-      EXPECT_EQ(12, Value(fields.y["b"]).y);
-    }).Go();
+    const auto result = storage
+                            ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                              ASSERT_TRUE(Exists(fields.y["b"]));
+                              EXPECT_EQ(12, Value(fields.y["b"]).y);
+                            })
+                            .Go();
 
     EXPECT_TRUE(WasCommitted(result));
   }
 
   {
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      EXPECT_TRUE(fields.y.Patch("b", +100));
-      ASSERT_TRUE(Exists(fields.y["b"]));
-      EXPECT_EQ(112, Value(fields.y["b"]).y);
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              EXPECT_TRUE(fields.y.Patch("b", +100));
+                              ASSERT_TRUE(Exists(fields.y["b"]));
+                              EXPECT_EQ(112, Value(fields.y["b"]).y);
+                            })
+                            .Go();
 
     EXPECT_TRUE(WasCommitted(result));
     EXPECT_EQ(static_cast<uint64_t>(4), stream->Data()->Size());
   }
 
   {
-    const auto result = storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-      ASSERT_TRUE(Exists(fields.y["b"]));
-      EXPECT_EQ(112, Value(fields.y["b"]).y);
-    }).Go();
+    const auto result = storage
+                            ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                              ASSERT_TRUE(Exists(fields.y["b"]));
+                              EXPECT_EQ(112, Value(fields.y["b"]).y);
+                            })
+                            .Go();
 
     EXPECT_TRUE(WasCommitted(result));
   }
 
   {
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      EXPECT_TRUE(fields.y.Patch("b", +333, +333, +334));
-      ASSERT_TRUE(Exists(fields.y["b"]));
-      EXPECT_EQ(1112, Value(fields.y["b"]).y);
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              EXPECT_TRUE(fields.y.Patch("b", +333, +333, +334));
+                              ASSERT_TRUE(Exists(fields.y["b"]));
+                              EXPECT_EQ(1112, Value(fields.y["b"]).y);
+                            })
+                            .Go();
 
     EXPECT_TRUE(WasCommitted(result));
     EXPECT_EQ(static_cast<uint64_t>(5), stream->Data()->Size());
   }
 
   {
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      ASSERT_TRUE(Exists(fields.y["b"]));
-      const auto b = Value(fields.y["b"]);
-      EXPECT_TRUE(fields.y.Patch(b, PatchToY(+1)));
-      EXPECT_TRUE(fields.y.Patch(b, +2));
-      EXPECT_TRUE(fields.y.Patch(b, 0, -1, -2));
-      EXPECT_EQ(1112, Value(fields.y["b"]).y);
-
-      EXPECT_FALSE(fields.y.Patch("no such key", -1));
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              ASSERT_TRUE(Exists(fields.y["b"]));
+                              const auto b = Value(fields.y["b"]);
+                              EXPECT_TRUE(fields.y.Patch(b, PatchToY(+1)));
+                              EXPECT_TRUE(fields.y.Patch(b, +2));
+                              EXPECT_TRUE(fields.y.Patch(b, 0, -1, -2));
+                              EXPECT_EQ(1112, Value(fields.y["b"]).y);
+
+                              EXPECT_FALSE(fields.y.Patch("no such key", -1));
+                            })
+                            .Go();
 
     EXPECT_TRUE(WasCommitted(result));
     EXPECT_EQ(static_cast<uint64_t>(6), stream->Data()->Size());
   }
 
   {
-    const auto result = storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-      ASSERT_TRUE(Exists(fields.y["b"]));
-      EXPECT_EQ(1112, Value(fields.y["b"]).y);
-    }).Go();
+    const auto result = storage
+                            ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                              ASSERT_TRUE(Exists(fields.y["b"]));
+                              EXPECT_EQ(1112, Value(fields.y["b"]).y);
+                            })
+                            .Go();
 
     EXPECT_TRUE(WasCommitted(result));
   }
 
   {
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      EXPECT_TRUE(fields.y.Patch("b", PatchToY(+1000000)));
-      CURRENT_STORAGE_THROW_ROLLBACK();
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              EXPECT_TRUE(fields.y.Patch("b", PatchToY(+1000000)));
+                              CURRENT_STORAGE_THROW_ROLLBACK();
+                            })
+                            .Go();
     EXPECT_FALSE(WasCommitted(result));
     EXPECT_EQ(static_cast<uint64_t>(6), stream->Data()->Size());
   }
 
   {
-    const auto result = storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-      ASSERT_TRUE(Exists(fields.y["b"]));
-      EXPECT_EQ(1112, Value(fields.y["b"]).y);
-    }).Go();
+    const auto result = storage
+                            ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                              ASSERT_TRUE(Exists(fields.y["b"]));
+                              EXPECT_EQ(1112, Value(fields.y["b"]).y);
+                            })
+                            .Go();
 
     EXPECT_TRUE(WasCommitted(result));
   }
@@ -1195,12 +1217,14 @@ TEST(TransactionalStorage, PatchMutation) {
     }
 
     {
-      const auto result = following_storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-        ASSERT_TRUE(Exists(fields.x["a"]));
-        EXPECT_EQ(1, Value(fields.x["a"]).x);
-        ASSERT_TRUE(Exists(fields.y["b"]));
-        EXPECT_EQ(1112, Value(fields.y["b"]).y);
-      }).Go();
+      const auto result = following_storage
+                              ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                                ASSERT_TRUE(Exists(fields.x["a"]));
+                                EXPECT_EQ(1, Value(fields.x["a"]).x);
+                                ASSERT_TRUE(Exists(fields.y["b"]));
+                                EXPECT_EQ(1112, Value(fields.y["b"]).y);
+                              })
+                              .Go();
 
       EXPECT_TRUE(WasCommitted(result));
     }
diff --git a/storage/tests_smoke/test.cc b/storage/tests_smoke/test.cc
index 7bd2be706..2e096f2ae 100644
--- a/storage/tests_smoke/test.cc
+++ b/storage/tests_smoke/test.cc
@@ -52,735 +52,784 @@ TEST(TransactionalStorage, SmokeTest) {
 
     // Fill a `Dictionary` container.
     {
-      const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-        EXPECT_FALSE(fields.d.Has("one"));
-        fields.d.Add(Record{"one", 1});
-        EXPECT_TRUE(fields.d.Has("one"));
-
-        {
-          size_t count = 0u;
-          int32_t value = 0;
-          for (const auto& e : fields.d) {
-            ++count;
-            value += e.rhs;
-          }
-          EXPECT_EQ(1u, count);
-          EXPECT_EQ(1, value);
-        }
-
-        EXPECT_FALSE(fields.d.Empty());
-        EXPECT_EQ(1u, fields.d.Size());
-        EXPECT_TRUE(Exists(fields.d["one"]));
-        EXPECT_EQ(1, Value(fields.d["one"]).rhs);
-
-        fields.d.Add(Record{"two", 2});
-
-        EXPECT_FALSE(fields.d.Empty());
-        EXPECT_EQ(2u, fields.d.Size());
-        EXPECT_EQ(1, Value(fields.d["one"]).rhs);
-        EXPECT_EQ(2, Value(fields.d["two"]).rhs);
-
-        fields.d.Add(Record{"three", 3});
-        EXPECT_TRUE(fields.d.Has("three"));
-        fields.d.Erase("three");
-        EXPECT_FALSE(fields.d.Has("three"));
-      }).Go();
+      const auto result = storage
+                              ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                                EXPECT_FALSE(fields.d.Has("one"));
+                                fields.d.Add(Record{"one", 1});
+                                EXPECT_TRUE(fields.d.Has("one"));
+
+                                {
+                                  size_t count = 0u;
+                                  int32_t value = 0;
+                                  for (const auto& e : fields.d) {
+                                    ++count;
+                                    value += e.rhs;
+                                  }
+                                  EXPECT_EQ(1u, count);
+                                  EXPECT_EQ(1, value);
+                                }
+
+                                EXPECT_FALSE(fields.d.Empty());
+                                EXPECT_EQ(1u, fields.d.Size());
+                                EXPECT_TRUE(Exists(fields.d["one"]));
+                                EXPECT_EQ(1, Value(fields.d["one"]).rhs);
+
+                                fields.d.Add(Record{"two", 2});
+
+                                EXPECT_FALSE(fields.d.Empty());
+                                EXPECT_EQ(2u, fields.d.Size());
+                                EXPECT_EQ(1, Value(fields.d["one"]).rhs);
+                                EXPECT_EQ(2, Value(fields.d["two"]).rhs);
+
+                                fields.d.Add(Record{"three", 3});
+                                EXPECT_TRUE(fields.d.Has("three"));
+                                fields.d.Erase("three");
+                                EXPECT_FALSE(fields.d.Has("three"));
+                              })
+                              .Go();
 
       EXPECT_TRUE(WasCommitted(result));
     }
 
     // Fill a `ManyToMany` container.
     {
-      const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-        EXPECT_TRUE(fields.umany_to_umany.Empty());
-        EXPECT_EQ(0u, fields.umany_to_umany.Size());
-        EXPECT_TRUE(fields.umany_to_umany.Rows().Empty());
-        EXPECT_TRUE(fields.umany_to_umany.Cols().Empty());
-        EXPECT_EQ(0u, fields.umany_to_umany.Rows().Size());
-        EXPECT_EQ(0u, fields.umany_to_umany.Cols().Size());
-        EXPECT_FALSE(fields.umany_to_umany.Has(1, "one"));
-        EXPECT_FALSE(fields.umany_to_umany.Has(std::make_pair(1, "one")));
-        fields.umany_to_umany.Add(Cell{1, "one", 1});
-        EXPECT_TRUE(fields.umany_to_umany.Has(1, "one"));
-        EXPECT_TRUE(fields.umany_to_umany.Has(std::make_pair(1, "one")));
-        EXPECT_FALSE(fields.umany_to_umany.Has(101, "one"));
-        EXPECT_FALSE(fields.umany_to_umany.Has(1, "some one"));
-        EXPECT_FALSE(fields.umany_to_umany.Has(std::make_pair(101, "one")));
-        EXPECT_FALSE(fields.umany_to_umany.Has(std::make_pair(1, "some one")));
-        fields.umany_to_umany.Add(Cell{2, "two", 2});
-        fields.umany_to_umany.Add(Cell{2, "too", 3});
-        EXPECT_FALSE(fields.umany_to_umany.Empty());
-        EXPECT_EQ(3u, fields.umany_to_umany.Size());
-        EXPECT_FALSE(fields.umany_to_umany.Rows().Empty());
-        EXPECT_FALSE(fields.umany_to_umany.Cols().Empty());
-        EXPECT_EQ(2u, fields.umany_to_umany.Rows().Size());
-        EXPECT_EQ(3u, fields.umany_to_umany.Cols().Size());
-        EXPECT_EQ(2u, fields.umany_to_umany.Row(2).Size());
-        EXPECT_EQ(1u, fields.umany_to_umany.Col("too").Size());
-        EXPECT_TRUE(fields.umany_to_umany.Rows().Has(1));
-        EXPECT_TRUE(fields.umany_to_umany.Row(3).Empty());
-        EXPECT_TRUE(fields.umany_to_umany.Cols().Has("one"));
-        EXPECT_TRUE(Exists(fields.umany_to_umany.Get(1, "one")));
-        EXPECT_EQ(1, Value(fields.umany_to_umany.Get(1, "one")).phew);
-        EXPECT_EQ(2, Value(fields.umany_to_umany.Get(2, "two")).phew);
-        EXPECT_EQ(3, Value(fields.umany_to_umany.Get(2, "too")).phew);
-      }).Go();
+      const auto result = storage
+                              ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                                EXPECT_TRUE(fields.umany_to_umany.Empty());
+                                EXPECT_EQ(0u, fields.umany_to_umany.Size());
+                                EXPECT_TRUE(fields.umany_to_umany.Rows().Empty());
+                                EXPECT_TRUE(fields.umany_to_umany.Cols().Empty());
+                                EXPECT_EQ(0u, fields.umany_to_umany.Rows().Size());
+                                EXPECT_EQ(0u, fields.umany_to_umany.Cols().Size());
+                                EXPECT_FALSE(fields.umany_to_umany.Has(1, "one"));
+                                EXPECT_FALSE(fields.umany_to_umany.Has(std::make_pair(1, "one")));
+                                fields.umany_to_umany.Add(Cell{1, "one", 1});
+                                EXPECT_TRUE(fields.umany_to_umany.Has(1, "one"));
+                                EXPECT_TRUE(fields.umany_to_umany.Has(std::make_pair(1, "one")));
+                                EXPECT_FALSE(fields.umany_to_umany.Has(101, "one"));
+                                EXPECT_FALSE(fields.umany_to_umany.Has(1, "some one"));
+                                EXPECT_FALSE(fields.umany_to_umany.Has(std::make_pair(101, "one")));
+                                EXPECT_FALSE(fields.umany_to_umany.Has(std::make_pair(1, "some one")));
+                                fields.umany_to_umany.Add(Cell{2, "two", 2});
+                                fields.umany_to_umany.Add(Cell{2, "too", 3});
+                                EXPECT_FALSE(fields.umany_to_umany.Empty());
+                                EXPECT_EQ(3u, fields.umany_to_umany.Size());
+                                EXPECT_FALSE(fields.umany_to_umany.Rows().Empty());
+                                EXPECT_FALSE(fields.umany_to_umany.Cols().Empty());
+                                EXPECT_EQ(2u, fields.umany_to_umany.Rows().Size());
+                                EXPECT_EQ(3u, fields.umany_to_umany.Cols().Size());
+                                EXPECT_EQ(2u, fields.umany_to_umany.Row(2).Size());
+                                EXPECT_EQ(1u, fields.umany_to_umany.Col("too").Size());
+                                EXPECT_TRUE(fields.umany_to_umany.Rows().Has(1));
+                                EXPECT_TRUE(fields.umany_to_umany.Row(3).Empty());
+                                EXPECT_TRUE(fields.umany_to_umany.Cols().Has("one"));
+                                EXPECT_TRUE(Exists(fields.umany_to_umany.Get(1, "one")));
+                                EXPECT_EQ(1, Value(fields.umany_to_umany.Get(1, "one")).phew);
+                                EXPECT_EQ(2, Value(fields.umany_to_umany.Get(2, "two")).phew);
+                                EXPECT_EQ(3, Value(fields.umany_to_umany.Get(2, "too")).phew);
+                              })
+                              .Go();
       EXPECT_TRUE(WasCommitted(result));
     }
 
     // Fill a `OneToOne` container.
     {
-      const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-        EXPECT_TRUE(fields.uone_to_uone.Empty());
-        EXPECT_EQ(0u, fields.uone_to_uone.Size());
-        EXPECT_TRUE(fields.uone_to_uone.Rows().Empty());
-        EXPECT_TRUE(fields.uone_to_uone.Cols().Empty());
-        EXPECT_EQ(0u, fields.uone_to_uone.Rows().Size());
-        EXPECT_EQ(0u, fields.uone_to_uone.Cols().Size());
-        fields.uone_to_uone.Add(Cell{1, "one", 1});  // Adds {1,one=1}
-        fields.uone_to_uone.Add(Cell{2, "two", 2});  // Adds {2,two=2}
-        fields.uone_to_uone.Add(Cell{2, "too", 3});  // Adds {2,too=3}, removes {2,two=2}
-        fields.uone_to_uone.Add(Cell{3, "too", 6});  // Adds {3,too=6}, removes {2,too=3}
-        fields.uone_to_uone.Add(Cell{3, "too", 4});  // Adds {3,too=4}, overwrites {3,too=6}
-        fields.uone_to_uone.Add(Cell{4, "fiv", 5});  // Adds {4,fiv=5}
-        EXPECT_FALSE(fields.uone_to_uone.Empty());
-        EXPECT_EQ(3u, fields.uone_to_uone.Size());
-        EXPECT_FALSE(fields.uone_to_uone.Rows().Empty());
-        EXPECT_FALSE(fields.uone_to_uone.Cols().Empty());
-        EXPECT_EQ(3u, fields.uone_to_uone.Rows().Size());
-        EXPECT_EQ(3u, fields.uone_to_uone.Cols().Size());
-        EXPECT_TRUE(fields.uone_to_uone.Rows().Has(1));
-        EXPECT_TRUE(Exists(fields.uone_to_uone.GetEntryFromRow(1)));
-        EXPECT_TRUE(fields.uone_to_uone.Cols().Has("one"));
-        EXPECT_TRUE(Exists(fields.uone_to_uone.GetEntryFromCol("one")));
-        EXPECT_FALSE(fields.uone_to_uone.Rows().Has(2));
-        EXPECT_FALSE(Exists(fields.uone_to_uone.GetEntryFromRow(2)));
-        EXPECT_FALSE(fields.uone_to_uone.Cols().Has("two"));
-        EXPECT_FALSE(Exists(fields.uone_to_uone.GetEntryFromCol("two")));
-        EXPECT_TRUE(Exists(fields.uone_to_uone.Get(3, "too")));
-        EXPECT_FALSE(Exists(fields.uone_to_uone.Get(2, "too")));
-        EXPECT_EQ(1, Value(fields.uone_to_uone.Get(1, "one")).phew);
-        EXPECT_EQ(1, Value(fields.uone_to_uone.GetEntryFromRow(1)).phew);
-        EXPECT_EQ(4, Value(fields.uone_to_uone.Get(3, "too")).phew);
-        EXPECT_EQ(4, Value(fields.uone_to_uone.GetEntryFromCol("too")).phew);
-        EXPECT_EQ(5, Value(fields.uone_to_uone.Get(4, "fiv")).phew);
-        EXPECT_EQ(5, Value(fields.uone_to_uone.GetEntryFromRow(4)).phew);
-        EXPECT_TRUE(fields.uone_to_uone.DoesNotConflict(2, "two"));
-        EXPECT_FALSE(fields.uone_to_uone.DoesNotConflict(1, "three"));
-        EXPECT_FALSE(fields.uone_to_uone.DoesNotConflict(4, "one"));
-      }).Go();
+      const auto result = storage
+                              ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                                EXPECT_TRUE(fields.uone_to_uone.Empty());
+                                EXPECT_EQ(0u, fields.uone_to_uone.Size());
+                                EXPECT_TRUE(fields.uone_to_uone.Rows().Empty());
+                                EXPECT_TRUE(fields.uone_to_uone.Cols().Empty());
+                                EXPECT_EQ(0u, fields.uone_to_uone.Rows().Size());
+                                EXPECT_EQ(0u, fields.uone_to_uone.Cols().Size());
+                                fields.uone_to_uone.Add(Cell{1, "one", 1});  // Adds {1,one=1}
+                                fields.uone_to_uone.Add(Cell{2, "two", 2});  // Adds {2,two=2}
+                                fields.uone_to_uone.Add(Cell{2, "too", 3});  // Adds {2,too=3}, removes {2,two=2}
+                                fields.uone_to_uone.Add(Cell{3, "too", 6});  // Adds {3,too=6}, removes {2,too=3}
+                                fields.uone_to_uone.Add(Cell{3, "too", 4});  // Adds {3,too=4}, overwrites {3,too=6}
+                                fields.uone_to_uone.Add(Cell{4, "fiv", 5});  // Adds {4,fiv=5}
+                                EXPECT_FALSE(fields.uone_to_uone.Empty());
+                                EXPECT_EQ(3u, fields.uone_to_uone.Size());
+                                EXPECT_FALSE(fields.uone_to_uone.Rows().Empty());
+                                EXPECT_FALSE(fields.uone_to_uone.Cols().Empty());
+                                EXPECT_EQ(3u, fields.uone_to_uone.Rows().Size());
+                                EXPECT_EQ(3u, fields.uone_to_uone.Cols().Size());
+                                EXPECT_TRUE(fields.uone_to_uone.Rows().Has(1));
+                                EXPECT_TRUE(Exists(fields.uone_to_uone.GetEntryFromRow(1)));
+                                EXPECT_TRUE(fields.uone_to_uone.Cols().Has("one"));
+                                EXPECT_TRUE(Exists(fields.uone_to_uone.GetEntryFromCol("one")));
+                                EXPECT_FALSE(fields.uone_to_uone.Rows().Has(2));
+                                EXPECT_FALSE(Exists(fields.uone_to_uone.GetEntryFromRow(2)));
+                                EXPECT_FALSE(fields.uone_to_uone.Cols().Has("two"));
+                                EXPECT_FALSE(Exists(fields.uone_to_uone.GetEntryFromCol("two")));
+                                EXPECT_TRUE(Exists(fields.uone_to_uone.Get(3, "too")));
+                                EXPECT_FALSE(Exists(fields.uone_to_uone.Get(2, "too")));
+                                EXPECT_EQ(1, Value(fields.uone_to_uone.Get(1, "one")).phew);
+                                EXPECT_EQ(1, Value(fields.uone_to_uone.GetEntryFromRow(1)).phew);
+                                EXPECT_EQ(4, Value(fields.uone_to_uone.Get(3, "too")).phew);
+                                EXPECT_EQ(4, Value(fields.uone_to_uone.GetEntryFromCol("too")).phew);
+                                EXPECT_EQ(5, Value(fields.uone_to_uone.Get(4, "fiv")).phew);
+                                EXPECT_EQ(5, Value(fields.uone_to_uone.GetEntryFromRow(4)).phew);
+                                EXPECT_TRUE(fields.uone_to_uone.DoesNotConflict(2, "two"));
+                                EXPECT_FALSE(fields.uone_to_uone.DoesNotConflict(1, "three"));
+                                EXPECT_FALSE(fields.uone_to_uone.DoesNotConflict(4, "one"));
+                              })
+                              .Go();
       EXPECT_TRUE(WasCommitted(result));
     }
 
     // Fill a `OneToMany` container.
     {
-      const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-        EXPECT_TRUE(fields.uone_to_umany.Empty());
-        EXPECT_EQ(0u, fields.uone_to_umany.Size());
-        EXPECT_TRUE(fields.uone_to_umany.Rows().Empty());
-        EXPECT_TRUE(fields.uone_to_umany.Cols().Empty());
-        EXPECT_EQ(0u, fields.uone_to_umany.Rows().Size());
-        EXPECT_EQ(0u, fields.uone_to_umany.Cols().Size());
-
-        EXPECT_FALSE(fields.uone_to_umany.Has(1, "one"));
-        EXPECT_FALSE(fields.uone_to_umany.Has(std::make_pair(1, "one")));
-
-        fields.uone_to_umany.Add(Cell{1, "one", 1});   // Adds {1,one=1 }
-        fields.uone_to_umany.Add(Cell{2, "two", 5});   // Adds {2,two=5 }
-        fields.uone_to_umany.Add(Cell{2, "two", 4});   // Adds {2,two=4 }, overwrites {2,two=5}
-        fields.uone_to_umany.Add(Cell{1, "fiv", 5});   // Adds {1,fiv=5 }
-        fields.uone_to_umany.Add(Cell{2, "fiv", 10});  // Adds {2,fiv=10}, removes {1,fiv=5}
-        fields.uone_to_umany.Add(Cell{3, "six", 18});  // Adds {3,six=18}
-        fields.uone_to_umany.Add(Cell{1, "six", 6});   // Adds {1,six=6 }, removes {3,six=18}
-
-        EXPECT_TRUE(fields.uone_to_umany.Has(1, "one"));
-        EXPECT_TRUE(fields.uone_to_umany.Has(std::make_pair(1, "one")));
-        EXPECT_FALSE(fields.uone_to_umany.Has(1, "fiv"));  // Implicitly removed above.
-        EXPECT_FALSE(fields.uone_to_umany.Has(3, "six"));  // Implicitly removed above.
-        EXPECT_FALSE(fields.uone_to_umany.Has(std::make_pair(1, "fiv")));
-        EXPECT_FALSE(fields.uone_to_umany.Has(std::make_pair(3, "six")));
-
-        EXPECT_FALSE(fields.uone_to_umany.Empty());
-        EXPECT_EQ(4u, fields.uone_to_umany.Size());
-        EXPECT_FALSE(fields.uone_to_umany.Rows().Empty());
-        EXPECT_FALSE(fields.uone_to_umany.Cols().Empty());
-        EXPECT_EQ(2u, fields.uone_to_umany.Rows().Size());
-        EXPECT_EQ(4u, fields.uone_to_umany.Cols().Size());
-        EXPECT_EQ(2u, fields.uone_to_umany.Row(1).Size());
-        EXPECT_TRUE(fields.uone_to_umany.Rows().Has(1));
-        EXPECT_FALSE(fields.uone_to_umany.Rows().Has(3));
-        EXPECT_TRUE(fields.uone_to_umany.Row(3).Empty());
-        EXPECT_TRUE(fields.uone_to_umany.Cols().Has("two"));
-        EXPECT_FALSE(fields.uone_to_umany.Cols().Has("too"));
-        EXPECT_TRUE(Exists(fields.uone_to_umany.GetEntryFromCol("two")));
-        EXPECT_FALSE(Exists(fields.uone_to_umany.GetEntryFromCol("tre")));
-        EXPECT_TRUE(Exists(fields.uone_to_umany.Get(2, "fiv")));
-        EXPECT_FALSE(Exists(fields.uone_to_umany.Get(3, "six")));
-        EXPECT_EQ(1, Value(fields.uone_to_umany.Get(1, "one")).phew);
-        EXPECT_EQ(4, Value(fields.uone_to_umany.Get(2, "two")).phew);
-        EXPECT_EQ(10, Value(fields.uone_to_umany.Get(2, "fiv")).phew);
-        EXPECT_EQ(6, Value(fields.uone_to_umany.Get(1, "six")).phew);
-        EXPECT_TRUE(fields.uone_to_umany.DoesNotConflict(1, "too"));
-        EXPECT_FALSE(fields.uone_to_umany.DoesNotConflict(2, "two"));
-        EXPECT_FALSE(fields.uone_to_umany.DoesNotConflict(3, "six"));
-      }).Go();
+      const auto result = storage
+                              ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                                EXPECT_TRUE(fields.uone_to_umany.Empty());
+                                EXPECT_EQ(0u, fields.uone_to_umany.Size());
+                                EXPECT_TRUE(fields.uone_to_umany.Rows().Empty());
+                                EXPECT_TRUE(fields.uone_to_umany.Cols().Empty());
+                                EXPECT_EQ(0u, fields.uone_to_umany.Rows().Size());
+                                EXPECT_EQ(0u, fields.uone_to_umany.Cols().Size());
+
+                                EXPECT_FALSE(fields.uone_to_umany.Has(1, "one"));
+                                EXPECT_FALSE(fields.uone_to_umany.Has(std::make_pair(1, "one")));
+
+                                fields.uone_to_umany.Add(Cell{1, "one", 1});   // Adds {1,one=1 }
+                                fields.uone_to_umany.Add(Cell{2, "two", 5});   // Adds {2,two=5 }
+                                fields.uone_to_umany.Add(Cell{2, "two", 4});   // Adds {2,two=4 }, overwrites {2,two=5}
+                                fields.uone_to_umany.Add(Cell{1, "fiv", 5});   // Adds {1,fiv=5 }
+                                fields.uone_to_umany.Add(Cell{2, "fiv", 10});  // Adds {2,fiv=10}, removes {1,fiv=5}
+                                fields.uone_to_umany.Add(Cell{3, "six", 18});  // Adds {3,six=18}
+                                fields.uone_to_umany.Add(Cell{1, "six", 6});   // Adds {1,six=6 }, removes {3,six=18}
+
+                                EXPECT_TRUE(fields.uone_to_umany.Has(1, "one"));
+                                EXPECT_TRUE(fields.uone_to_umany.Has(std::make_pair(1, "one")));
+                                EXPECT_FALSE(fields.uone_to_umany.Has(1, "fiv"));  // Implicitly removed above.
+                                EXPECT_FALSE(fields.uone_to_umany.Has(3, "six"));  // Implicitly removed above.
+                                EXPECT_FALSE(fields.uone_to_umany.Has(std::make_pair(1, "fiv")));
+                                EXPECT_FALSE(fields.uone_to_umany.Has(std::make_pair(3, "six")));
+
+                                EXPECT_FALSE(fields.uone_to_umany.Empty());
+                                EXPECT_EQ(4u, fields.uone_to_umany.Size());
+                                EXPECT_FALSE(fields.uone_to_umany.Rows().Empty());
+                                EXPECT_FALSE(fields.uone_to_umany.Cols().Empty());
+                                EXPECT_EQ(2u, fields.uone_to_umany.Rows().Size());
+                                EXPECT_EQ(4u, fields.uone_to_umany.Cols().Size());
+                                EXPECT_EQ(2u, fields.uone_to_umany.Row(1).Size());
+                                EXPECT_TRUE(fields.uone_to_umany.Rows().Has(1));
+                                EXPECT_FALSE(fields.uone_to_umany.Rows().Has(3));
+                                EXPECT_TRUE(fields.uone_to_umany.Row(3).Empty());
+                                EXPECT_TRUE(fields.uone_to_umany.Cols().Has("two"));
+                                EXPECT_FALSE(fields.uone_to_umany.Cols().Has("too"));
+                                EXPECT_TRUE(Exists(fields.uone_to_umany.GetEntryFromCol("two")));
+                                EXPECT_FALSE(Exists(fields.uone_to_umany.GetEntryFromCol("tre")));
+                                EXPECT_TRUE(Exists(fields.uone_to_umany.Get(2, "fiv")));
+                                EXPECT_FALSE(Exists(fields.uone_to_umany.Get(3, "six")));
+                                EXPECT_EQ(1, Value(fields.uone_to_umany.Get(1, "one")).phew);
+                                EXPECT_EQ(4, Value(fields.uone_to_umany.Get(2, "two")).phew);
+                                EXPECT_EQ(10, Value(fields.uone_to_umany.Get(2, "fiv")).phew);
+                                EXPECT_EQ(6, Value(fields.uone_to_umany.Get(1, "six")).phew);
+                                EXPECT_TRUE(fields.uone_to_umany.DoesNotConflict(1, "too"));
+                                EXPECT_FALSE(fields.uone_to_umany.DoesNotConflict(2, "two"));
+                                EXPECT_FALSE(fields.uone_to_umany.DoesNotConflict(3, "six"));
+                              })
+                              .Go();
       EXPECT_TRUE(WasCommitted(result));
     }
 
     // Copy data from unordered `ManyToMany`, `OneToOne` and `OneToMany` to corresponding ordered ones
     {
       current::time::SetNow(std::chrono::microseconds(1000000));
-      const auto result1 = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-        EXPECT_FALSE(fields.umany_to_umany.Empty());
-        EXPECT_TRUE(fields.omany_to_omany.Empty());
-        for (const auto& element : fields.umany_to_umany) {
-          fields.omany_to_omany.Add(element);
-          fields.umany_to_omany.Add(element);
-          fields.omany_to_umany.Add(element);
-        }
-        EXPECT_EQ(fields.umany_to_umany.Size(), fields.omany_to_omany.Size());
-      }).Go();
+      const auto result1 = storage
+                               ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                                 EXPECT_FALSE(fields.umany_to_umany.Empty());
+                                 EXPECT_TRUE(fields.omany_to_omany.Empty());
+                                 for (const auto& element : fields.umany_to_umany) {
+                                   fields.omany_to_omany.Add(element);
+                                   fields.umany_to_omany.Add(element);
+                                   fields.omany_to_umany.Add(element);
+                                 }
+                                 EXPECT_EQ(fields.umany_to_umany.Size(), fields.omany_to_omany.Size());
+                               })
+                               .Go();
       EXPECT_TRUE(WasCommitted(result1));
 
       current::time::SetNow(std::chrono::microseconds(2000000));
-      const auto result2 = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-        EXPECT_FALSE(fields.uone_to_uone.Empty());
-        EXPECT_TRUE(fields.oone_to_oone.Empty());
-        for (const auto& element : fields.uone_to_uone) {
-          fields.oone_to_oone.Add(element);
-          fields.uone_to_oone.Add(element);
-          fields.oone_to_uone.Add(element);
-        }
-        EXPECT_EQ(fields.uone_to_uone.Size(), fields.oone_to_oone.Size());
-      }).Go();
+      const auto result2 = storage
+                               ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                                 EXPECT_FALSE(fields.uone_to_uone.Empty());
+                                 EXPECT_TRUE(fields.oone_to_oone.Empty());
+                                 for (const auto& element : fields.uone_to_uone) {
+                                   fields.oone_to_oone.Add(element);
+                                   fields.uone_to_oone.Add(element);
+                                   fields.oone_to_uone.Add(element);
+                                 }
+                                 EXPECT_EQ(fields.uone_to_uone.Size(), fields.oone_to_oone.Size());
+                               })
+                               .Go();
       EXPECT_TRUE(WasCommitted(result2));
 
       current::time::SetNow(std::chrono::microseconds(3000000));
-      const auto result3 = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-        EXPECT_FALSE(fields.uone_to_umany.Empty());
-        EXPECT_TRUE(fields.oone_to_omany.Empty());
-        for (const auto& element : fields.uone_to_umany) {
-          fields.oone_to_omany.Add(element);
-          fields.uone_to_omany.Add(element);
-          fields.oone_to_umany.Add(element);
-        }
-      }).Go();
+      const auto result3 = storage
+                               ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                                 EXPECT_FALSE(fields.uone_to_umany.Empty());
+                                 EXPECT_TRUE(fields.oone_to_omany.Empty());
+                                 for (const auto& element : fields.uone_to_umany) {
+                                   fields.oone_to_omany.Add(element);
+                                   fields.uone_to_omany.Add(element);
+                                   fields.oone_to_umany.Add(element);
+                                 }
+                               })
+                               .Go();
       EXPECT_TRUE(WasCommitted(result3));
     }
 
     // Iterate over a `ManyToMany`, compare its ordered and unordered versions
     {
-      const auto result1 = storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-        EXPECT_FALSE(fields.umany_to_umany.Empty());
-        EXPECT_FALSE(fields.omany_to_omany.Empty());
-        std::multiset<std::string> data_set;
-        for (const auto row : fields.umany_to_umany.Rows()) {
-          for (const auto& element : row) {
-            data_set.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                            current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                            current::ToString(element.phew));
-          }
-        }
-        EXPECT_EQ("1,one=1 2,too=3 2,two=2", current::strings::Join(data_set, ' '));
-        // Use vector instead of set and expect the same result, because the data is already sorted.
-        std::vector<std::string> data_vec;
-        for (const auto row : fields.omany_to_omany.Rows()) {
-          for (const auto& element : row) {
-            data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                               current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                               current::ToString(element.phew));
-          }
-        }
-        EXPECT_EQ("1,one=1 2,too=3 2,two=2", current::strings::Join(data_vec, ' '));
-        data_vec.clear();
-        std::multiset<int32_t> rows;
-        for (const auto row : fields.umany_to_omany.Rows()) {
-          rows.insert(current::storage::sfinae::GetRow(*row.begin()));
-        }
-        for (const auto& row : rows) {
-          for (const auto& element : fields.umany_to_omany.Row(row)) {
-            data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                               current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                               current::ToString(element.phew));
-          }
-        }
-        EXPECT_EQ("1,one=1 2,too=3 2,two=2", current::strings::Join(data_vec, ' '));
-        data_vec.clear();
-        for (const auto row : fields.omany_to_umany.Rows()) {
-          int32_t row_value = current::storage::sfinae::GetRow(*row.begin());
-          std::multiset<std::string> cols;
-          for (const auto& element : row) {
-            cols.insert(current::storage::sfinae::GetCol(element));
-          }
-          for (const auto& col_value : cols) {
-            data_vec.push_back(current::ToString(row_value) + ',' + current::ToString(col_value) + '=' +
-                               current::ToString(Value(fields.omany_to_umany.Get(row_value, col_value)).phew));
-          }
-        }
-        EXPECT_EQ("1,one=1 2,too=3 2,two=2", current::strings::Join(data_vec, ' '));
-      }).Go();
+      const auto result1 =
+          storage
+              ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                EXPECT_FALSE(fields.umany_to_umany.Empty());
+                EXPECT_FALSE(fields.omany_to_omany.Empty());
+                std::multiset<std::string> data_set;
+                for (const auto row : fields.umany_to_umany.Rows()) {
+                  for (const auto& element : row) {
+                    data_set.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                    current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                    current::ToString(element.phew));
+                  }
+                }
+                EXPECT_EQ("1,one=1 2,too=3 2,two=2", current::strings::Join(data_set, ' '));
+                // Use vector instead of set and expect the same result, because the data is already sorted.
+                std::vector<std::string> data_vec;
+                for (const auto row : fields.omany_to_omany.Rows()) {
+                  for (const auto& element : row) {
+                    data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                       current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                       current::ToString(element.phew));
+                  }
+                }
+                EXPECT_EQ("1,one=1 2,too=3 2,two=2", current::strings::Join(data_vec, ' '));
+                data_vec.clear();
+                std::multiset<int32_t> rows;
+                for (const auto row : fields.umany_to_omany.Rows()) {
+                  rows.insert(current::storage::sfinae::GetRow(*row.begin()));
+                }
+                for (const auto& row : rows) {
+                  for (const auto& element : fields.umany_to_omany.Row(row)) {
+                    data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                       current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                       current::ToString(element.phew));
+                  }
+                }
+                EXPECT_EQ("1,one=1 2,too=3 2,two=2", current::strings::Join(data_vec, ' '));
+                data_vec.clear();
+                for (const auto row : fields.omany_to_umany.Rows()) {
+                  int32_t row_value = current::storage::sfinae::GetRow(*row.begin());
+                  std::multiset<std::string> cols;
+                  for (const auto& element : row) {
+                    cols.insert(current::storage::sfinae::GetCol(element));
+                  }
+                  for (const auto& col_value : cols) {
+                    data_vec.push_back(current::ToString(row_value) + ',' + current::ToString(col_value) + '=' +
+                                       current::ToString(Value(fields.omany_to_umany.Get(row_value, col_value)).phew));
+                  }
+                }
+                EXPECT_EQ("1,one=1 2,too=3 2,two=2", current::strings::Join(data_vec, ' '));
+              })
+              .Go();
       EXPECT_TRUE(WasCommitted(result1));
-      const auto result2 = storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-        EXPECT_FALSE(fields.umany_to_umany.Empty());
-        EXPECT_FALSE(fields.omany_to_omany.Empty());
-        std::multiset<std::string> data_set;
-        for (const auto col : fields.umany_to_umany.Cols()) {
-          for (const auto& element : col) {
-            data_set.insert(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
-                            current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
-                            current::ToString(element.phew));
-          }
-        }
-        EXPECT_EQ("one,1=1 too,2=3 two,2=2", current::strings::Join(data_set, ' '));
-        // Use vector instead of set and expect the same result, because the data is already sorted.
-        std::vector<std::string> data_vec;
-        for (const auto col : fields.omany_to_omany.Cols()) {
-          for (const auto& element : col) {
-            data_vec.push_back(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
-                               current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
-                               current::ToString(element.phew));
-          }
-        }
-        EXPECT_EQ("one,1=1 too,2=3 two,2=2", current::strings::Join(data_vec, ' '));
-        data_vec.clear();
-        for (const auto col : fields.umany_to_omany.Cols()) {
-          std::string col_value = current::storage::sfinae::GetCol(*col.begin());
-          std::multiset<int32_t> rows;
-          for (const auto& element : col) {
-            rows.insert(current::storage::sfinae::GetRow(element));
-          }
-          for (const auto& row_value : rows) {
-            data_vec.push_back(current::ToString(col_value) + ',' + current::ToString(row_value) + '=' +
-                               current::ToString(Value(fields.umany_to_omany.Get(row_value, col_value)).phew));
-          }
-        }
-        EXPECT_EQ("one,1=1 too,2=3 two,2=2", current::strings::Join(data_vec, ' '));
-        data_vec.clear();
-        std::multiset<std::string> cols;
-        for (const auto col : fields.omany_to_umany.Cols()) {
-          cols.insert(current::storage::sfinae::GetCol(*col.begin()));
-        }
-        for (const auto& col : cols) {
-          for (const auto& element : fields.omany_to_umany.Col(col)) {
-            data_vec.push_back(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
-                               current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
-                               current::ToString(element.phew));
-          }
-        }
-        EXPECT_EQ("one,1=1 too,2=3 two,2=2", current::strings::Join(data_vec, ' '));
-      }).Go();
+      const auto result2 =
+          storage
+              ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                EXPECT_FALSE(fields.umany_to_umany.Empty());
+                EXPECT_FALSE(fields.omany_to_omany.Empty());
+                std::multiset<std::string> data_set;
+                for (const auto col : fields.umany_to_umany.Cols()) {
+                  for (const auto& element : col) {
+                    data_set.insert(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
+                                    current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
+                                    current::ToString(element.phew));
+                  }
+                }
+                EXPECT_EQ("one,1=1 too,2=3 two,2=2", current::strings::Join(data_set, ' '));
+                // Use vector instead of set and expect the same result, because the data is already sorted.
+                std::vector<std::string> data_vec;
+                for (const auto col : fields.omany_to_omany.Cols()) {
+                  for (const auto& element : col) {
+                    data_vec.push_back(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
+                                       current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
+                                       current::ToString(element.phew));
+                  }
+                }
+                EXPECT_EQ("one,1=1 too,2=3 two,2=2", current::strings::Join(data_vec, ' '));
+                data_vec.clear();
+                for (const auto col : fields.umany_to_omany.Cols()) {
+                  std::string col_value = current::storage::sfinae::GetCol(*col.begin());
+                  std::multiset<int32_t> rows;
+                  for (const auto& element : col) {
+                    rows.insert(current::storage::sfinae::GetRow(element));
+                  }
+                  for (const auto& row_value : rows) {
+                    data_vec.push_back(current::ToString(col_value) + ',' + current::ToString(row_value) + '=' +
+                                       current::ToString(Value(fields.umany_to_omany.Get(row_value, col_value)).phew));
+                  }
+                }
+                EXPECT_EQ("one,1=1 too,2=3 two,2=2", current::strings::Join(data_vec, ' '));
+                data_vec.clear();
+                std::multiset<std::string> cols;
+                for (const auto col : fields.omany_to_umany.Cols()) {
+                  cols.insert(current::storage::sfinae::GetCol(*col.begin()));
+                }
+                for (const auto& col : cols) {
+                  for (const auto& element : fields.omany_to_umany.Col(col)) {
+                    data_vec.push_back(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
+                                       current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
+                                       current::ToString(element.phew));
+                  }
+                }
+                EXPECT_EQ("one,1=1 too,2=3 two,2=2", current::strings::Join(data_vec, ' '));
+              })
+              .Go();
       EXPECT_TRUE(WasCommitted(result2));
-      const auto result3 = storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-        std::set<std::string> data_set;
-        for (const auto& element : fields.umany_to_umany.Row(2)) {
-          data_set.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                          current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                          current::ToString(element.phew));
-        }
-        EXPECT_EQ("2,too=3 2,two=2", current::strings::Join(data_set, ' '));
-        // Use vector instead of set and expect the same result, because the data is already sorted.
-        std::vector<std::string> data_vec;
-        for (const auto& element : fields.omany_to_omany.Row(2)) {
-          data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                             current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                             current::ToString(element.phew));
-        }
-        EXPECT_EQ("2,too=3 2,two=2", current::strings::Join(data_vec, ' '));
-        data_vec.clear();
-        for (const auto& element : fields.umany_to_omany.Row(2)) {
-          data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                             current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                             current::ToString(element.phew));
-        }
-        EXPECT_EQ("2,too=3 2,two=2", current::strings::Join(data_vec, ' '));
-        data_set.clear();
-        for (const auto& element : fields.omany_to_umany.Row(2)) {
-          data_set.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                          current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                          current::ToString(element.phew));
-        }
-        EXPECT_EQ("2,too=3 2,two=2", current::strings::Join(data_set, ' '));
-      }).Go();
+      const auto result3 =
+          storage
+              ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                std::set<std::string> data_set;
+                for (const auto& element : fields.umany_to_umany.Row(2)) {
+                  data_set.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                  current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                  current::ToString(element.phew));
+                }
+                EXPECT_EQ("2,too=3 2,two=2", current::strings::Join(data_set, ' '));
+                // Use vector instead of set and expect the same result, because the data is already sorted.
+                std::vector<std::string> data_vec;
+                for (const auto& element : fields.omany_to_omany.Row(2)) {
+                  data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                     current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                     current::ToString(element.phew));
+                }
+                EXPECT_EQ("2,too=3 2,two=2", current::strings::Join(data_vec, ' '));
+                data_vec.clear();
+                for (const auto& element : fields.umany_to_omany.Row(2)) {
+                  data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                     current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                     current::ToString(element.phew));
+                }
+                EXPECT_EQ("2,too=3 2,two=2", current::strings::Join(data_vec, ' '));
+                data_set.clear();
+                for (const auto& element : fields.omany_to_umany.Row(2)) {
+                  data_set.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                  current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                  current::ToString(element.phew));
+                }
+                EXPECT_EQ("2,too=3 2,two=2", current::strings::Join(data_set, ' '));
+              })
+              .Go();
       EXPECT_TRUE(WasCommitted(result3));
     }
 
     // Iterate over a `OneToOne`, compare its ordered and unordered versions.
     {
-      const auto result1 = storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-        EXPECT_FALSE(fields.uone_to_uone.Empty());
-        EXPECT_FALSE(fields.oone_to_oone.Empty());
-        std::multiset<std::string> data_set;
-        for (const auto& element : fields.uone_to_uone.Rows()) {
-          data_set.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                          current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                          current::ToString(element.phew));
-        }
-        EXPECT_EQ("1,one=1 3,too=4 4,fiv=5", current::strings::Join(data_set, ' '));
-        // Use vector instead of set and expect the same result, because the data is already sorted.
-        std::vector<std::string> data_vec;
-        for (const auto& element : fields.oone_to_oone.Rows()) {
-          data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                             current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                             current::ToString(element.phew));
-        }
-        EXPECT_EQ("1,one=1 3,too=4 4,fiv=5", current::strings::Join(data_vec, ' '));
-        data_set.clear();
-        for (const auto& element : fields.uone_to_oone.Rows()) {
-          data_set.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                          current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                          current::ToString(element.phew));
-        }
-        EXPECT_EQ("1,one=1 3,too=4 4,fiv=5", current::strings::Join(data_set, ' '));
-        data_vec.clear();
-        for (const auto& element : fields.oone_to_uone.Rows()) {
-          data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                             current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                             current::ToString(element.phew));
-        }
-        EXPECT_EQ("1,one=1 3,too=4 4,fiv=5", current::strings::Join(data_vec, ' '));
-      }).Go();
+      const auto result1 =
+          storage
+              ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                EXPECT_FALSE(fields.uone_to_uone.Empty());
+                EXPECT_FALSE(fields.oone_to_oone.Empty());
+                std::multiset<std::string> data_set;
+                for (const auto& element : fields.uone_to_uone.Rows()) {
+                  data_set.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                  current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                  current::ToString(element.phew));
+                }
+                EXPECT_EQ("1,one=1 3,too=4 4,fiv=5", current::strings::Join(data_set, ' '));
+                // Use vector instead of set and expect the same result, because the data is already sorted.
+                std::vector<std::string> data_vec;
+                for (const auto& element : fields.oone_to_oone.Rows()) {
+                  data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                     current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                     current::ToString(element.phew));
+                }
+                EXPECT_EQ("1,one=1 3,too=4 4,fiv=5", current::strings::Join(data_vec, ' '));
+                data_set.clear();
+                for (const auto& element : fields.uone_to_oone.Rows()) {
+                  data_set.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                  current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                  current::ToString(element.phew));
+                }
+                EXPECT_EQ("1,one=1 3,too=4 4,fiv=5", current::strings::Join(data_set, ' '));
+                data_vec.clear();
+                for (const auto& element : fields.oone_to_uone.Rows()) {
+                  data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                     current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                     current::ToString(element.phew));
+                }
+                EXPECT_EQ("1,one=1 3,too=4 4,fiv=5", current::strings::Join(data_vec, ' '));
+              })
+              .Go();
       EXPECT_TRUE(WasCommitted(result1));
-      const auto result2 = storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-        EXPECT_FALSE(fields.uone_to_uone.Empty());
-        EXPECT_FALSE(fields.oone_to_oone.Empty());
-        std::multiset<std::string> data_set;
-        for (const auto& element : fields.uone_to_uone.Cols()) {
-          data_set.insert(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
-                          current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
-                          current::ToString(element.phew));
-        }
-        EXPECT_EQ("fiv,4=5 one,1=1 too,3=4", current::strings::Join(data_set, ' '));
-        // Use vector instead of set and expect the same result, because the data is already sorted.
-        std::vector<std::string> data_vec;
-        for (const auto& element : fields.oone_to_oone.Cols()) {
-          data_vec.push_back(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
-                             current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
-                             current::ToString(element.phew));
-        }
-        EXPECT_EQ("fiv,4=5 one,1=1 too,3=4", current::strings::Join(data_vec, ' '));
-        data_vec.clear();
-        for (const auto& element : fields.uone_to_oone.Cols()) {
-          data_vec.push_back(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
-                             current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
-                             current::ToString(element.phew));
-        }
-        EXPECT_EQ("fiv,4=5 one,1=1 too,3=4", current::strings::Join(data_vec, ' '));
-        data_set.clear();
-        for (const auto& element : fields.oone_to_uone.Cols()) {
-          data_set.insert(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
-                          current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
-                          current::ToString(element.phew));
-        }
-        EXPECT_EQ("fiv,4=5 one,1=1 too,3=4", current::strings::Join(data_set, ' '));
-      }).Go();
+      const auto result2 =
+          storage
+              ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                EXPECT_FALSE(fields.uone_to_uone.Empty());
+                EXPECT_FALSE(fields.oone_to_oone.Empty());
+                std::multiset<std::string> data_set;
+                for (const auto& element : fields.uone_to_uone.Cols()) {
+                  data_set.insert(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
+                                  current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
+                                  current::ToString(element.phew));
+                }
+                EXPECT_EQ("fiv,4=5 one,1=1 too,3=4", current::strings::Join(data_set, ' '));
+                // Use vector instead of set and expect the same result, because the data is already sorted.
+                std::vector<std::string> data_vec;
+                for (const auto& element : fields.oone_to_oone.Cols()) {
+                  data_vec.push_back(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
+                                     current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
+                                     current::ToString(element.phew));
+                }
+                EXPECT_EQ("fiv,4=5 one,1=1 too,3=4", current::strings::Join(data_vec, ' '));
+                data_vec.clear();
+                for (const auto& element : fields.uone_to_oone.Cols()) {
+                  data_vec.push_back(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
+                                     current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
+                                     current::ToString(element.phew));
+                }
+                EXPECT_EQ("fiv,4=5 one,1=1 too,3=4", current::strings::Join(data_vec, ' '));
+                data_set.clear();
+                for (const auto& element : fields.oone_to_uone.Cols()) {
+                  data_set.insert(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
+                                  current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
+                                  current::ToString(element.phew));
+                }
+                EXPECT_EQ("fiv,4=5 one,1=1 too,3=4", current::strings::Join(data_set, ' '));
+              })
+              .Go();
       EXPECT_TRUE(WasCommitted(result2));
     }
 
     // Iterate over a `OneToMany`, compare its ordered and unordered versions.
     {
-      const auto result1 = storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-        EXPECT_FALSE(fields.uone_to_umany.Empty());
-        EXPECT_FALSE(fields.oone_to_omany.Empty());
-        std::multiset<std::string> data_set;
-        for (const auto row : fields.uone_to_umany.Rows()) {
-          for (const auto& element : row) {
-            data_set.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                            current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                            current::ToString(element.phew));
-          }
-        }
-        EXPECT_EQ("1,one=1 1,six=6 2,fiv=10 2,two=4", current::strings::Join(data_set, ' '));
-        // Use vector instead of set and expect the same result, because the data is already sorted.
-        std::vector<std::string> data_vec;
-        for (const auto row : fields.oone_to_omany.Rows()) {
-          for (const auto& element : row) {
-            data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                               current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                               current::ToString(element.phew));
-          }
-        }
-        EXPECT_EQ("1,one=1 1,six=6 2,fiv=10 2,two=4", current::strings::Join(data_vec, ' '));
-        data_vec.clear();
-        std::multiset<int32_t> rows;
-        for (const auto row : fields.uone_to_omany.Rows()) {
-          rows.insert(current::storage::sfinae::GetRow(*row.begin()));
-        }
-        for (const auto& row : rows) {
-          for (const auto& element : fields.uone_to_omany.Row(row)) {
-            data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                               current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                               current::ToString(element.phew));
-          }
-        }
-        EXPECT_EQ("1,one=1 1,six=6 2,fiv=10 2,two=4", current::strings::Join(data_vec, ' '));
-        data_vec.clear();
-        for (const auto row : fields.oone_to_umany.Rows()) {
-          int32_t row_value = current::storage::sfinae::GetRow(*row.begin());
-          std::multiset<std::string> cols;
-          for (const auto& element : row) {
-            cols.insert(current::storage::sfinae::GetCol(element));
-          }
-          for (const auto& col_value : cols) {
-            data_vec.push_back(current::ToString(row_value) + ',' + current::ToString(col_value) + '=' +
-                               current::ToString(Value(fields.oone_to_umany.Get(row_value, col_value)).phew));
-          }
-        }
-        EXPECT_EQ("1,one=1 1,six=6 2,fiv=10 2,two=4", current::strings::Join(data_vec, ' '));
-      }).Go();
+      const auto result1 =
+          storage
+              ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                EXPECT_FALSE(fields.uone_to_umany.Empty());
+                EXPECT_FALSE(fields.oone_to_omany.Empty());
+                std::multiset<std::string> data_set;
+                for (const auto row : fields.uone_to_umany.Rows()) {
+                  for (const auto& element : row) {
+                    data_set.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                    current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                    current::ToString(element.phew));
+                  }
+                }
+                EXPECT_EQ("1,one=1 1,six=6 2,fiv=10 2,two=4", current::strings::Join(data_set, ' '));
+                // Use vector instead of set and expect the same result, because the data is already sorted.
+                std::vector<std::string> data_vec;
+                for (const auto row : fields.oone_to_omany.Rows()) {
+                  for (const auto& element : row) {
+                    data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                       current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                       current::ToString(element.phew));
+                  }
+                }
+                EXPECT_EQ("1,one=1 1,six=6 2,fiv=10 2,two=4", current::strings::Join(data_vec, ' '));
+                data_vec.clear();
+                std::multiset<int32_t> rows;
+                for (const auto row : fields.uone_to_omany.Rows()) {
+                  rows.insert(current::storage::sfinae::GetRow(*row.begin()));
+                }
+                for (const auto& row : rows) {
+                  for (const auto& element : fields.uone_to_omany.Row(row)) {
+                    data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                       current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                       current::ToString(element.phew));
+                  }
+                }
+                EXPECT_EQ("1,one=1 1,six=6 2,fiv=10 2,two=4", current::strings::Join(data_vec, ' '));
+                data_vec.clear();
+                for (const auto row : fields.oone_to_umany.Rows()) {
+                  int32_t row_value = current::storage::sfinae::GetRow(*row.begin());
+                  std::multiset<std::string> cols;
+                  for (const auto& element : row) {
+                    cols.insert(current::storage::sfinae::GetCol(element));
+                  }
+                  for (const auto& col_value : cols) {
+                    data_vec.push_back(current::ToString(row_value) + ',' + current::ToString(col_value) + '=' +
+                                       current::ToString(Value(fields.oone_to_umany.Get(row_value, col_value)).phew));
+                  }
+                }
+                EXPECT_EQ("1,one=1 1,six=6 2,fiv=10 2,two=4", current::strings::Join(data_vec, ' '));
+              })
+              .Go();
       EXPECT_TRUE(WasCommitted(result1));
-      const auto result2 = storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-        EXPECT_FALSE(fields.uone_to_umany.Empty());
-        EXPECT_FALSE(fields.oone_to_omany.Empty());
-        std::multiset<std::string> data_set;
-        for (const auto& element : fields.uone_to_umany.Cols()) {
-          data_set.insert(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
-                          current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
-                          current::ToString(element.phew));
-        }
-        EXPECT_EQ("fiv,2=10 one,1=1 six,1=6 two,2=4", current::strings::Join(data_set, ' '));
-        // Use vector instead of set and expect the same result, because the data is already sorted.
-        std::vector<std::string> data_vec;
-        for (const auto& element : fields.oone_to_omany.Cols()) {
-          data_vec.push_back(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
-                             current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
-                             current::ToString(element.phew));
-        }
-        data_vec.clear();
-        for (const auto& element : fields.uone_to_omany.Cols()) {
-          data_vec.push_back(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
-                             current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
-                             current::ToString(element.phew));
-        }
-        data_set.clear();
-        EXPECT_EQ("fiv,2=10 one,1=1 six,1=6 two,2=4", current::strings::Join(data_vec, ' '));
-        for (const auto& element : fields.oone_to_umany.Cols()) {
-          data_set.insert(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
-                          current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
-                          current::ToString(element.phew));
-        }
-        EXPECT_EQ("fiv,2=10 one,1=1 six,1=6 two,2=4", current::strings::Join(data_set, ' '));
-      }).Go();
+      const auto result2 =
+          storage
+              ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                EXPECT_FALSE(fields.uone_to_umany.Empty());
+                EXPECT_FALSE(fields.oone_to_omany.Empty());
+                std::multiset<std::string> data_set;
+                for (const auto& element : fields.uone_to_umany.Cols()) {
+                  data_set.insert(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
+                                  current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
+                                  current::ToString(element.phew));
+                }
+                EXPECT_EQ("fiv,2=10 one,1=1 six,1=6 two,2=4", current::strings::Join(data_set, ' '));
+                // Use vector instead of set and expect the same result, because the data is already sorted.
+                std::vector<std::string> data_vec;
+                for (const auto& element : fields.oone_to_omany.Cols()) {
+                  data_vec.push_back(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
+                                     current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
+                                     current::ToString(element.phew));
+                }
+                data_vec.clear();
+                for (const auto& element : fields.uone_to_omany.Cols()) {
+                  data_vec.push_back(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
+                                     current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
+                                     current::ToString(element.phew));
+                }
+                data_set.clear();
+                EXPECT_EQ("fiv,2=10 one,1=1 six,1=6 two,2=4", current::strings::Join(data_vec, ' '));
+                for (const auto& element : fields.oone_to_umany.Cols()) {
+                  data_set.insert(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
+                                  current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
+                                  current::ToString(element.phew));
+                }
+                EXPECT_EQ("fiv,2=10 one,1=1 six,1=6 two,2=4", current::strings::Join(data_set, ' '));
+              })
+              .Go();
       EXPECT_TRUE(WasCommitted(result2));
-      const auto result3 = storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-        std::set<std::string> data_set;
-        for (const auto& element : fields.uone_to_umany.Row(2)) {
-          data_set.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                          current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                          current::ToString(element.phew));
-        }
-        EXPECT_EQ("2,fiv=10 2,two=4", current::strings::Join(data_set, ' '));
-        // Use vector instead of set and expect the same result, because the data is already sorted.
-        std::vector<std::string> data_vec;
-        for (const auto& element : fields.oone_to_omany.Row(2)) {
-          data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                             current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                             current::ToString(element.phew));
-        }
-        EXPECT_EQ("2,fiv=10 2,two=4", current::strings::Join(data_vec, ' '));
-        data_vec.clear();
-        for (const auto& element : fields.uone_to_omany.Row(2)) {
-          data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                             current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                             current::ToString(element.phew));
-        }
-        EXPECT_EQ("2,fiv=10 2,two=4", current::strings::Join(data_vec, ' '));
-        data_set.clear();
-        for (const auto& element : fields.oone_to_umany.Row(2)) {
-          data_set.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                          current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                          current::ToString(element.phew));
-        }
-        EXPECT_EQ("2,fiv=10 2,two=4", current::strings::Join(data_set, ' '));
-      }).Go();
+      const auto result3 =
+          storage
+              ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                std::set<std::string> data_set;
+                for (const auto& element : fields.uone_to_umany.Row(2)) {
+                  data_set.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                  current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                  current::ToString(element.phew));
+                }
+                EXPECT_EQ("2,fiv=10 2,two=4", current::strings::Join(data_set, ' '));
+                // Use vector instead of set and expect the same result, because the data is already sorted.
+                std::vector<std::string> data_vec;
+                for (const auto& element : fields.oone_to_omany.Row(2)) {
+                  data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                     current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                     current::ToString(element.phew));
+                }
+                EXPECT_EQ("2,fiv=10 2,two=4", current::strings::Join(data_vec, ' '));
+                data_vec.clear();
+                for (const auto& element : fields.uone_to_omany.Row(2)) {
+                  data_vec.push_back(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                     current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                     current::ToString(element.phew));
+                }
+                EXPECT_EQ("2,fiv=10 2,two=4", current::strings::Join(data_vec, ' '));
+                data_set.clear();
+                for (const auto& element : fields.oone_to_umany.Row(2)) {
+                  data_set.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                  current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                  current::ToString(element.phew));
+                }
+                EXPECT_EQ("2,fiv=10 2,two=4", current::strings::Join(data_set, ' '));
+              })
+              .Go();
       EXPECT_TRUE(WasCommitted(result3));
     }
 
     // Rollback a transaction involving a `ManyToMany`, `OneToOne` and `OneToMany`.
     {
-      const auto result1 = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-        EXPECT_EQ(3u, fields.umany_to_umany.Size());
-        EXPECT_EQ(2u, fields.umany_to_umany.Rows().Size());
-        EXPECT_EQ(3u, fields.umany_to_umany.Cols().Size());
-        EXPECT_EQ(3u, fields.uone_to_uone.Size());
-        EXPECT_EQ(3u, fields.uone_to_uone.Rows().Size());
-        EXPECT_EQ(3u, fields.uone_to_uone.Cols().Size());
-        EXPECT_EQ(4u, fields.uone_to_umany.Size());
-        EXPECT_EQ(2u, fields.uone_to_umany.Rows().Size());
-        EXPECT_EQ(4u, fields.uone_to_umany.Cols().Size());
-
-        fields.d.Add(Record{"one", 100});
-        fields.d.Add(Record{"four", 4});
-        fields.d.Erase("two");
-
-        fields.umany_to_umany.Add(Cell{1, "one", 42});
-        fields.umany_to_umany.Add(Cell{3, "three", 3});
-        fields.umany_to_umany.Erase(2, "two");
-
-        fields.uone_to_uone.Add(Cell{3, "too", 6});  // Adds {3,too=6}, overwrites {3,too=4}
-        fields.uone_to_uone.Add(Cell{4, "for", 4});  // Adds {4,for=4}, removes {4,fiv=5}
-        fields.uone_to_uone.Add(Cell{5, "fiv", 7});  // Adds {5,fiv=7}
-        fields.uone_to_uone.EraseRow(1);
-
-        fields.uone_to_umany.Add(Cell{2, "six", 7});  // Adds {2,six=7}, removes {1,six=6}
-        fields.uone_to_umany.Add(Cell{2, "two", 5});  // Adds {2,two=5}, overwrites {2,two=4}
-        fields.uone_to_umany.Add(Cell{4, "sev", 1});  // Adds {4,sev=1}
-        fields.uone_to_umany.EraseCol("one");         // Removes {1,one=1}
-        fields.uone_to_umany.Erase(2, "fiv");         // Removes {2,fiv=10}
-
-        CURRENT_STORAGE_THROW_ROLLBACK();
-      }).Go();
+      const auto result1 = storage
+                               ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                                 EXPECT_EQ(3u, fields.umany_to_umany.Size());
+                                 EXPECT_EQ(2u, fields.umany_to_umany.Rows().Size());
+                                 EXPECT_EQ(3u, fields.umany_to_umany.Cols().Size());
+                                 EXPECT_EQ(3u, fields.uone_to_uone.Size());
+                                 EXPECT_EQ(3u, fields.uone_to_uone.Rows().Size());
+                                 EXPECT_EQ(3u, fields.uone_to_uone.Cols().Size());
+                                 EXPECT_EQ(4u, fields.uone_to_umany.Size());
+                                 EXPECT_EQ(2u, fields.uone_to_umany.Rows().Size());
+                                 EXPECT_EQ(4u, fields.uone_to_umany.Cols().Size());
+
+                                 fields.d.Add(Record{"one", 100});
+                                 fields.d.Add(Record{"four", 4});
+                                 fields.d.Erase("two");
+
+                                 fields.umany_to_umany.Add(Cell{1, "one", 42});
+                                 fields.umany_to_umany.Add(Cell{3, "three", 3});
+                                 fields.umany_to_umany.Erase(2, "two");
+
+                                 fields.uone_to_uone.Add(Cell{3, "too", 6});  // Adds {3,too=6}, overwrites {3,too=4}
+                                 fields.uone_to_uone.Add(Cell{4, "for", 4});  // Adds {4,for=4}, removes {4,fiv=5}
+                                 fields.uone_to_uone.Add(Cell{5, "fiv", 7});  // Adds {5,fiv=7}
+                                 fields.uone_to_uone.EraseRow(1);
+
+                                 fields.uone_to_umany.Add(Cell{2, "six", 7});  // Adds {2,six=7}, removes {1,six=6}
+                                 fields.uone_to_umany.Add(Cell{2, "two", 5});  // Adds {2,two=5}, overwrites {2,two=4}
+                                 fields.uone_to_umany.Add(Cell{4, "sev", 1});  // Adds {4,sev=1}
+                                 fields.uone_to_umany.EraseCol("one");         // Removes {1,one=1}
+                                 fields.uone_to_umany.Erase(2, "fiv");         // Removes {2,fiv=10}
+
+                                 CURRENT_STORAGE_THROW_ROLLBACK();
+                               })
+                               .Go();
       EXPECT_FALSE(WasCommitted(result1));
 
-      const auto result2 = storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-        EXPECT_EQ(3u, fields.umany_to_umany.Size());
-        EXPECT_EQ(2u, fields.umany_to_umany.Rows().Size());
-        EXPECT_EQ(3u, fields.umany_to_umany.Cols().Size());
-
-        EXPECT_EQ(3u, fields.uone_to_uone.Size());
-        EXPECT_EQ(3u, fields.uone_to_uone.Rows().Size());
-        EXPECT_EQ(3u, fields.uone_to_uone.Cols().Size());
-        EXPECT_FALSE(fields.uone_to_uone.Cols().Has("three"));
-        EXPECT_TRUE(fields.uone_to_uone.Rows().Has(3));
-        EXPECT_TRUE(fields.uone_to_uone.Cols().Has("one"));
-
-        EXPECT_EQ(4u, fields.uone_to_umany.Size());
-        EXPECT_EQ(2u, fields.uone_to_umany.Rows().Size());
-        EXPECT_EQ(4u, fields.uone_to_umany.Cols().Size());
-        EXPECT_FALSE(fields.uone_to_umany.Rows().Has(4));
-        EXPECT_FALSE(fields.uone_to_umany.Cols().Has("sev"));
-        EXPECT_TRUE(fields.uone_to_umany.Rows().Has(1));
-        EXPECT_TRUE(fields.uone_to_umany.Cols().Has("fiv"));
-      }).Go();
+      const auto result2 = storage
+                               ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                                 EXPECT_EQ(3u, fields.umany_to_umany.Size());
+                                 EXPECT_EQ(2u, fields.umany_to_umany.Rows().Size());
+                                 EXPECT_EQ(3u, fields.umany_to_umany.Cols().Size());
+
+                                 EXPECT_EQ(3u, fields.uone_to_uone.Size());
+                                 EXPECT_EQ(3u, fields.uone_to_uone.Rows().Size());
+                                 EXPECT_EQ(3u, fields.uone_to_uone.Cols().Size());
+                                 EXPECT_FALSE(fields.uone_to_uone.Cols().Has("three"));
+                                 EXPECT_TRUE(fields.uone_to_uone.Rows().Has(3));
+                                 EXPECT_TRUE(fields.uone_to_uone.Cols().Has("one"));
+
+                                 EXPECT_EQ(4u, fields.uone_to_umany.Size());
+                                 EXPECT_EQ(2u, fields.uone_to_umany.Rows().Size());
+                                 EXPECT_EQ(4u, fields.uone_to_umany.Cols().Size());
+                                 EXPECT_FALSE(fields.uone_to_umany.Rows().Has(4));
+                                 EXPECT_FALSE(fields.uone_to_umany.Cols().Has("sev"));
+                                 EXPECT_TRUE(fields.uone_to_umany.Rows().Has(1));
+                                 EXPECT_TRUE(fields.uone_to_umany.Cols().Has("fiv"));
+                               })
+                               .Go();
       EXPECT_TRUE(WasCommitted(result2));
     }
 
     // Iterate over a `ManyToMany` with deleted elements, confirm the integrity of `forward_` and `transposed_`.
     {
-      const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-        EXPECT_TRUE(fields.umany_to_umany.Rows().Has(2));
-        EXPECT_TRUE(fields.umany_to_umany.Cols().Has("two"));
-        EXPECT_TRUE(fields.umany_to_umany.Cols().Has("too"));
-
-        fields.umany_to_umany.Erase(2, "two");
-        EXPECT_TRUE(fields.umany_to_umany.Rows().Has(2));  // Still has another "2" left, the {2, "too"} key.
-        EXPECT_FALSE(fields.umany_to_umany.Cols().Has("two"));
-        EXPECT_TRUE(fields.umany_to_umany.Cols().Has("too"));
-        EXPECT_EQ(2u, fields.umany_to_umany.Rows().Size());
-        EXPECT_EQ(2u, fields.umany_to_umany.Cols().Size());
-
-        fields.umany_to_umany.Erase(2, "too");
-        EXPECT_FALSE(fields.umany_to_umany.Rows().Has(2));
-        EXPECT_FALSE(fields.umany_to_umany.Cols().Has("two"));
-        EXPECT_FALSE(fields.umany_to_umany.Cols().Has("too"));
-        EXPECT_EQ(1u, fields.umany_to_umany.Rows().Size());
-        EXPECT_EQ(1u, fields.umany_to_umany.Cols().Size());
-
-        std::multiset<std::string> data1;
-        std::multiset<std::string> data2;
-        for (const auto row : fields.umany_to_umany.Rows()) {
-          for (const auto& element : row) {
-            data1.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                         current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                         current::ToString(element.phew));
-          }
-        }
-        for (const auto col : fields.umany_to_umany.Cols()) {
-          for (const auto& element : col) {
-            data2.insert(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
-                         current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
-                         current::ToString(element.phew));
-          }
-        }
-
-        EXPECT_EQ("1,one=1", current::strings::Join(data1, ' '));
-        EXPECT_EQ("one,1=1", current::strings::Join(data2, ' '));
-
-        CURRENT_STORAGE_THROW_ROLLBACK();
-      }).Go();
+      const auto result =
+          storage
+              ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                EXPECT_TRUE(fields.umany_to_umany.Rows().Has(2));
+                EXPECT_TRUE(fields.umany_to_umany.Cols().Has("two"));
+                EXPECT_TRUE(fields.umany_to_umany.Cols().Has("too"));
+
+                fields.umany_to_umany.Erase(2, "two");
+                EXPECT_TRUE(fields.umany_to_umany.Rows().Has(2));  // Still has another "2" left, the {2, "too"} key.
+                EXPECT_FALSE(fields.umany_to_umany.Cols().Has("two"));
+                EXPECT_TRUE(fields.umany_to_umany.Cols().Has("too"));
+                EXPECT_EQ(2u, fields.umany_to_umany.Rows().Size());
+                EXPECT_EQ(2u, fields.umany_to_umany.Cols().Size());
+
+                fields.umany_to_umany.Erase(2, "too");
+                EXPECT_FALSE(fields.umany_to_umany.Rows().Has(2));
+                EXPECT_FALSE(fields.umany_to_umany.Cols().Has("two"));
+                EXPECT_FALSE(fields.umany_to_umany.Cols().Has("too"));
+                EXPECT_EQ(1u, fields.umany_to_umany.Rows().Size());
+                EXPECT_EQ(1u, fields.umany_to_umany.Cols().Size());
+
+                std::multiset<std::string> data1;
+                std::multiset<std::string> data2;
+                for (const auto row : fields.umany_to_umany.Rows()) {
+                  for (const auto& element : row) {
+                    data1.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                 current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                 current::ToString(element.phew));
+                  }
+                }
+                for (const auto col : fields.umany_to_umany.Cols()) {
+                  for (const auto& element : col) {
+                    data2.insert(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
+                                 current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
+                                 current::ToString(element.phew));
+                  }
+                }
+
+                EXPECT_EQ("1,one=1", current::strings::Join(data1, ' '));
+                EXPECT_EQ("one,1=1", current::strings::Join(data2, ' '));
+
+                CURRENT_STORAGE_THROW_ROLLBACK();
+              })
+              .Go();
       EXPECT_FALSE(WasCommitted(result));
     }
 
     // Iterate over a `OneToOne` with deleted elements, confirm the integrity of `forward_` and `transposed_`.
     {
-      const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-        EXPECT_TRUE(fields.uone_to_uone.Rows().Has(1));
-        EXPECT_TRUE(fields.uone_to_uone.Cols().Has("one"));
-        EXPECT_TRUE(fields.uone_to_uone.Cols().Has("too"));
-
-        fields.uone_to_uone.Add(Cell{3, "two", 5});
-        EXPECT_TRUE(fields.uone_to_uone.Rows().Has(3));
-        EXPECT_FALSE(fields.uone_to_uone.Cols().Has("too"));
-        EXPECT_TRUE(fields.uone_to_uone.Cols().Has("two"));
-        EXPECT_EQ(3u, fields.uone_to_uone.Rows().Size());
-        EXPECT_EQ(3u, fields.uone_to_uone.Cols().Size());
-
-        fields.uone_to_uone.EraseCol("two");
-        EXPECT_FALSE(fields.uone_to_uone.Rows().Has(3));
-        EXPECT_FALSE(fields.uone_to_uone.Cols().Has("too"));
-        EXPECT_FALSE(fields.uone_to_uone.Cols().Has("two"));
-        EXPECT_EQ(2u, fields.uone_to_uone.Rows().Size());
-        EXPECT_EQ(2u, fields.uone_to_uone.Cols().Size());
-
-        std::multiset<std::string> rows;
-        std::multiset<std::string> cols;
-        for (const auto& element : fields.uone_to_uone.Rows()) {
-          rows.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                      current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                      current::ToString(element.phew));
-        }
-        for (const auto& element : fields.uone_to_uone.Cols()) {
-          cols.insert(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
-                      current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
-                      current::ToString(element.phew));
-        }
-
-        EXPECT_EQ("1,one=1 4,fiv=5", current::strings::Join(rows, ' '));
-        EXPECT_EQ("fiv,4=5 one,1=1", current::strings::Join(cols, ' '));
-
-        CURRENT_STORAGE_THROW_ROLLBACK();
-      }).Go();
+      const auto result = storage
+                              ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                                EXPECT_TRUE(fields.uone_to_uone.Rows().Has(1));
+                                EXPECT_TRUE(fields.uone_to_uone.Cols().Has("one"));
+                                EXPECT_TRUE(fields.uone_to_uone.Cols().Has("too"));
+
+                                fields.uone_to_uone.Add(Cell{3, "two", 5});
+                                EXPECT_TRUE(fields.uone_to_uone.Rows().Has(3));
+                                EXPECT_FALSE(fields.uone_to_uone.Cols().Has("too"));
+                                EXPECT_TRUE(fields.uone_to_uone.Cols().Has("two"));
+                                EXPECT_EQ(3u, fields.uone_to_uone.Rows().Size());
+                                EXPECT_EQ(3u, fields.uone_to_uone.Cols().Size());
+
+                                fields.uone_to_uone.EraseCol("two");
+                                EXPECT_FALSE(fields.uone_to_uone.Rows().Has(3));
+                                EXPECT_FALSE(fields.uone_to_uone.Cols().Has("too"));
+                                EXPECT_FALSE(fields.uone_to_uone.Cols().Has("two"));
+                                EXPECT_EQ(2u, fields.uone_to_uone.Rows().Size());
+                                EXPECT_EQ(2u, fields.uone_to_uone.Cols().Size());
+
+                                std::multiset<std::string> rows;
+                                std::multiset<std::string> cols;
+                                for (const auto& element : fields.uone_to_uone.Rows()) {
+                                  rows.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                              current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                              current::ToString(element.phew));
+                                }
+                                for (const auto& element : fields.uone_to_uone.Cols()) {
+                                  cols.insert(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
+                                              current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
+                                              current::ToString(element.phew));
+                                }
+
+                                EXPECT_EQ("1,one=1 4,fiv=5", current::strings::Join(rows, ' '));
+                                EXPECT_EQ("fiv,4=5 one,1=1", current::strings::Join(cols, ' '));
+
+                                CURRENT_STORAGE_THROW_ROLLBACK();
+                              })
+                              .Go();
       EXPECT_FALSE(WasCommitted(result));
     }
 
     // Iterate over a `OneToMany` with deleted elements, confirm the integrity of `forward_` and `transposed_`.
     {
-      const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-        EXPECT_TRUE(fields.uone_to_umany.Rows().Has(1));
-        EXPECT_TRUE(fields.uone_to_umany.Cols().Has("six"));
-        EXPECT_TRUE(fields.uone_to_umany.Cols().Has("one"));
-
-        fields.uone_to_umany.Add(Cell{3, "one", 6});  // Adds {3,one=6}, removes {1,one=1}
-        EXPECT_TRUE(fields.uone_to_umany.Rows().Has(3));
-        EXPECT_TRUE(fields.uone_to_umany.Rows().Has(1));  // There is still {1,six=6}
-        EXPECT_EQ(3u, fields.uone_to_umany.Rows().Size());
-        EXPECT_EQ(4u, fields.uone_to_umany.Cols().Size());
-
-        fields.uone_to_umany.EraseCol("six");
-        EXPECT_FALSE(fields.uone_to_umany.Rows().Has(1));
-        EXPECT_FALSE(fields.uone_to_umany.Cols().Has("six"));
-        EXPECT_EQ(2u, fields.uone_to_umany.Rows().Size());
-        EXPECT_EQ(3u, fields.uone_to_umany.Cols().Size());
-
-        std::multiset<std::string> rows;
-        std::multiset<std::string> cols;
-        for (const auto row : fields.uone_to_umany.Rows()) {
-          for (const auto& element : row) {
-            rows.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
-                        current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
-                        current::ToString(element.phew));
-          }
-        }
-        for (const auto& element : fields.uone_to_umany.Cols()) {
-          cols.insert(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
-                      current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
-                      current::ToString(element.phew));
-        }
-
-        EXPECT_EQ("2,fiv=10 2,two=4 3,one=6", current::strings::Join(rows, ' '));
-        EXPECT_EQ("fiv,2=10 one,3=6 two,2=4", current::strings::Join(cols, ' '));
-
-        CURRENT_STORAGE_THROW_ROLLBACK();
-      }).Go();
+      const auto result = storage
+                              ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                                EXPECT_TRUE(fields.uone_to_umany.Rows().Has(1));
+                                EXPECT_TRUE(fields.uone_to_umany.Cols().Has("six"));
+                                EXPECT_TRUE(fields.uone_to_umany.Cols().Has("one"));
+
+                                fields.uone_to_umany.Add(Cell{3, "one", 6});  // Adds {3,one=6}, removes {1,one=1}
+                                EXPECT_TRUE(fields.uone_to_umany.Rows().Has(3));
+                                EXPECT_TRUE(fields.uone_to_umany.Rows().Has(1));  // There is still {1,six=6}
+                                EXPECT_EQ(3u, fields.uone_to_umany.Rows().Size());
+                                EXPECT_EQ(4u, fields.uone_to_umany.Cols().Size());
+
+                                fields.uone_to_umany.EraseCol("six");
+                                EXPECT_FALSE(fields.uone_to_umany.Rows().Has(1));
+                                EXPECT_FALSE(fields.uone_to_umany.Cols().Has("six"));
+                                EXPECT_EQ(2u, fields.uone_to_umany.Rows().Size());
+                                EXPECT_EQ(3u, fields.uone_to_umany.Cols().Size());
+
+                                std::multiset<std::string> rows;
+                                std::multiset<std::string> cols;
+                                for (const auto row : fields.uone_to_umany.Rows()) {
+                                  for (const auto& element : row) {
+                                    rows.insert(current::ToString(current::storage::sfinae::GetRow(element)) + ',' +
+                                                current::ToString(current::storage::sfinae::GetCol(element)) + '=' +
+                                                current::ToString(element.phew));
+                                  }
+                                }
+                                for (const auto& element : fields.uone_to_umany.Cols()) {
+                                  cols.insert(current::ToString(current::storage::sfinae::GetCol(element)) + ',' +
+                                              current::ToString(current::storage::sfinae::GetRow(element)) + '=' +
+                                              current::ToString(element.phew));
+                                }
+
+                                EXPECT_EQ("2,fiv=10 2,two=4 3,one=6", current::strings::Join(rows, ' '));
+                                EXPECT_EQ("fiv,2=10 one,3=6 two,2=4", current::strings::Join(cols, ' '));
+
+                                CURRENT_STORAGE_THROW_ROLLBACK();
+                              })
+                              .Go();
       EXPECT_FALSE(WasCommitted(result));
     }
 
@@ -804,59 +853,61 @@ TEST(TransactionalStorage, SmokeTest) {
       std::this_thread::yield();
     }
 
-    const auto result = replayed->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-      EXPECT_FALSE(fields.d.Empty());
-      EXPECT_EQ(2u, fields.d.Size());
-      EXPECT_EQ(1, Value(fields.d["one"]).rhs);
-      EXPECT_EQ(2, Value(fields.d["two"]).rhs);
-      EXPECT_FALSE(Exists(fields.d["three"]));
-
-      EXPECT_FALSE(fields.umany_to_umany.Empty());
-      EXPECT_EQ(3u, fields.umany_to_umany.Size());
-      EXPECT_EQ(1, Value(fields.umany_to_umany.Get(1, "one")).phew);
-      EXPECT_EQ(2, Value(fields.umany_to_umany.Get(2, "two")).phew);
-      EXPECT_EQ(3, Value(fields.umany_to_umany.Get(2, "too")).phew);
-      EXPECT_FALSE(Exists(fields.umany_to_umany.Get(3, "three")));
-
-      EXPECT_FALSE(fields.uone_to_uone.Empty());
-      EXPECT_EQ(3u, fields.uone_to_uone.Size());
-      EXPECT_EQ(1, Value(fields.uone_to_uone.Get(1, "one")).phew);
-      EXPECT_EQ(1, Value(fields.uone_to_uone.GetEntryFromCol("one")).phew);
-      EXPECT_EQ(4, Value(fields.uone_to_uone.Get(3, "too")).phew);
-      EXPECT_EQ(4, Value(fields.uone_to_uone.GetEntryFromRow(3)).phew);
-      EXPECT_EQ(5, Value(fields.uone_to_uone.Get(4, "fiv")).phew);
-      EXPECT_EQ(5, Value(fields.uone_to_uone.GetEntryFromCol("fiv")).phew);
-      EXPECT_FALSE(Exists(fields.uone_to_uone.Get(2, "two")));
-      EXPECT_FALSE(Exists(fields.uone_to_uone.GetEntryFromRow(2)));
-      EXPECT_FALSE(Exists(fields.uone_to_uone.GetEntryFromCol("two")));
-      EXPECT_FALSE(Exists(fields.uone_to_uone.Get(2, "too")));
-      EXPECT_TRUE(Exists(fields.uone_to_uone.GetEntryFromCol("too")));
-      EXPECT_FALSE(Exists(fields.uone_to_uone.GetEntryFromCol("three")));
-      EXPECT_TRUE(Exists(fields.uone_to_uone.GetEntryFromRow(4)));
-      EXPECT_FALSE(fields.uone_to_uone.Cols().Has("three"));
-      EXPECT_TRUE(fields.uone_to_uone.Cols().Has("too"));
-
-      EXPECT_FALSE(fields.uone_to_umany.Empty());
-      EXPECT_EQ(4u, fields.uone_to_umany.Size());
-      EXPECT_EQ(1, Value(fields.uone_to_umany.Get(1, "one")).phew);
-      EXPECT_EQ(1, Value(fields.uone_to_umany.GetEntryFromCol("one")).phew);
-      EXPECT_EQ(4, Value(fields.uone_to_umany.Get(2, "two")).phew);
-      EXPECT_EQ(4, Value(fields.uone_to_umany.GetEntryFromCol("two")).phew);
-      EXPECT_EQ(6, Value(fields.uone_to_umany.Get(1, "six")).phew);
-      EXPECT_EQ(6, Value(fields.uone_to_umany.GetEntryFromCol("six")).phew);
-      EXPECT_EQ(10, Value(fields.uone_to_umany.Get(2, "fiv")).phew);
-      EXPECT_EQ(10, Value(fields.uone_to_umany.GetEntryFromCol("fiv")).phew);
-      EXPECT_FALSE(Exists(fields.uone_to_umany.Get(3, "six")));
-      EXPECT_FALSE(Exists(fields.uone_to_umany.GetEntryFromCol("sev")));
-      EXPECT_FALSE(Exists(fields.uone_to_umany.Get(4, "sev")));
-      EXPECT_TRUE(Exists(fields.uone_to_umany.GetEntryFromCol("one")));
-      EXPECT_FALSE(Exists(fields.uone_to_umany.GetEntryFromCol("too")));
-      EXPECT_TRUE(Exists(fields.uone_to_umany.Get(2, "two")));
-      EXPECT_FALSE(fields.uone_to_umany.Cols().Has("sev"));
-      EXPECT_TRUE(fields.uone_to_umany.Cols().Has("fiv"));
-      EXPECT_FALSE(fields.uone_to_umany.Rows().Has(3));
-      EXPECT_TRUE(fields.uone_to_umany.Rows().Has(2));
-    }).Go();
+    const auto result = replayed
+                            ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                              EXPECT_FALSE(fields.d.Empty());
+                              EXPECT_EQ(2u, fields.d.Size());
+                              EXPECT_EQ(1, Value(fields.d["one"]).rhs);
+                              EXPECT_EQ(2, Value(fields.d["two"]).rhs);
+                              EXPECT_FALSE(Exists(fields.d["three"]));
+
+                              EXPECT_FALSE(fields.umany_to_umany.Empty());
+                              EXPECT_EQ(3u, fields.umany_to_umany.Size());
+                              EXPECT_EQ(1, Value(fields.umany_to_umany.Get(1, "one")).phew);
+                              EXPECT_EQ(2, Value(fields.umany_to_umany.Get(2, "two")).phew);
+                              EXPECT_EQ(3, Value(fields.umany_to_umany.Get(2, "too")).phew);
+                              EXPECT_FALSE(Exists(fields.umany_to_umany.Get(3, "three")));
+
+                              EXPECT_FALSE(fields.uone_to_uone.Empty());
+                              EXPECT_EQ(3u, fields.uone_to_uone.Size());
+                              EXPECT_EQ(1, Value(fields.uone_to_uone.Get(1, "one")).phew);
+                              EXPECT_EQ(1, Value(fields.uone_to_uone.GetEntryFromCol("one")).phew);
+                              EXPECT_EQ(4, Value(fields.uone_to_uone.Get(3, "too")).phew);
+                              EXPECT_EQ(4, Value(fields.uone_to_uone.GetEntryFromRow(3)).phew);
+                              EXPECT_EQ(5, Value(fields.uone_to_uone.Get(4, "fiv")).phew);
+                              EXPECT_EQ(5, Value(fields.uone_to_uone.GetEntryFromCol("fiv")).phew);
+                              EXPECT_FALSE(Exists(fields.uone_to_uone.Get(2, "two")));
+                              EXPECT_FALSE(Exists(fields.uone_to_uone.GetEntryFromRow(2)));
+                              EXPECT_FALSE(Exists(fields.uone_to_uone.GetEntryFromCol("two")));
+                              EXPECT_FALSE(Exists(fields.uone_to_uone.Get(2, "too")));
+                              EXPECT_TRUE(Exists(fields.uone_to_uone.GetEntryFromCol("too")));
+                              EXPECT_FALSE(Exists(fields.uone_to_uone.GetEntryFromCol("three")));
+                              EXPECT_TRUE(Exists(fields.uone_to_uone.GetEntryFromRow(4)));
+                              EXPECT_FALSE(fields.uone_to_uone.Cols().Has("three"));
+                              EXPECT_TRUE(fields.uone_to_uone.Cols().Has("too"));
+
+                              EXPECT_FALSE(fields.uone_to_umany.Empty());
+                              EXPECT_EQ(4u, fields.uone_to_umany.Size());
+                              EXPECT_EQ(1, Value(fields.uone_to_umany.Get(1, "one")).phew);
+                              EXPECT_EQ(1, Value(fields.uone_to_umany.GetEntryFromCol("one")).phew);
+                              EXPECT_EQ(4, Value(fields.uone_to_umany.Get(2, "two")).phew);
+                              EXPECT_EQ(4, Value(fields.uone_to_umany.GetEntryFromCol("two")).phew);
+                              EXPECT_EQ(6, Value(fields.uone_to_umany.Get(1, "six")).phew);
+                              EXPECT_EQ(6, Value(fields.uone_to_umany.GetEntryFromCol("six")).phew);
+                              EXPECT_EQ(10, Value(fields.uone_to_umany.Get(2, "fiv")).phew);
+                              EXPECT_EQ(10, Value(fields.uone_to_umany.GetEntryFromCol("fiv")).phew);
+                              EXPECT_FALSE(Exists(fields.uone_to_umany.Get(3, "six")));
+                              EXPECT_FALSE(Exists(fields.uone_to_umany.GetEntryFromCol("sev")));
+                              EXPECT_FALSE(Exists(fields.uone_to_umany.Get(4, "sev")));
+                              EXPECT_TRUE(Exists(fields.uone_to_umany.GetEntryFromCol("one")));
+                              EXPECT_FALSE(Exists(fields.uone_to_umany.GetEntryFromCol("too")));
+                              EXPECT_TRUE(Exists(fields.uone_to_umany.Get(2, "two")));
+                              EXPECT_FALSE(fields.uone_to_umany.Cols().Has("sev"));
+                              EXPECT_TRUE(fields.uone_to_umany.Cols().Has("fiv"));
+                              EXPECT_FALSE(fields.uone_to_umany.Rows().Has(3));
+                              EXPECT_TRUE(fields.uone_to_umany.Rows().Has(2));
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
   }
 }
@@ -866,21 +917,23 @@ TEST(TransactionalStorage, ExposedFieldNames) {
   using storage_t = TestStorage<StreamInMemoryStreamPersister>;
 
   auto storage = storage_t::CreateMasterStorage();
-  const auto result = storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-    EXPECT_EQ("d", fields.d.FieldName());
-    EXPECT_EQ("umany_to_umany", fields.umany_to_umany.FieldName());
-    EXPECT_EQ("omany_to_omany", fields.omany_to_omany.FieldName());
-    EXPECT_EQ("umany_to_omany", fields.umany_to_omany.FieldName());
-    EXPECT_EQ("omany_to_umany", fields.omany_to_umany.FieldName());
-    EXPECT_EQ("uone_to_uone", fields.uone_to_uone.FieldName());
-    EXPECT_EQ("oone_to_oone", fields.oone_to_oone.FieldName());
-    EXPECT_EQ("uone_to_oone", fields.uone_to_oone.FieldName());
-    EXPECT_EQ("oone_to_uone", fields.oone_to_uone.FieldName());
-    EXPECT_EQ("uone_to_umany", fields.uone_to_umany.FieldName());
-    EXPECT_EQ("oone_to_omany", fields.oone_to_omany.FieldName());
-    EXPECT_EQ("uone_to_omany", fields.uone_to_omany.FieldName());
-    EXPECT_EQ("oone_to_umany", fields.oone_to_umany.FieldName());
-  }).Go();
+  const auto result = storage
+                          ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                            EXPECT_EQ("d", fields.d.FieldName());
+                            EXPECT_EQ("umany_to_umany", fields.umany_to_umany.FieldName());
+                            EXPECT_EQ("omany_to_omany", fields.omany_to_omany.FieldName());
+                            EXPECT_EQ("umany_to_omany", fields.umany_to_omany.FieldName());
+                            EXPECT_EQ("omany_to_umany", fields.omany_to_umany.FieldName());
+                            EXPECT_EQ("uone_to_uone", fields.uone_to_uone.FieldName());
+                            EXPECT_EQ("oone_to_oone", fields.oone_to_oone.FieldName());
+                            EXPECT_EQ("uone_to_oone", fields.uone_to_oone.FieldName());
+                            EXPECT_EQ("oone_to_uone", fields.oone_to_uone.FieldName());
+                            EXPECT_EQ("uone_to_umany", fields.uone_to_umany.FieldName());
+                            EXPECT_EQ("oone_to_omany", fields.oone_to_omany.FieldName());
+                            EXPECT_EQ("uone_to_omany", fields.uone_to_omany.FieldName());
+                            EXPECT_EQ("oone_to_umany", fields.oone_to_umany.FieldName());
+                          })
+                          .Go();
   ASSERT_TRUE(WasCommitted(result));
 }
 
@@ -1128,17 +1181,20 @@ TEST(TransactionalStorage, TransactionMetaFields) {
 
   current::Owned<storage_t> storage = storage_t::CreateMasterStorage();
   const auto& data = storage->UnderlyingStream()->Data();
-  const auto TransactionByIndex =
-      [&data](uint64_t index) -> const storage_t::transaction_t& { return (*data->Iterate(static_cast<size_t>(index)).begin()).entry; };
+  const auto TransactionByIndex = [&data](uint64_t index) -> const storage_t::transaction_t& {
+    return (*data->Iterate(static_cast<size_t>(index)).begin()).entry;
+  };
 
   // Try to delete nonexistent entry, setting `who` transaction meta field.
   // No state should be changed as a result of executing the transaction.
   {
     current::time::SetNow(std::chrono::microseconds(100));
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      fields.d.Erase("nonexistent");
-      fields.SetTransactionMetaField("who", "anyone");
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              fields.d.Erase("nonexistent");
+                              fields.SetTransactionMetaField("who", "anyone");
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
   }
 
@@ -1146,17 +1202,19 @@ TEST(TransactionalStorage, TransactionMetaFields) {
   {
     current::time::SetNow(std::chrono::microseconds(200));
     bool second_step_executed = false;
-    const auto result = storage->ReadWriteTransaction(
-                                     [](MutableFields<storage_t> fields) -> int {
-                                       fields.d.Add(Record{"nonexistent", 0});
-                                       fields.SetTransactionMetaField("where", "here");
-                                       CURRENT_STORAGE_THROW_ROLLBACK_WITH_VALUE(int, 42);
-                                       return 0;
-                                     },
-                                     [&second_step_executed](int v) {
-                                       EXPECT_EQ(42, v);
-                                       second_step_executed = true;
-                                     }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction(
+                                [](MutableFields<storage_t> fields) -> int {
+                                  fields.d.Add(Record{"nonexistent", 0});
+                                  fields.SetTransactionMetaField("where", "here");
+                                  CURRENT_STORAGE_THROW_ROLLBACK_WITH_VALUE(int, 42);
+                                  return 0;
+                                },
+                                [&second_step_executed](int v) {
+                                  EXPECT_EQ(42, v);
+                                  second_step_executed = true;
+                                })
+                            .Go();
     EXPECT_FALSE(WasCommitted(result));
     EXPECT_TRUE(second_step_executed);
   }
@@ -1178,7 +1236,7 @@ TEST(TransactionalStorage, TransactionMetaFields) {
           second_step_executed = true;
         }
         // LCOV_EXCL_STOP
-        );
+    );
     EXPECT_THROW(future.Go(), current::Exception);
     EXPECT_FALSE(second_step_executed);
   }
@@ -1186,10 +1244,12 @@ TEST(TransactionalStorage, TransactionMetaFields) {
   // Add one entry, setting another meta field - `why`.
   {
     current::time::SetNow(std::chrono::microseconds(1000));
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      fields.d.Add(Record{"", 42});
-      fields.SetTransactionMetaField("why", "because");
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              fields.d.Add(Record{"", 42});
+                              fields.SetTransactionMetaField("why", "because");
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
   }
 
@@ -1213,35 +1273,38 @@ TEST(TransactionalStorage, LastModifiedInDictionaryContainer) {
 
   current::Owned<storage_t> storage = storage_t::CreateMasterStorage();
   const auto& data = storage->UnderlyingStream()->Data();
-  const auto TransactionByIndex =
-      [&data](uint64_t index) -> const storage_t::transaction_t& { return (*(data->Iterate(index).begin())).entry; };
+  const auto TransactionByIndex = [&data](uint64_t index) -> const storage_t::transaction_t& {
+    return (*(data->Iterate(index).begin())).entry;
+  };
 
   {
     current::time::SetNow(std::chrono::microseconds(100));
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      ASSERT_FALSE(Exists(fields.d.LastModified("x")));
-      current::time::SetNow(std::chrono::microseconds(101));
-      fields.d.Add(Record{"x", 1});
-      {
-        const auto t = fields.d.LastModified("x");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(101, Value(t).count());
-      }
-      current::time::SetNow(std::chrono::microseconds(102));
-      fields.d.Add(Record{"y", 2});
-      {
-        const auto t = fields.d.LastModified("y");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(102, Value(t).count());
-      }
-      current::time::SetNow(std::chrono::microseconds(103));
-      fields.d.Erase("y");
-      {
-        const auto t = fields.d.LastModified("y");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(103, Value(t).count());
-      }
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              ASSERT_FALSE(Exists(fields.d.LastModified("x")));
+                              current::time::SetNow(std::chrono::microseconds(101));
+                              fields.d.Add(Record{"x", 1});
+                              {
+                                const auto t = fields.d.LastModified("x");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(101, Value(t).count());
+                              }
+                              current::time::SetNow(std::chrono::microseconds(102));
+                              fields.d.Add(Record{"y", 2});
+                              {
+                                const auto t = fields.d.LastModified("y");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(102, Value(t).count());
+                              }
+                              current::time::SetNow(std::chrono::microseconds(103));
+                              fields.d.Erase("y");
+                              {
+                                const auto t = fields.d.LastModified("y");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(103, Value(t).count());
+                              }
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
 
     ASSERT_EQ(1u, data->Size());
@@ -1259,37 +1322,41 @@ TEST(TransactionalStorage, LastModifiedInDictionaryContainer) {
 
   {
     current::time::SetNow(std::chrono::microseconds(200));
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      fields.d.Add(Record{"x", 100});
-      fields.d.Erase("y");
-      fields.d.Add(Record{"z", 3});
-      CURRENT_STORAGE_THROW_ROLLBACK();
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              fields.d.Add(Record{"x", 100});
+                              fields.d.Erase("y");
+                              fields.d.Add(Record{"z", 3});
+                              CURRENT_STORAGE_THROW_ROLLBACK();
+                            })
+                            .Go();
     EXPECT_FALSE(WasCommitted(result));
   }
 
   {
     current::time::SetNow(std::chrono::microseconds(300));
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      {
-        const auto t = fields.d.LastModified("x");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(101, Value(t).count());
-      }
-      {
-        const auto t = fields.d.LastModified("y");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(103, Value(t).count());
-      }
-      EXPECT_FALSE(Exists(fields.d.LastModified("z")));
-      current::time::SetNow(std::chrono::microseconds(301));
-      fields.d.Erase("x");
-      {
-        const auto t = fields.d.LastModified("x");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(301, Value(t).count());
-      }
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              {
+                                const auto t = fields.d.LastModified("x");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(101, Value(t).count());
+                              }
+                              {
+                                const auto t = fields.d.LastModified("y");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(103, Value(t).count());
+                              }
+                              EXPECT_FALSE(Exists(fields.d.LastModified("z")));
+                              current::time::SetNow(std::chrono::microseconds(301));
+                              fields.d.Erase("x");
+                              {
+                                const auto t = fields.d.LastModified("x");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(301, Value(t).count());
+                              }
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
 
     ASSERT_EQ(2u, data->Size());
@@ -1310,35 +1377,38 @@ TEST(TransactionalStorage, LastModifiedInMatrixContainers) {
 
   current::Owned<storage_t> storage = storage_t::CreateMasterStorage();
   const auto& data = storage->UnderlyingStream()->Data();
-  const auto TransactionByIndex =
-      [&data](uint64_t index) -> const storage_t::transaction_t& { return (*(data->Iterate(index).begin())).entry; };
+  const auto TransactionByIndex = [&data](uint64_t index) -> const storage_t::transaction_t& {
+    return (*(data->Iterate(index).begin())).entry;
+  };
 
   {
     current::time::SetNow(std::chrono::microseconds(100));
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      ASSERT_FALSE(Exists(fields.umany_to_umany.LastModified(1, "x")));
-      current::time::SetNow(std::chrono::microseconds(101));
-      fields.umany_to_umany.Add(Cell{1, "x", 1});
-      {
-        const auto t = fields.umany_to_umany.LastModified(1, "x");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(101, Value(t).count());
-      }
-      current::time::SetNow(std::chrono::microseconds(102));
-      fields.uone_to_umany.Add(Cell{1, "x", 1});
-      {
-        const auto t = fields.uone_to_umany.LastModified(1, "x");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(102, Value(t).count());
-      }
-      current::time::SetNow(std::chrono::microseconds(103));
-      fields.uone_to_uone.Add(Cell{1, "x", 1});
-      {
-        const auto t = fields.uone_to_uone.LastModified(1, "x");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(103, Value(t).count());
-      }
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              ASSERT_FALSE(Exists(fields.umany_to_umany.LastModified(1, "x")));
+                              current::time::SetNow(std::chrono::microseconds(101));
+                              fields.umany_to_umany.Add(Cell{1, "x", 1});
+                              {
+                                const auto t = fields.umany_to_umany.LastModified(1, "x");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(101, Value(t).count());
+                              }
+                              current::time::SetNow(std::chrono::microseconds(102));
+                              fields.uone_to_umany.Add(Cell{1, "x", 1});
+                              {
+                                const auto t = fields.uone_to_umany.LastModified(1, "x");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(102, Value(t).count());
+                              }
+                              current::time::SetNow(std::chrono::microseconds(103));
+                              fields.uone_to_uone.Add(Cell{1, "x", 1});
+                              {
+                                const auto t = fields.uone_to_uone.LastModified(1, "x");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(103, Value(t).count());
+                              }
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
 
     ASSERT_EQ(1u, data->Size());
@@ -1356,145 +1426,149 @@ TEST(TransactionalStorage, LastModifiedInMatrixContainers) {
 
   {
     current::time::SetNow(std::chrono::microseconds(200));
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      EXPECT_FALSE(Exists(fields.umany_to_umany.LastModified(1, "y")));
-      EXPECT_FALSE(Exists(fields.uone_to_umany.LastModified(1, "y")));
-      EXPECT_FALSE(Exists(fields.uone_to_uone.LastModified(1, "y")));
-      fields.umany_to_umany.Add(Cell{1, "x", 100});
-      fields.uone_to_umany.Add(Cell{2, "x", 100});
-      fields.uone_to_uone.Add(Cell{2, "y", 100});
-      fields.uone_to_uone.Add(Cell{1, "y", 42});
-      fields.umany_to_umany.Erase(1, "x");
-      fields.uone_to_umany.Erase(2, "x");
-      fields.uone_to_uone.Erase(1, "y");
-      CURRENT_STORAGE_THROW_ROLLBACK();
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              EXPECT_FALSE(Exists(fields.umany_to_umany.LastModified(1, "y")));
+                              EXPECT_FALSE(Exists(fields.uone_to_umany.LastModified(1, "y")));
+                              EXPECT_FALSE(Exists(fields.uone_to_uone.LastModified(1, "y")));
+                              fields.umany_to_umany.Add(Cell{1, "x", 100});
+                              fields.uone_to_umany.Add(Cell{2, "x", 100});
+                              fields.uone_to_uone.Add(Cell{2, "y", 100});
+                              fields.uone_to_uone.Add(Cell{1, "y", 42});
+                              fields.umany_to_umany.Erase(1, "x");
+                              fields.uone_to_umany.Erase(2, "x");
+                              fields.uone_to_uone.Erase(1, "y");
+                              CURRENT_STORAGE_THROW_ROLLBACK();
+                            })
+                            .Go();
     EXPECT_FALSE(WasCommitted(result));
   }
 
   {
     current::time::SetNow(std::chrono::microseconds(300));
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      {
-        const auto t = fields.umany_to_umany.LastModified(1, "x");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(101, Value(t).count());
-      }
-      {
-        const auto t = fields.uone_to_umany.LastModified(1, "x");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(102, Value(t).count());
-      }
-      {
-        const auto t = fields.uone_to_uone.LastModified(1, "x");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(103, Value(t).count());
-      }
-      EXPECT_FALSE(Exists(fields.uone_to_umany.LastModified(2, "x")));
-      EXPECT_FALSE(Exists(fields.uone_to_uone.LastModified(2, "y")));
-      EXPECT_FALSE(Exists(fields.uone_to_uone.LastModified(1, "y")));
-
-      current::time::SetNow(std::chrono::microseconds(301));
-      fields.umany_to_umany.Add(Cell{1, "x", 100});
-      {
-        const auto t = fields.umany_to_umany.LastModified(1, "x");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(301, Value(t).count());
-      }
-      current::time::SetNow(std::chrono::microseconds(302), std::chrono::microseconds(303));
-      fields.uone_to_umany.Add(Cell{2, "x", 100});
-      {
-        const auto removed_t = fields.uone_to_umany.LastModified(1, "x");
-        ASSERT_TRUE(Exists(removed_t));
-        EXPECT_EQ(302, Value(removed_t).count());
-        const auto t = fields.uone_to_umany.LastModified(2, "x");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(303, Value(t).count());
-      }
-      current::time::SetNow(std::chrono::microseconds(304));
-      fields.uone_to_uone.Add(Cell{2, "y", 100});
-      {
-        const auto t = fields.uone_to_uone.LastModified(2, "y");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(304, Value(t).count());
-      }
-      current::time::SetNow(std::chrono::microseconds(305), std::chrono::microseconds(307));
-      fields.uone_to_uone.Add(Cell{1, "y", 42});
-      {
-        const auto removed_t1 = fields.uone_to_uone.LastModified(1, "x");
-        ASSERT_TRUE(Exists(removed_t1));
-        EXPECT_EQ(305, Value(removed_t1).count());
-        const auto removed_t2 = fields.uone_to_uone.LastModified(2, "y");
-        ASSERT_TRUE(Exists(removed_t2));
-        EXPECT_EQ(306, Value(removed_t2).count());
-        const auto t = fields.uone_to_uone.LastModified(1, "y");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(307, Value(t).count());
-      }
-      current::time::SetNow(std::chrono::microseconds(308));
-      fields.umany_to_umany.Erase(1, "x");
-      {
-        const auto t = fields.umany_to_umany.LastModified(1, "x");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(308, Value(t).count());
-      }
-      current::time::SetNow(std::chrono::microseconds(309));
-      fields.uone_to_umany.Add(Cell{42, "z", 42});
-      {
-        const auto t = fields.uone_to_umany.LastModified(42, "z");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(309, Value(t).count());
-      }
-      current::time::SetNow(std::chrono::microseconds(310));
-      fields.uone_to_umany.EraseCol("z");
-      {
-        const auto t = fields.uone_to_umany.LastModified(42, "z");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(310, Value(t).count());
-      }
-      current::time::SetNow(std::chrono::microseconds(311));
-      fields.uone_to_umany.Erase(2, "x");
-      {
-        const auto t = fields.uone_to_umany.LastModified(2, "x");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(311, Value(t).count());
-      }
-      current::time::SetNow(std::chrono::microseconds(312));
-      fields.uone_to_uone.Add(Cell{2, "x", 2});
-      {
-        const auto t = fields.uone_to_uone.LastModified(2, "x");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(312, Value(t).count());
-      }
-      current::time::SetNow(std::chrono::microseconds(313));
-      fields.uone_to_uone.Add(Cell{42, "z", 42});
-      {
-        const auto t = fields.uone_to_uone.LastModified(42, "z");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(313, Value(t).count());
-      }
-      current::time::SetNow(std::chrono::microseconds(314));
-      fields.uone_to_uone.EraseRow(42);
-      {
-        const auto t = fields.uone_to_uone.LastModified(42, "z");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(314, Value(t).count());
-      }
-      current::time::SetNow(std::chrono::microseconds(315));
-      fields.uone_to_uone.EraseCol("x");
-      {
-        const auto t = fields.uone_to_uone.LastModified(2, "x");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(315, Value(t).count());
-      }
-      current::time::SetNow(std::chrono::microseconds(316));
-      fields.uone_to_uone.Erase(1, "y");
-      {
-        const auto t = fields.uone_to_uone.LastModified(1, "y");
-        ASSERT_TRUE(Exists(t));
-        EXPECT_EQ(316, Value(t).count());
-      }
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              {
+                                const auto t = fields.umany_to_umany.LastModified(1, "x");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(101, Value(t).count());
+                              }
+                              {
+                                const auto t = fields.uone_to_umany.LastModified(1, "x");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(102, Value(t).count());
+                              }
+                              {
+                                const auto t = fields.uone_to_uone.LastModified(1, "x");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(103, Value(t).count());
+                              }
+                              EXPECT_FALSE(Exists(fields.uone_to_umany.LastModified(2, "x")));
+                              EXPECT_FALSE(Exists(fields.uone_to_uone.LastModified(2, "y")));
+                              EXPECT_FALSE(Exists(fields.uone_to_uone.LastModified(1, "y")));
+
+                              current::time::SetNow(std::chrono::microseconds(301));
+                              fields.umany_to_umany.Add(Cell{1, "x", 100});
+                              {
+                                const auto t = fields.umany_to_umany.LastModified(1, "x");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(301, Value(t).count());
+                              }
+                              current::time::SetNow(std::chrono::microseconds(302), std::chrono::microseconds(303));
+                              fields.uone_to_umany.Add(Cell{2, "x", 100});
+                              {
+                                const auto removed_t = fields.uone_to_umany.LastModified(1, "x");
+                                ASSERT_TRUE(Exists(removed_t));
+                                EXPECT_EQ(302, Value(removed_t).count());
+                                const auto t = fields.uone_to_umany.LastModified(2, "x");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(303, Value(t).count());
+                              }
+                              current::time::SetNow(std::chrono::microseconds(304));
+                              fields.uone_to_uone.Add(Cell{2, "y", 100});
+                              {
+                                const auto t = fields.uone_to_uone.LastModified(2, "y");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(304, Value(t).count());
+                              }
+                              current::time::SetNow(std::chrono::microseconds(305), std::chrono::microseconds(307));
+                              fields.uone_to_uone.Add(Cell{1, "y", 42});
+                              {
+                                const auto removed_t1 = fields.uone_to_uone.LastModified(1, "x");
+                                ASSERT_TRUE(Exists(removed_t1));
+                                EXPECT_EQ(305, Value(removed_t1).count());
+                                const auto removed_t2 = fields.uone_to_uone.LastModified(2, "y");
+                                ASSERT_TRUE(Exists(removed_t2));
+                                EXPECT_EQ(306, Value(removed_t2).count());
+                                const auto t = fields.uone_to_uone.LastModified(1, "y");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(307, Value(t).count());
+                              }
+                              current::time::SetNow(std::chrono::microseconds(308));
+                              fields.umany_to_umany.Erase(1, "x");
+                              {
+                                const auto t = fields.umany_to_umany.LastModified(1, "x");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(308, Value(t).count());
+                              }
+                              current::time::SetNow(std::chrono::microseconds(309));
+                              fields.uone_to_umany.Add(Cell{42, "z", 42});
+                              {
+                                const auto t = fields.uone_to_umany.LastModified(42, "z");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(309, Value(t).count());
+                              }
+                              current::time::SetNow(std::chrono::microseconds(310));
+                              fields.uone_to_umany.EraseCol("z");
+                              {
+                                const auto t = fields.uone_to_umany.LastModified(42, "z");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(310, Value(t).count());
+                              }
+                              current::time::SetNow(std::chrono::microseconds(311));
+                              fields.uone_to_umany.Erase(2, "x");
+                              {
+                                const auto t = fields.uone_to_umany.LastModified(2, "x");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(311, Value(t).count());
+                              }
+                              current::time::SetNow(std::chrono::microseconds(312));
+                              fields.uone_to_uone.Add(Cell{2, "x", 2});
+                              {
+                                const auto t = fields.uone_to_uone.LastModified(2, "x");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(312, Value(t).count());
+                              }
+                              current::time::SetNow(std::chrono::microseconds(313));
+                              fields.uone_to_uone.Add(Cell{42, "z", 42});
+                              {
+                                const auto t = fields.uone_to_uone.LastModified(42, "z");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(313, Value(t).count());
+                              }
+                              current::time::SetNow(std::chrono::microseconds(314));
+                              fields.uone_to_uone.EraseRow(42);
+                              {
+                                const auto t = fields.uone_to_uone.LastModified(42, "z");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(314, Value(t).count());
+                              }
+                              current::time::SetNow(std::chrono::microseconds(315));
+                              fields.uone_to_uone.EraseCol("x");
+                              {
+                                const auto t = fields.uone_to_uone.LastModified(2, "x");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(315, Value(t).count());
+                              }
+                              current::time::SetNow(std::chrono::microseconds(316));
+                              fields.uone_to_uone.Erase(1, "y");
+                              {
+                                const auto t = fields.uone_to_uone.LastModified(1, "y");
+                                ASSERT_TRUE(Exists(t));
+                                EXPECT_EQ(316, Value(t).count());
+                              }
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
 
     ASSERT_EQ(2u, data->Size());
@@ -1554,8 +1628,9 @@ TEST(TransactionalStorage, WaitUntilLocalLogIsReplayed) {
     master_storage->ReadWriteTransaction([](MutableFields<storage_t> fields) { fields.d.Add(Record{"one", 1}); }).Go();
     master_storage->ReadWriteTransaction([](MutableFields<storage_t> fields) { fields.d.Add(Record{"two", 2}); }).Go();
     master_storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      fields.d.Add(Record{"three", 3});
-    }).Go();
+                    fields.d.Add(Record{"three", 3});
+                  })
+        .Go();
   }
 
   // Test following storage.
@@ -1576,19 +1651,23 @@ TEST(TransactionalStorage, WaitUntilLocalLogIsReplayed) {
     // Wait until the whole log is replayed.
     bool done = false;
     while (!done) {
-      done = Value(storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields)
-                                                    -> bool { return Exists(fields.d["three"]); }).Go());
+      done = Value(
+          storage
+              ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) -> bool { return Exists(fields.d["three"]); })
+              .Go());
     }
 
     // Check the data.
-    const auto result = storage->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
-      EXPECT_TRUE(Exists(fields.d["one"]));
-      EXPECT_EQ(1, Value(fields.d["one"]).rhs);
-      EXPECT_TRUE(Exists(fields.d["two"]));
-      EXPECT_EQ(2, Value(fields.d["two"]).rhs);
-      EXPECT_TRUE(Exists(fields.d["three"]));
-      EXPECT_EQ(3, Value(fields.d["three"]).rhs);
-    }).Go();
+    const auto result = storage
+                            ->ReadOnlyTransaction([](ImmutableFields<storage_t> fields) {
+                              EXPECT_TRUE(Exists(fields.d["one"]));
+                              EXPECT_EQ(1, Value(fields.d["one"]).rhs);
+                              EXPECT_TRUE(Exists(fields.d["two"]));
+                              EXPECT_EQ(2, Value(fields.d["two"]).rhs);
+                              EXPECT_TRUE(Exists(fields.d["three"]));
+                              EXPECT_EQ(3, Value(fields.d["three"]).rhs);
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
 
     // TODO(dkorolev): Test for no write transaction possible?
@@ -1607,18 +1686,22 @@ TEST(TransactionalStorage, WorkWithUnderlyingStream) {
 
   {
     current::time::SetNow(std::chrono::microseconds(100));
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      fields.d.Add(Record{"one", 1});
-      current::time::SetNow(std::chrono::microseconds(101));
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              fields.d.Add(Record{"one", 1});
+                              current::time::SetNow(std::chrono::microseconds(101));
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
   }
   {
     current::time::SetNow(std::chrono::microseconds(200));
-    const auto result = storage->ReadWriteTransaction([](MutableFields<storage_t> fields) {
-      fields.d.Add(Record{"two", 2});
-      current::time::SetNow(std::chrono::microseconds(201));
-    }).Go();
+    const auto result = storage
+                            ->ReadWriteTransaction([](MutableFields<storage_t> fields) {
+                              fields.d.Add(Record{"two", 2});
+                              current::time::SetNow(std::chrono::microseconds(201));
+                            })
+                            .Go();
     EXPECT_TRUE(WasCommitted(result));
   }
 
diff --git a/stream/replicator.h b/stream/replicator.h
index bc4558dc6..21a7537c7 100644
--- a/stream/replicator.h
+++ b/stream/replicator.h
@@ -99,8 +99,9 @@ class SubscribableRemoteStream final {
         opt = "i=" + current::ToString(last_idx);
       }
       opt += "&head=" + current::ToString(head_idxts.head);
-      return url_ + "/control/flip_to_master?" + opt + "&key=" + current::ToString(key) + "&clock=" +
-             current::ToString(current::time::Now().count()) + (mode == SubscriptionMode::Checked ? "&checked" : "");
+      return url_ + "/control/flip_to_master?" + opt + "&key=" + current::ToString(key) +
+             "&clock=" + current::ToString(current::time::Now().count()) +
+             (mode == SubscriptionMode::Checked ? "&checked" : "");
     }
 
    private:
@@ -295,10 +296,11 @@ class SubscribableRemoteStream final {
         }
         try {
           bare_stream.CheckSchema();
-          HTTP(ChunkedGET(bare_stream.GetURLToSubscribe(this->next_expected_index_, this->from_us_, subscription_mode_),
-                          [this](const std::string& header, const std::string& value) { OnHeader(header, value); },
-                          [this](const std::string& chunk_body) { OnChunk(chunk_body); },
-                          [](){}));
+          HTTP(ChunkedGET(
+              bare_stream.GetURLToSubscribe(this->next_expected_index_, this->from_us_, subscription_mode_),
+              [this](const std::string& header, const std::string& value) { OnHeader(header, value); },
+              [this](const std::string& chunk_body) { OnChunk(chunk_body); },
+              []() {}));
         } catch (StreamTerminatedBySubscriber&) {
           break;
         } catch (RemoteStreamMalformedChunkException&) {
@@ -552,12 +554,12 @@ class MasterFlipController final {
     exposed_via_http_ = std::make_unique<ExposedStreamState>(
         port, route, std::move(restrictions), flip_started, flip_finished, flip_canceled);
     exposed_via_http_->routes_scope_ +=
-        HTTP(current::net::BarePort(port)).Register(route,
-                                                    URLPathArgs::CountMask::None | URLPathArgs::CountMask::One,
-                                                    *Value(stream_)) +
-        HTTP(current::net::BarePort(port)).Register(route + "/control/flip_to_master",
-                                                    URLPathArgs::CountMask::None,
-                                                    [this](Request r) { MasterFlipRequest(std::move(r)); });
+        HTTP(current::net::BarePort(port))
+            .Register(route, URLPathArgs::CountMask::None | URLPathArgs::CountMask::One, *Value(stream_)) +
+        HTTP(current::net::BarePort(port))
+            .Register(route + "/control/flip_to_master", URLPathArgs::CountMask::None, [this](Request r) {
+              MasterFlipRequest(std::move(r));
+            });
     return exposed_via_http_->flip_key_;
   }
 
@@ -657,8 +659,7 @@ class MasterFlipController final {
           std::min(stream_->Data()->IndexRangeByTimestampRange(client_head + std::chrono::microseconds(1)).first,
                    Value(head_idxts.idxts).index + 1u);
       if (next_index_by_timestamp != client_next_index) {
-        r("The prospective master's head doesn't match the specified next index.\n",
-          HTTPResponseCode.BadRequest);
+        r("The prospective master's head doesn't match the specified next index.\n", HTTPResponseCode.BadRequest);
         return;
       }
     }
diff --git a/stream/stream.h b/stream/stream.h
index 9dd5938f1..28d241fa7 100644
--- a/stream/stream.h
+++ b/stream/stream.h
@@ -102,8 +102,8 @@ CURRENT_STRUCT(SubscribableStreamSchema) {
   CURRENT_FIELD(namespace_name, std::string);
 
   CURRENT_DEFAULT_CONSTRUCTOR(SubscribableStreamSchema) {}
-  CURRENT_CONSTRUCTOR(SubscribableStreamSchema)(
-      current::reflection::TypeID type_id, const std::string& entry_name, const std::string& namespace_name)
+  CURRENT_CONSTRUCTOR(SubscribableStreamSchema)
+  (current::reflection::TypeID type_id, const std::string& entry_name, const std::string& namespace_name)
       : type_id(type_id), entry_name(entry_name), namespace_name(namespace_name) {}
 
   bool operator==(const SubscribableStreamSchema& rhs) const {
@@ -405,14 +405,12 @@ class Stream final {
         } else {
           std::unique_lock<std::mutex> lock(impl_->publishing_mutex);
           current::WaitableTerminateSignalBulkNotifier::Scope scope(impl_->notifier, terminate_signal_);
-          terminate_signal_.WaitUntil(
-              lock,
-              [this, &index, &begin_idx, &head]() {
-                return terminate_signal_ ||
-                       impl_->persister.template Size<current::locks::MutexLockStatus::AlreadyLocked>() > index ||
-                       (index > begin_idx &&
-                        impl_->persister.template CurrentHead<current::locks::MutexLockStatus::AlreadyLocked>() > head);
-              });
+          terminate_signal_.WaitUntil(lock, [this, &index, &begin_idx, &head]() {
+            return terminate_signal_ ||
+                   impl_->persister.template Size<current::locks::MutexLockStatus::AlreadyLocked>() > index ||
+                   (index > begin_idx &&
+                    impl_->persister.template CurrentHead<current::locks::MutexLockStatus::AlreadyLocked>() > head);
+          });
         }
       }
     }
diff --git a/stream/stream_impl.h b/stream/stream_impl.h
index 893769908..e91033198 100644
--- a/stream/stream_impl.h
+++ b/stream/stream_impl.h
@@ -118,8 +118,7 @@ struct StreamImpl {
   mutable http_subscriptions_t http_subscriptions;
 
   template <typename... ARGS>
-  StreamImpl(ARGS&&... args)
-      : persister(publishing_mutex, std::forward<ARGS>(args)...) {}
+  StreamImpl(ARGS&&... args) : persister(publishing_mutex, std::forward<ARGS>(args)...) {}
 };
 
 template <typename ENTRY, template <typename> class PERSISTENCE_LAYER>
diff --git a/stream/test.cc b/stream/test.cc
index 3e898ed7f..c11e5343a 100644
--- a/stream/test.cc
+++ b/stream/test.cc
@@ -51,10 +51,10 @@ DEFINE_string(stream_test_tmpdir, ".current", "Local path for the test to create
 
 namespace stream_unittest {
 
-using current::strings::Join;
-using current::strings::Printf;
 using current::ss::EntryResponse;
 using current::ss::TerminationResponse;
+using current::strings::Join;
+using current::strings::Printf;
 
 // The records we work with.
 CURRENT_STRUCT(Record) {
@@ -65,9 +65,8 @@ CURRENT_STRUCT(Record) {
 CURRENT_STRUCT(RecordWithTimestamp) {
   CURRENT_FIELD(s, std::string);
   CURRENT_FIELD(t, std::chrono::microseconds);
-  CURRENT_CONSTRUCTOR(RecordWithTimestamp)(std::string s = "",
-                                           std::chrono::microseconds t = std::chrono::microseconds(0ull))
-      : s(s), t(t) {}
+  CURRENT_CONSTRUCTOR(RecordWithTimestamp)
+  (std::string s = "", std::chrono::microseconds t = std::chrono::microseconds(0ull)) : s(s), t(t) {}
   CURRENT_USE_FIELD_AS_TIMESTAMP(t);
 };
 
@@ -512,8 +511,7 @@ TEST(Stream, SubscribeToStreamViaHTTP) {
   const std::string base_url = Printf("http://localhost:%d/exposed", port);
   const auto scope =
       HTTP(port).Register("/exposed", *exposed_stream) +
-      HTTP(port)
-          .Register("/exposed_more", URLPathArgs::CountMask::None | URLPathArgs::CountMask::One, *exposed_stream);
+      HTTP(port).Register("/exposed_more", URLPathArgs::CountMask::None | URLPathArgs::CountMask::One, *exposed_stream);
   const std::string base_url_with_args = Printf("http://localhost:%d/exposed_more", port);
 
   {
@@ -922,17 +920,18 @@ TEST(Stream, HTTPSubscriptionCanBeTerminated) {
   std::atomic_bool chunks_done(false);
 
   std::thread slow_subscriber([&] {
-    const auto result = HTTP(ChunkedGET(base_url,
-                                        [&subscription_id](const std::string& header, const std::string& value) {
-                                          if (header == "X-Current-Stream-Subscription-Id") {
-                                            subscription_id = value;
-                                          }
-                                        },
-                                        [&chunks_count](const std::string& unused_chunk_body) {
-                                          static_cast<void>(unused_chunk_body);
-                                          ++chunks_count;
-                                        },
-                                        [&chunks_done]() { chunks_done = true; }));
+    const auto result = HTTP(ChunkedGET(
+        base_url,
+        [&subscription_id](const std::string& header, const std::string& value) {
+          if (header == "X-Current-Stream-Subscription-Id") {
+            subscription_id = value;
+          }
+        },
+        [&chunks_count](const std::string& unused_chunk_body) {
+          static_cast<void>(unused_chunk_body);
+          ++chunks_count;
+        },
+        [&chunks_done]() { chunks_done = true; }));
     EXPECT_EQ(200, static_cast<int>(result));
   });
 
@@ -1147,16 +1146,16 @@ TEST(Stream, UncheckedVsCheckedSubscription) {
       std::this_thread::yield();
     }
   };
-  const auto CollectUncheckedSubscriptionResult =
-      [&](std::vector<std::string>& rows, std::vector<std::string>& entries) {
-        rows.clear();
-        entries.clear();
-        RecordsUncheckedCollector collector(entries, rows);
-        const auto scope = exposed_stream->SubscribeUnchecked(collector);
-        while (collector.count_ < 3u) {
-          std::this_thread::yield();
-        }
-      };
+  const auto CollectUncheckedSubscriptionResult = [&](std::vector<std::string>& rows,
+                                                      std::vector<std::string>& entries) {
+    rows.clear();
+    entries.clear();
+    RecordsUncheckedCollector collector(entries, rows);
+    const auto scope = exposed_stream->SubscribeUnchecked(collector);
+    while (collector.count_ < 3u) {
+      std::this_thread::yield();
+    }
+  };
 
   {
     std::vector<std::string> all_entries;
@@ -1322,38 +1321,35 @@ TEST(Stream, ParseArbitrarilySplitChunks) {
 
   // Simulate subscription to stream stream.
   const auto scope =
-      HTTP(port)
-          .Register("/log",
-                    URLPathArgs::CountMask::None | URLPathArgs::CountMask::One,
-                    [](Request r) {
-                      EXPECT_EQ("GET", r.method);
-                      const std::string subscription_id = "fake_subscription";
-                      if (r.url.query.has("terminate")) {
-                        EXPECT_EQ(r.url.query["terminate"], subscription_id);
-                        r("", HTTPResponseCode.OK);
-                      } else if (r.url.query.has("i")) {
-                        const auto index = current::FromString<uint64_t>(r.url.query["i"]);
-                        auto response = r.connection.SendChunkedHTTPResponse(
-                            HTTPResponseCode.OK,
-                            current::net::http::Headers({{"X-Current-Stream-Subscription-Id", subscription_id}}),
-                            "text/plain");
-                        if (index == 0u) {
-                          for (const auto& chunk : stream_golden_data_chunks) {
-                            response.Send(chunk);
-                          }
-                        } else {
-                          EXPECT_EQ(3u, index);
-                        }
-                      } else {
-                        EXPECT_EQ(1u, r.url_path_args.size());
-                        EXPECT_EQ("schema.simple", r.url_path_args[0]);
-                        r(current::stream::SubscribableStreamSchema(
-                            Value<current::reflection::ReflectedTypeBase>(
-                                current::reflection::Reflector().ReflectType<Record>()).type_id,
-                            "Record",
-                            "Namespace"));
-                      }
-                    });
+      HTTP(port).Register("/log", URLPathArgs::CountMask::None | URLPathArgs::CountMask::One, [](Request r) {
+        EXPECT_EQ("GET", r.method);
+        const std::string subscription_id = "fake_subscription";
+        if (r.url.query.has("terminate")) {
+          EXPECT_EQ(r.url.query["terminate"], subscription_id);
+          r("", HTTPResponseCode.OK);
+        } else if (r.url.query.has("i")) {
+          const auto index = current::FromString<uint64_t>(r.url.query["i"]);
+          auto response = r.connection.SendChunkedHTTPResponse(
+              HTTPResponseCode.OK,
+              current::net::http::Headers({{"X-Current-Stream-Subscription-Id", subscription_id}}),
+              "text/plain");
+          if (index == 0u) {
+            for (const auto& chunk : stream_golden_data_chunks) {
+              response.Send(chunk);
+            }
+          } else {
+            EXPECT_EQ(3u, index);
+          }
+        } else {
+          EXPECT_EQ(1u, r.url_path_args.size());
+          EXPECT_EQ("schema.simple", r.url_path_args[0]);
+          r(current::stream::SubscribableStreamSchema(
+              Value<current::reflection::ReflectedTypeBase>(current::reflection::Reflector().ReflectType<Record>())
+                  .type_id,
+              "Record",
+              "Namespace"));
+        }
+      });
 
   // Replicate data via subscription to the fake stream.
   current::stream::SubscribableRemoteStream<Record> remote_stream(
@@ -1539,22 +1535,23 @@ TEST(Stream, MasterFollowerFlipRestrictions) {
     const auto stream2_file_remover = current::FileSystem::ScopedRmFile(stream2_file_name);
     current::stream::MasterFlipController<stream_t> stream2(stream_t::CreateStream(stream2_file_name));
 
-    auto flip_key = stream1.ExposeViaHTTP(port1,
-                                          "/exposed",
-                                          current::stream::MasterFlipRestrictions().SetMaxIndexDifference(1),
-                                          // A little trick: we can publish from the `flip_started_callback`,
-                                          // the stream is still master there.
-                                          [&]() {
-                                            flip_started_called = true;
-                                            if (stream1->Data()->Size() < 3) {
-                                              current::time::SetNow(std::chrono::microseconds(30));
-                                              stream1->Publisher()->Publish(Record(3));
-                                              current::time::SetNow(std::chrono::microseconds(40));
-                                              stream1->Publisher()->Publish(Record(4));
-                                            }
-                                          },
-                                          [&]() { flip_finished_called = true; },
-                                          [&]() { flip_canceled_called = true; });
+    auto flip_key = stream1.ExposeViaHTTP(
+        port1,
+        "/exposed",
+        current::stream::MasterFlipRestrictions().SetMaxIndexDifference(1),
+        // A little trick: we can publish from the `flip_started_callback`,
+        // the stream is still master there.
+        [&]() {
+          flip_started_called = true;
+          if (stream1->Data()->Size() < 3) {
+            current::time::SetNow(std::chrono::microseconds(30));
+            stream1->Publisher()->Publish(Record(3));
+            current::time::SetNow(std::chrono::microseconds(40));
+            stream1->Publisher()->Publish(Record(4));
+          }
+        },
+        [&]() { flip_finished_called = true; },
+        [&]() { flip_canceled_called = true; });
     stream2.FollowRemoteStream(base_url1, current::stream::SubscriptionMode::Checked);
     while (stream2->Data()->Size() != stream1->Data()->Size()) {
       std::this_thread::yield();
@@ -1639,21 +1636,22 @@ TEST(Stream, MasterFollowerFlipRestrictions) {
     // Calculate the next entry size (2 stays for \t and \n) to make the restriction just 1 byte smaller.
     const auto entry_size = JSON(Record(55)).length() + JSON(idxts_t(4, std::chrono::microseconds(80))).length() + 2;
 
-    auto flip_key = stream1.ExposeViaHTTP(port1,
-                                          "/exposed",
-                                          current::stream::MasterFlipRestrictions().SetMaxDiffSize(entry_size - 1),
-                                          [&]() {
-                                            flip_started_called = true;
-                                            if (stream1->Data()->CurrentHead() < std::chrono::microseconds(80)) {
-                                              current::time::SetNow(std::chrono::microseconds(80));
-                                              stream1->Publisher()->Publish(Record(55));
-                                            } else if (stream1->Data()->CurrentHead() < std::chrono::microseconds(90)) {
-                                              current::time::SetNow(std::chrono::microseconds(90));
-                                              stream1->Publisher()->Publish(Record(6));
-                                            }
-                                          },
-                                          [&]() { flip_finished_called = true; },
-                                          [&]() { flip_canceled_called = true; });
+    auto flip_key = stream1.ExposeViaHTTP(
+        port1,
+        "/exposed",
+        current::stream::MasterFlipRestrictions().SetMaxDiffSize(entry_size - 1),
+        [&]() {
+          flip_started_called = true;
+          if (stream1->Data()->CurrentHead() < std::chrono::microseconds(80)) {
+            current::time::SetNow(std::chrono::microseconds(80));
+            stream1->Publisher()->Publish(Record(55));
+          } else if (stream1->Data()->CurrentHead() < std::chrono::microseconds(90)) {
+            current::time::SetNow(std::chrono::microseconds(90));
+            stream1->Publisher()->Publish(Record(6));
+          }
+        },
+        [&]() { flip_finished_called = true; },
+        [&]() { flip_canceled_called = true; });
     stream2.FollowRemoteStream(base_url1, current::stream::SubscriptionMode::Checked);
     while (stream2->Data()->CurrentHead() != stream1->Data()->CurrentHead()) {
       std::this_thread::yield();
@@ -1690,13 +1688,13 @@ TEST(Stream, MasterFollowerFlipRestrictions) {
     const auto head_idxts = stream1->Data()->HeadAndLastPublishedIndexAndTimestamp();
     const auto max_clock_diff = std::chrono::microseconds(10);
 
-    const auto flip_key =
-        stream1.ExposeViaHTTP(port1,
-                              "/exposed",
-                              current::stream::MasterFlipRestrictions().SetMaxClockDifference(max_clock_diff),
-                              [&]() { flip_started_called = true; },
-                              [&]() { flip_finished_called = true; },
-                              [&]() { flip_canceled_called = true; });
+    const auto flip_key = stream1.ExposeViaHTTP(
+        port1,
+        "/exposed",
+        current::stream::MasterFlipRestrictions().SetMaxClockDifference(max_clock_diff),
+        [&]() { flip_started_called = true; },
+        [&]() { flip_finished_called = true; },
+        [&]() { flip_canceled_called = true; });
     current::stream::SubscribableRemoteStream<Record>::RemoteStream remote_stream(
         base_url1, current::stream::constants::kDefaultTopLevelName, current::stream::constants::kDefaultNamespaceName);
     const auto url_checked =
@@ -1939,11 +1937,10 @@ TEST(Stream, ReleaseAndAcquirePublisher) {
   struct DynamicStreamPublisherAcquirer {
     using publisher_t = typename Stream::publisher_t;
     DynamicStreamPublisherAcquirer(current::Borrowed<publisher_t> publisher)
-        : publisher_(std::move(publisher),
-                     [this]() {
-                       requested_termination_ = true;
-                       publisher_ = nullptr;
-                     }) {}
+        : publisher_(std::move(publisher), [this]() {
+            requested_termination_ = true;
+            publisher_ = nullptr;
+          }) {}
     bool requested_termination_ = false;
     current::BorrowedWithCallback<publisher_t> publisher_;
   };
@@ -1998,14 +1995,13 @@ TEST(Stream, ReleaseAndAcquirePublisher) {
           current::BorrowedWithCallback<publisher_t> publisher_;
           bool termination_requested_ = false;
           TemporaryPublisher(current::Borrowed<publisher_t> publisher)
-              : publisher_(publisher,
-                           [this]() {
-                             CURRENT_ASSERT(!termination_requested_);
-                             termination_requested_ = true;
-                             // Note: Comment out the next line and observe the deadlock in
-                             // `stream->BecomeMasterStream();` below.
-                             publisher_ = nullptr;
-                           }) {}
+              : publisher_(publisher, [this]() {
+                  CURRENT_ASSERT(!termination_requested_);
+                  termination_requested_ = true;
+                  // Note: Comment out the next line and observe the deadlock in
+                  // `stream->BecomeMasterStream();` below.
+                  publisher_ = nullptr;
+                }) {}
         };
 
         // Transfer ownership of the stream publisher to the external object.
@@ -2113,13 +2109,14 @@ TEST(Stream, SubscribingToJustTailDoesTheJob) {
   });
 
   std::string body;
-  HTTP(ChunkedGET(base_url + "?tail&n=3&array",
-                  [&](const std::string& header, const std::string& value) {
-                    static_cast<void>(header);
-                    static_cast<void>(value);
-                    http_subscriber_started = true;
-                  },
-                  [&](const std::string& chunk_body) { body += chunk_body; }));
+  HTTP(ChunkedGET(
+      base_url + "?tail&n=3&array",
+      [&](const std::string& header, const std::string& value) {
+        static_cast<void>(header);
+        static_cast<void>(value);
+        http_subscriber_started = true;
+      },
+      [&](const std::string& chunk_body) { body += chunk_body; }));
   follow_up_publisher.join();
 
   const auto result = ParseJSON<std::vector<Record>>(body);
diff --git a/typesystem/base.h b/typesystem/base.h
index d7be9470a..487cfc342 100644
--- a/typesystem/base.h
+++ b/typesystem/base.h
@@ -66,7 +66,7 @@ struct Index {};
 template <typename T>
 struct TypeSelector {};
 
-}  // namespace crnt::r
+}  // namespace r
 }  // namespace crnt
 
 namespace current {
@@ -75,15 +75,15 @@ using DeclareFields = ::crnt::r::DF;
 using CountFields = ::crnt::r::FC;
 using DummyTemplateType = ::crnt::r::DummyT;
 using ::crnt::r::CountFieldsImplementationType;
-using ::crnt::r::FieldTypeAndName;
-using ::crnt::r::FieldTypeAndNameAndIndex;
-using ::crnt::r::FieldNameAndPtr;
 using ::crnt::r::FieldNameAndImmutableValue;
 using ::crnt::r::FieldNameAndMutableValue;
-using ::crnt::r::SimpleIndex;
+using ::crnt::r::FieldNameAndPtr;
+using ::crnt::r::FieldTypeAndName;
+using ::crnt::r::FieldTypeAndNameAndIndex;
 using ::crnt::r::Index;
+using ::crnt::r::SimpleIndex;
 using ::crnt::r::TypeSelector;
-}  // namespace current::reflection
+}  // namespace reflection
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_BASE_H
diff --git a/typesystem/evolution/macros.h b/typesystem/evolution/macros.h
index 151fb57e8..f47be74a9 100644
--- a/typesystem/evolution/macros.h
+++ b/typesystem/evolution/macros.h
@@ -64,24 +64,22 @@ template <typename DST>
 struct CurrentGenericPerCaseVariantEvolver {
   current::decay_t<DST>* p_into;
 };
-}  // namespace current::type_evolution
+}  // namespace type_evolution
 }  // namespace current
 
 #define CURRENT_TYPE_EVOLVER_VARIANT(custom_evolver, from_namespace, T, into_namespace)                    \
   template <int COUNTER, typename DST, typename FROM, typename INTO, typename EVOLVER>                     \
   struct CurrentGenericPerCaseVariantEvolverImpl;                                                          \
-  CURRENT_TYPE_EVOLVER(custom_evolver,                                                                     \
-                       from_namespace,                                                                     \
-                       T,                                                                                  \
-                       {                                                                                   \
+  CURRENT_TYPE_EVOLVER(custom_evolver, from_namespace, T, {                                                \
     CurrentGenericPerCaseVariantEvolverImpl<__COUNTER__,                                                   \
                                             decltype(into),                                                \
                                             from_namespace,                                                \
                                             into_namespace,                                                \
-                                            custom_evolver> evolver;                                       \
+                                            custom_evolver>                                                \
+        evolver;                                                                                           \
     evolver.p_into = &into;                                                                                \
     from.Call(evolver);                                                                                    \
-                       });                                                                                 \
+  });                                                                                                      \
                                                                                                            \
   template <typename DST, typename FROM, typename INTO, typename CURRENT_ACTIVE_EVOLVER>                   \
   struct CurrentGenericPerCaseVariantEvolverImpl<__COUNTER__ - 1, DST, FROM, INTO, CURRENT_ACTIVE_EVOLVER> \
diff --git a/typesystem/evolution/test.cc b/typesystem/evolution/test.cc
index e65402ddd..26e47b50e 100644
--- a/typesystem/evolution/test.cc
+++ b/typesystem/evolution/test.cc
@@ -116,8 +116,8 @@ CURRENT_STRUCT(StructWithVectorOfNames) {
   CURRENT_DEFAULT_CONSTRUCTOR(StructWithVectorOfNames) {}
 };
 
-}  // namespacetype_evolution_test:: current_user_namespace::SchemaV1
-}  // namespace type_evolution_test::current_user_namespace
+}  // namespace SchemaV1
+}  // namespace current_user_namespace
 
 CURRENT_NAMESPACE(SchemaV1) {
   CURRENT_NAMESPACE_TYPE(SimpleStruct, current_user_namespace::SchemaV1::SimpleStruct);
@@ -289,7 +289,7 @@ struct Evolve<type_evolution_test::SchemaV1, type_evolution_test::SchemaV1::Stru
   }
 };
 
-}  // namespace current::type_evolution
+}  // namespace type_evolution
 }  // namespace current
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -297,25 +297,21 @@ struct Evolve<type_evolution_test::SchemaV1, type_evolution_test::SchemaV1::Stru
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 // Custom evolution for `StructWithVector`.
-CURRENT_TYPE_EVOLVER(V1ToV2Evolver,
-                     type_evolution_test::SchemaV1,
-                     StructWithVector,
-                     {
-                       into.string_ids.clear();
-                       into.string_ids.reserve(from.numerical_ids.size());
-                       for (const auto& cit : from.numerical_ids) {
-                         into.string_ids.push_back('@' + current::ToString(cit));
-                       }
-                     });
+CURRENT_TYPE_EVOLVER(V1ToV2Evolver, type_evolution_test::SchemaV1, StructWithVector, {
+  into.string_ids.clear();
+  into.string_ids.reserve(from.numerical_ids.size());
+  for (const auto& cit : from.numerical_ids) {
+    into.string_ids.push_back('@' + current::ToString(cit));
+  }
+});
 
 // Custom evolution for `Name`.
 CURRENT_TYPE_EVOLVER(V1ToV2Evolver, type_evolution_test::SchemaV1, Name, { into.full = from.first + ' ' + from.last; });
 
 // Alternative custom evolution for `Name`.
-CURRENT_TYPE_EVOLVER(AnotherV1ToV2Evolver,
-                     type_evolution_test::SchemaV1,
-                     Name,
-                     { into.full = from.last + ", " + from.first; });
+CURRENT_TYPE_EVOLVER(AnotherV1ToV2Evolver, type_evolution_test::SchemaV1, Name, {
+  into.full = from.last + ", " + from.first;
+});
 
 namespace type_evolution_test {
 namespace arbitrarily_called_namespace {
@@ -534,32 +530,23 @@ TEST(TypeEvolutionTest, NameWithDifferentEvolvers) {
 using SchemaXX = USERSPACE_F055D51FBF78DB84;
 
 // Custom evolution from the autogenerated `SimpleStruct`.
-CURRENT_TYPE_EVOLVER(AddFortyTwoToX,
-                     SchemaXX,
-                     SimpleStruct,
-                     {
-                       into.x = from.x + 42;
-                       into.y = from.y;
-                       into.z = from.z;
-                     });
+CURRENT_TYPE_EVOLVER(AddFortyTwoToX, SchemaXX, SimpleStruct, {
+  into.x = from.x + 42;
+  into.y = from.y;
+  into.z = from.z;
+});
 
 // Custom evolution that behaves differently for `SimpleStruct` and `StructWithStruct`.
-CURRENT_TYPE_EVOLVER(AddOneOrTwoToX,
-                     SchemaXX,
-                     SimpleStruct,
-                     {
-                       into.x = from.x + 1;
-                       into.y = from.y;
-                       into.z = from.z;
-                     });
-CURRENT_TYPE_EVOLVER(AddOneOrTwoToX,
-                     SchemaXX,
-                     StructWithStruct,
-                     {
-                       into.s.x = from.s.x + 2;
-                       into.s.y = from.s.y;
-                       into.s.z = from.s.z;
-                     });
+CURRENT_TYPE_EVOLVER(AddOneOrTwoToX, SchemaXX, SimpleStruct, {
+  into.x = from.x + 1;
+  into.y = from.y;
+  into.z = from.z;
+});
+CURRENT_TYPE_EVOLVER(AddOneOrTwoToX, SchemaXX, StructWithStruct, {
+  into.s.x = from.s.x + 2;
+  into.s.y = from.s.y;
+  into.s.z = from.s.z;
+});
 #endif  // JUST_GENERATE_THAT_GOLDEN_FILE
 
 #ifndef CURRENT_WINDOWS
@@ -597,346 +584,316 @@ TEST(TypeEvolutionTest, AutogeneratedCurrentStructsAreReadyForEvolution) {
   // Confirm the types we are dealing with are indeed different.
   static_assert(!std::is_same_v<typename SchemaV1::SimpleStruct, typename SchemaXX::SimpleStruct>, "");
 
-  {
-    // Plain `SimpleStruct` tests, just copy the fields over, no evolution.
-    {
-      // Local `SimpleStruct` into autogenerated `SimpleStruct`.
-      typename SchemaV1::SimpleStruct from;
-      typename SchemaXX::SimpleStruct into;
-      from.x = 100002;
-      from.y = 100003;
-      from.z = "dima";
-      current::type_evolution::Evolve<SchemaV1, SchemaV1::SimpleStruct>::template Go<SchemaXX>(from, into);
-      EXPECT_EQ(100002, into.x);
-      EXPECT_EQ(100003, into.y);
-      EXPECT_EQ("dima", into.z);
-    }
-    {
-      // Autogenerated `SimpleStruct` into local `SimpleStruct`.
-      typename SchemaXX::SimpleStruct from;
-      typename SchemaV1::SimpleStruct into;
-      from.x = 400005;
-      from.y = 400006;
-      from.z = "max";
-      current::type_evolution::Evolve<SchemaXX, SchemaXX::SimpleStruct>::template Go<SchemaV1>(from, into);
-      EXPECT_EQ(400005, into.x);
-      EXPECT_EQ(400006, into.y);
-      EXPECT_EQ("max", into.z);
-    }
-  }
-
-  {
-    // Plain `StructWithStruct` tests, just copy the fields over, no evolution.
-    {
-      // Local `StructWithStruct` into autogenerated `StructWithStruct`.
-      typename SchemaV1::StructWithStruct from;
-      typename SchemaXX::StructWithStruct into;
-      from.s.x = 188882;
-      from.s.y = 188883;
-      from.s.z = "dima";
-      current::type_evolution::Evolve<SchemaV1, SchemaV1::StructWithStruct>::template Go<SchemaXX>(from, into);
-      EXPECT_EQ(188882, into.s.x);
-      EXPECT_EQ(188883, into.s.y);
-      EXPECT_EQ("dima", into.s.z);
-    }
-    {
-      // Autogenerated `StructWithStruct` into local `StructWithStruct`.
-      typename SchemaXX::StructWithStruct from;
-      typename SchemaV1::StructWithStruct into;
-      from.s.x = 488885;
-      from.s.y = 488886;
-      from.s.z = "max";
-      current::type_evolution::Evolve<SchemaXX, SchemaXX::StructWithStruct>::template Go<SchemaV1>(from, into);
-      EXPECT_EQ(488885, into.s.x);
-      EXPECT_EQ(488886, into.s.y);
-      EXPECT_EQ("max", into.s.z);
-    }
-  }
+  { // Plain `SimpleStruct` tests, just copy the fields over, no evolution.
+   {// Local `SimpleStruct` into autogenerated `SimpleStruct`.
+    typename SchemaV1::SimpleStruct from;
+  typename SchemaXX::SimpleStruct into;
+  from.x = 100002;
+  from.y = 100003;
+  from.z = "dima";
+  current::type_evolution::Evolve<SchemaV1, SchemaV1::SimpleStruct>::template Go<SchemaXX>(from, into);
+  EXPECT_EQ(100002, into.x);
+  EXPECT_EQ(100003, into.y);
+  EXPECT_EQ("dima", into.z);
+}
+{
+  // Autogenerated `SimpleStruct` into local `SimpleStruct`.
+  typename SchemaXX::SimpleStruct from;
+  typename SchemaV1::SimpleStruct into;
+  from.x = 400005;
+  from.y = 400006;
+  from.z = "max";
+  current::type_evolution::Evolve<SchemaXX, SchemaXX::SimpleStruct>::template Go<SchemaV1>(from, into);
+  EXPECT_EQ(400005, into.x);
+  EXPECT_EQ(400006, into.y);
+  EXPECT_EQ("max", into.z);
+}
+}
 
-  {
-    // Plain `Name` tests, just copy the fields over, no evolution.
-    {
-      // Local `Name` into autogenerated `Name`.
-      typename SchemaV1::Name from;
-      typename SchemaXX::Name into;
-      from.first = "Dima";
-      from.last = "Korolev";
-      current::type_evolution::Evolve<SchemaV1, SchemaV1::Name>::template Go<SchemaXX>(from, into);
-      EXPECT_EQ("Dima", into.first);
-      EXPECT_EQ("Korolev", into.last);
-    }
-    {
-      // Autogenerated `Name` into local `Name`.
-      typename SchemaXX::Name from;
-      typename SchemaV1::Name into;
-      from.first = "Max";
-      from.last = "Zhurovich";
-      current::type_evolution::Evolve<SchemaXX, SchemaXX::Name>::template Go<SchemaV1>(from, into);
-      EXPECT_EQ("Max", into.first);
-      EXPECT_EQ("Zhurovich", into.last);
-    }
-  }
+{ // Plain `StructWithStruct` tests, just copy the fields over, no evolution.
+ {// Local `StructWithStruct` into autogenerated `StructWithStruct`.
+  typename SchemaV1::StructWithStruct from;
+typename SchemaXX::StructWithStruct into;
+from.s.x = 188882;
+from.s.y = 188883;
+from.s.z = "dima";
+current::type_evolution::Evolve<SchemaV1, SchemaV1::StructWithStruct>::template Go<SchemaXX>(from, into);
+EXPECT_EQ(188882, into.s.x);
+EXPECT_EQ(188883, into.s.y);
+EXPECT_EQ("dima", into.s.z);
+}
+{
+  // Autogenerated `StructWithStruct` into local `StructWithStruct`.
+  typename SchemaXX::StructWithStruct from;
+  typename SchemaV1::StructWithStruct into;
+  from.s.x = 488885;
+  from.s.y = 488886;
+  from.s.z = "max";
+  current::type_evolution::Evolve<SchemaXX, SchemaXX::StructWithStruct>::template Go<SchemaV1>(from, into);
+  EXPECT_EQ(488885, into.s.x);
+  EXPECT_EQ(488886, into.s.y);
+  EXPECT_EQ("max", into.s.z);
+}
+}
 
-  {
-    // `AddFortyTwoToX` adds 42 to `.x` of `SimpleStruct`.
-    {
-      // Run with a plain `SimpleStruct`.
-      typename SchemaXX::SimpleStruct from;
-      typename SchemaV1::SimpleStruct into;
-      from.x = 0;
-      from.y = 0;
-      from.z = "doit";
-      current::type_evolution::Evolve<SchemaXX,
-                                      SchemaXX::SimpleStruct,
-                                      current::type_evolution::AddFortyTwoToX>::template Go<SchemaV1>(from, into);
-      EXPECT_EQ(42, into.x);
-      EXPECT_EQ(0, into.y);
-      EXPECT_EQ("doit", into.z);
-    }
-    {
-      // Run with `SimpleStruct` within `StructWithStruct`.
-      typename SchemaXX::StructWithStruct from;
-      typename SchemaV1::StructWithStruct into;
-      from.s.x = 0;
-      from.s.y = 0;
-      from.s.z = "doit";
-      current::type_evolution::Evolve<SchemaXX,
-                                      SchemaXX::StructWithStruct,
-                                      current::type_evolution::AddFortyTwoToX>::template Go<SchemaV1>(from, into);
-      EXPECT_EQ(42, into.s.x);
-      EXPECT_EQ(0, into.s.y);
-      EXPECT_EQ("doit", into.s.z);
-    }
-  }
+{ // Plain `Name` tests, just copy the fields over, no evolution.
+ {// Local `Name` into autogenerated `Name`.
+  typename SchemaV1::Name from;
+typename SchemaXX::Name into;
+from.first = "Dima";
+from.last = "Korolev";
+current::type_evolution::Evolve<SchemaV1, SchemaV1::Name>::template Go<SchemaXX>(from, into);
+EXPECT_EQ("Dima", into.first);
+EXPECT_EQ("Korolev", into.last);
+}
+{
+  // Autogenerated `Name` into local `Name`.
+  typename SchemaXX::Name from;
+  typename SchemaV1::Name into;
+  from.first = "Max";
+  from.last = "Zhurovich";
+  current::type_evolution::Evolve<SchemaXX, SchemaXX::Name>::template Go<SchemaV1>(from, into);
+  EXPECT_EQ("Max", into.first);
+  EXPECT_EQ("Zhurovich", into.last);
+}
+}
 
-  {
-    // `AddOneOrTwoToX` adds 1 to `.x` of `SimpleStruct` or 2 to `.s.x` of `StructWithStruct`.
-    {
-      // Run with a plain `SimpleStruct`.
-      typename SchemaXX::SimpleStruct from;
-      typename SchemaV1::SimpleStruct into;
-      from.x = 0;
-      from.y = 0;
-      from.z = "doit";
-      current::type_evolution::Evolve<SchemaXX,
-                                      SchemaXX::SimpleStruct,
-                                      current::type_evolution::AddOneOrTwoToX>::template Go<SchemaV1>(from, into);
-      EXPECT_EQ(1, into.x);
-      EXPECT_EQ(0, into.y);
-      EXPECT_EQ("doit", into.z);
-    }
-    {
-      // Run with `SimpleStruct` within `StructWithStruct`.
-      typename SchemaXX::StructWithStruct from;
-      typename SchemaV1::StructWithStruct into;
-      from.s.x = 0;
-      from.s.y = 0;
-      from.s.z = "doit";
-      current::type_evolution::Evolve<SchemaXX,
-                                      SchemaXX::StructWithStruct,
-                                      current::type_evolution::AddOneOrTwoToX>::template Go<SchemaV1>(from, into);
-      EXPECT_EQ(2, into.s.x);
-      EXPECT_EQ(0, into.s.y);
-      EXPECT_EQ("doit", into.s.z);
-    }
-  }
+{ // `AddFortyTwoToX` adds 42 to `.x` of `SimpleStruct`.
+ {// Run with a plain `SimpleStruct`.
+  typename SchemaXX::SimpleStruct from;
+typename SchemaV1::SimpleStruct into;
+from.x = 0;
+from.y = 0;
+from.z = "doit";
+current::type_evolution::Evolve<SchemaXX, SchemaXX::SimpleStruct, current::type_evolution::AddFortyTwoToX>::template Go<
+    SchemaV1>(from, into);
+EXPECT_EQ(42, into.x);
+EXPECT_EQ(0, into.y);
+EXPECT_EQ("doit", into.z);
+}
+{
+  // Run with `SimpleStruct` within `StructWithStruct`.
+  typename SchemaXX::StructWithStruct from;
+  typename SchemaV1::StructWithStruct into;
+  from.s.x = 0;
+  from.s.y = 0;
+  from.s.z = "doit";
+  current::type_evolution::Evolve<SchemaXX, SchemaXX::StructWithStruct, current::type_evolution::AddFortyTwoToX>::
+      template Go<SchemaV1>(from, into);
+  EXPECT_EQ(42, into.s.x);
+  EXPECT_EQ(0, into.s.y);
+  EXPECT_EQ("doit", into.s.z);
+}
+}
 
-  {
-    // Plain `Variant<SimpleStruct, StructWithStruct>` tests, just copy the fields over, no evolution.
-    {
-      // Local `Variant<...>` into autogenerated `Variant<...>`.
-      // The `Variant<>`-originating evolver implemented manually above is used.
-      {
-        Variant<typename SchemaV1::SimpleStruct, typename SchemaV1::StructWithStruct, typename SchemaV1::OtherTypes>
-            from;
-        Variant<typename SchemaXX::SimpleStruct, typename SchemaXX::StructWithStruct, typename SchemaXX::OtherTypes>
-            into;
-        from = typename SchemaV1::SimpleStruct();
-        Value<SchemaV1::SimpleStruct>(from).x = 1;
-        current::type_evolution::Evolve<SchemaV1, decltype(from)>::template Go<SchemaXX>(from, into);
-        EXPECT_TRUE(Exists<typename SchemaXX::SimpleStruct>(into));
-        EXPECT_FALSE(Exists<typename SchemaXX::StructWithStruct>(into));
-        EXPECT_EQ(1, Value<typename SchemaXX::SimpleStruct>(into).x);
-      }
+{ // `AddOneOrTwoToX` adds 1 to `.x` of `SimpleStruct` or 2 to `.s.x` of `StructWithStruct`.
+ {// Run with a plain `SimpleStruct`.
+  typename SchemaXX::SimpleStruct from;
+typename SchemaV1::SimpleStruct into;
+from.x = 0;
+from.y = 0;
+from.z = "doit";
+current::type_evolution::Evolve<SchemaXX, SchemaXX::SimpleStruct, current::type_evolution::AddOneOrTwoToX>::template Go<
+    SchemaV1>(from, into);
+EXPECT_EQ(1, into.x);
+EXPECT_EQ(0, into.y);
+EXPECT_EQ("doit", into.z);
+}
+{
+  // Run with `SimpleStruct` within `StructWithStruct`.
+  typename SchemaXX::StructWithStruct from;
+  typename SchemaV1::StructWithStruct into;
+  from.s.x = 0;
+  from.s.y = 0;
+  from.s.z = "doit";
+  current::type_evolution::Evolve<SchemaXX, SchemaXX::StructWithStruct, current::type_evolution::AddOneOrTwoToX>::
+      template Go<SchemaV1>(from, into);
+  EXPECT_EQ(2, into.s.x);
+  EXPECT_EQ(0, into.s.y);
+  EXPECT_EQ("doit", into.s.z);
+}
+}
 
-      {
-        Variant<typename SchemaV1::SimpleStruct, typename SchemaV1::StructWithStruct, typename SchemaV1::OtherTypes>
-            from;
-        Variant<typename SchemaXX::SimpleStruct, typename SchemaXX::StructWithStruct, typename SchemaXX::OtherTypes>
-            into;
-        from = typename SchemaV1::StructWithStruct();
-        Value<SchemaV1::StructWithStruct>(from).s.x = 2;
-        current::type_evolution::Evolve<SchemaV1,
-                                        Variant<typename SchemaV1::SimpleStruct,
-                                                typename SchemaV1::StructWithStruct,
-                                                typename SchemaV1::OtherTypes>>::template Go<SchemaXX>(from, into);
-        EXPECT_FALSE(Exists<typename SchemaXX::SimpleStruct>(into));
-        EXPECT_TRUE(Exists<typename SchemaXX::StructWithStruct>(into));
-        EXPECT_EQ(2, Value<typename SchemaXX::StructWithStruct>(into).s.x);
-      }
-    }
+{ // Plain `Variant<SimpleStruct, StructWithStruct>` tests, just copy the fields over, no evolution.
+ {// Local `Variant<...>` into autogenerated `Variant<...>`.
+  // The `Variant<>`-originating evolver implemented manually above is used.
+  {Variant<typename SchemaV1::SimpleStruct, typename SchemaV1::StructWithStruct, typename SchemaV1::OtherTypes> from;
+Variant<typename SchemaXX::SimpleStruct, typename SchemaXX::StructWithStruct, typename SchemaXX::OtherTypes> into;
+from = typename SchemaV1::SimpleStruct();
+Value<SchemaV1::SimpleStruct>(from).x = 1;
+current::type_evolution::Evolve<SchemaV1, decltype(from)>::template Go<SchemaXX>(from, into);
+EXPECT_TRUE(Exists<typename SchemaXX::SimpleStruct>(into));
+EXPECT_FALSE(Exists<typename SchemaXX::StructWithStruct>(into));
+EXPECT_EQ(1, Value<typename SchemaXX::SimpleStruct>(into).x);
+}
 
-    {
-      // Autogenerated `Variant<...>` into local `Variant<...>`.
-      // The autogenerated `Variant<>`-originating evolver is used.
-      {
-        Variant<typename SchemaXX::SimpleStruct, typename SchemaXX::StructWithStruct, typename SchemaXX::OtherTypes>
-            from;
-        Variant<typename SchemaV1::SimpleStruct, typename SchemaV1::StructWithStruct, typename SchemaV1::OtherTypes>
-            into;
-        from = typename SchemaXX::SimpleStruct();
-        Value<SchemaXX::SimpleStruct>(from).x = 3;
-        current::type_evolution::Evolve<SchemaXX,
-                                        Variant<typename SchemaXX::SimpleStruct,
-                                                typename SchemaXX::StructWithStruct,
-                                                typename SchemaXX::OtherTypes>>::template Go<SchemaV1>(from, into);
-        EXPECT_TRUE(Exists<typename SchemaV1::SimpleStruct>(into));
-        EXPECT_FALSE(Exists<typename SchemaV1::StructWithStruct>(into));
-        EXPECT_EQ(3, Value<typename SchemaV1::SimpleStruct>(into).x);
-      }
+{
+  Variant<typename SchemaV1::SimpleStruct, typename SchemaV1::StructWithStruct, typename SchemaV1::OtherTypes> from;
+  Variant<typename SchemaXX::SimpleStruct, typename SchemaXX::StructWithStruct, typename SchemaXX::OtherTypes> into;
+  from = typename SchemaV1::StructWithStruct();
+  Value<SchemaV1::StructWithStruct>(from).s.x = 2;
+  current::type_evolution::Evolve<
+      SchemaV1,
+      Variant<typename SchemaV1::SimpleStruct, typename SchemaV1::StructWithStruct, typename SchemaV1::OtherTypes>>::
+      template Go<SchemaXX>(from, into);
+  EXPECT_FALSE(Exists<typename SchemaXX::SimpleStruct>(into));
+  EXPECT_TRUE(Exists<typename SchemaXX::StructWithStruct>(into));
+  EXPECT_EQ(2, Value<typename SchemaXX::StructWithStruct>(into).s.x);
+}
+}
 
-      {
-        Variant<typename SchemaXX::SimpleStruct, typename SchemaXX::StructWithStruct, typename SchemaXX::OtherTypes>
-            from;
-        Variant<typename SchemaV1::SimpleStruct, typename SchemaV1::StructWithStruct, typename SchemaV1::OtherTypes>
-            into;
-        from = typename SchemaXX::StructWithStruct();
-        Value<SchemaXX::StructWithStruct>(from).s.x = 4;
-        current::type_evolution::Evolve<SchemaXX,
-                                        Variant<typename SchemaXX::SimpleStruct,
-                                                typename SchemaXX::StructWithStruct,
-                                                typename SchemaXX::OtherTypes>>::template Go<SchemaV1>(from, into);
-        EXPECT_FALSE(Exists<typename SchemaV1::SimpleStruct>(into));
-        EXPECT_TRUE(Exists<typename SchemaV1::StructWithStruct>(into));
-        EXPECT_EQ(4, Value<typename SchemaV1::StructWithStruct>(into).s.x);
-      }
-    }
+{
+  // Autogenerated `Variant<...>` into local `Variant<...>`.
+  // The autogenerated `Variant<>`-originating evolver is used.
+  {
+    Variant<typename SchemaXX::SimpleStruct, typename SchemaXX::StructWithStruct, typename SchemaXX::OtherTypes> from;
+    Variant<typename SchemaV1::SimpleStruct, typename SchemaV1::StructWithStruct, typename SchemaV1::OtherTypes> into;
+    from = typename SchemaXX::SimpleStruct();
+    Value<SchemaXX::SimpleStruct>(from).x = 3;
+    current::type_evolution::Evolve<
+        SchemaXX,
+        Variant<typename SchemaXX::SimpleStruct, typename SchemaXX::StructWithStruct, typename SchemaXX::OtherTypes>>::
+        template Go<SchemaV1>(from, into);
+    EXPECT_TRUE(Exists<typename SchemaV1::SimpleStruct>(into));
+    EXPECT_FALSE(Exists<typename SchemaV1::StructWithStruct>(into));
+    EXPECT_EQ(3, Value<typename SchemaV1::SimpleStruct>(into).x);
   }
 
   {
-    // Plain `StructWithVariant` tests, just copy the fields over, no evolution.
-    {
-      // Local `StructWithVariant` into autogenerated `StructWithVariant`.
-      // The `Variant<>`-originating evolver implemented manually above is used.
-      {
-        typename SchemaV1::StructWithVariant from;
-        typename SchemaXX::StructWithVariant into;
-        from.v = typename SchemaV1::SimpleStruct();
-        Value<SchemaV1::SimpleStruct>(from.v).x = 1;
-        current::type_evolution::Evolve<SchemaV1, SchemaV1::StructWithVariant>::template Go<SchemaXX>(from, into);
-        EXPECT_TRUE(Exists<typename SchemaXX::SimpleStruct>(into.v));
-        EXPECT_FALSE(Exists<typename SchemaXX::StructWithStruct>(into.v));
-        EXPECT_EQ(1, Value<typename SchemaXX::SimpleStruct>(into.v).x);
-      }
+    Variant<typename SchemaXX::SimpleStruct, typename SchemaXX::StructWithStruct, typename SchemaXX::OtherTypes> from;
+    Variant<typename SchemaV1::SimpleStruct, typename SchemaV1::StructWithStruct, typename SchemaV1::OtherTypes> into;
+    from = typename SchemaXX::StructWithStruct();
+    Value<SchemaXX::StructWithStruct>(from).s.x = 4;
+    current::type_evolution::Evolve<
+        SchemaXX,
+        Variant<typename SchemaXX::SimpleStruct, typename SchemaXX::StructWithStruct, typename SchemaXX::OtherTypes>>::
+        template Go<SchemaV1>(from, into);
+    EXPECT_FALSE(Exists<typename SchemaV1::SimpleStruct>(into));
+    EXPECT_TRUE(Exists<typename SchemaV1::StructWithStruct>(into));
+    EXPECT_EQ(4, Value<typename SchemaV1::StructWithStruct>(into).s.x);
+  }
+}
+}
 
-      {
-        typename SchemaV1::StructWithVariant from;
-        typename SchemaXX::StructWithVariant into;
-        from.v = typename SchemaV1::StructWithStruct();
-        Value<SchemaV1::StructWithStruct>(from.v).s.x = 2;
-        current::type_evolution::Evolve<SchemaV1, SchemaV1::StructWithVariant>::template Go<SchemaXX>(from, into);
-        EXPECT_FALSE(Exists<typename SchemaXX::SimpleStruct>(into.v));
-        EXPECT_TRUE(Exists<typename SchemaXX::StructWithStruct>(into.v));
-        EXPECT_EQ(2, Value<typename SchemaXX::StructWithStruct>(into.v).s.x);
-      }
-    }
+{ // Plain `StructWithVariant` tests, just copy the fields over, no evolution.
+ {// Local `StructWithVariant` into autogenerated `StructWithVariant`.
+  // The `Variant<>`-originating evolver implemented manually above is used.
+  {typename SchemaV1::StructWithVariant from;
+typename SchemaXX::StructWithVariant into;
+from.v = typename SchemaV1::SimpleStruct();
+Value<SchemaV1::SimpleStruct>(from.v).x = 1;
+current::type_evolution::Evolve<SchemaV1, SchemaV1::StructWithVariant>::template Go<SchemaXX>(from, into);
+EXPECT_TRUE(Exists<typename SchemaXX::SimpleStruct>(into.v));
+EXPECT_FALSE(Exists<typename SchemaXX::StructWithStruct>(into.v));
+EXPECT_EQ(1, Value<typename SchemaXX::SimpleStruct>(into.v).x);
+}
 
-    {
-      // Autogenerated `StructWithVariant` into local `StructWithVariant`.
-      // The autogenerated `Variant<>`-originating evolver is used.
-      {
-        typename SchemaXX::StructWithVariant from;
-        typename SchemaV1::StructWithVariant into;
-        from.v = typename SchemaXX::SimpleStruct();
-        Value<SchemaXX::SimpleStruct>(from.v).x = 3;
-        current::type_evolution::Evolve<SchemaXX, SchemaXX::StructWithVariant>::template Go<SchemaV1>(from, into);
-        EXPECT_TRUE(Exists<typename SchemaV1::SimpleStruct>(into.v));
-        EXPECT_FALSE(Exists<typename SchemaV1::StructWithStruct>(into.v));
-        EXPECT_EQ(3, Value<typename SchemaV1::SimpleStruct>(into.v).x);
-      }
+{
+  typename SchemaV1::StructWithVariant from;
+  typename SchemaXX::StructWithVariant into;
+  from.v = typename SchemaV1::StructWithStruct();
+  Value<SchemaV1::StructWithStruct>(from.v).s.x = 2;
+  current::type_evolution::Evolve<SchemaV1, SchemaV1::StructWithVariant>::template Go<SchemaXX>(from, into);
+  EXPECT_FALSE(Exists<typename SchemaXX::SimpleStruct>(into.v));
+  EXPECT_TRUE(Exists<typename SchemaXX::StructWithStruct>(into.v));
+  EXPECT_EQ(2, Value<typename SchemaXX::StructWithStruct>(into.v).s.x);
+}
+}
 
-      {
-        typename SchemaXX::StructWithVariant from;
-        typename SchemaV1::StructWithVariant into;
-        from.v = typename SchemaXX::StructWithStruct();
-        Value<SchemaXX::StructWithStruct>(from.v).s.x = 4;
-        current::type_evolution::Evolve<SchemaXX, SchemaXX::StructWithVariant>::template Go<SchemaV1>(from, into);
-        EXPECT_FALSE(Exists<typename SchemaV1::SimpleStruct>(into.v));
-        EXPECT_TRUE(Exists<typename SchemaV1::StructWithStruct>(into.v));
-        EXPECT_EQ(4, Value<typename SchemaV1::StructWithStruct>(into.v).s.x);
-      }
-    }
+{
+  // Autogenerated `StructWithVariant` into local `StructWithVariant`.
+  // The autogenerated `Variant<>`-originating evolver is used.
+  {
+    typename SchemaXX::StructWithVariant from;
+    typename SchemaV1::StructWithVariant into;
+    from.v = typename SchemaXX::SimpleStruct();
+    Value<SchemaXX::SimpleStruct>(from.v).x = 3;
+    current::type_evolution::Evolve<SchemaXX, SchemaXX::StructWithVariant>::template Go<SchemaV1>(from, into);
+    EXPECT_TRUE(Exists<typename SchemaV1::SimpleStruct>(into.v));
+    EXPECT_FALSE(Exists<typename SchemaV1::StructWithStruct>(into.v));
+    EXPECT_EQ(3, Value<typename SchemaV1::SimpleStruct>(into.v).x);
   }
 
   {
-    // Plain `StructWithVectorOfNames` tests, just copy the fields over, no evolution.
-    {
-      // Local `StructWithVectorOfNames` into autogenerated `StructWithVectorOfNames`.
-      typename SchemaV1::StructWithVectorOfNames from;
-      typename SchemaXX::StructWithVectorOfNames into;
-      from.w.emplace_back("Dima", "Korolev");
-      from.w.emplace_back("Max", "Zhurovich");
-      current::type_evolution::Evolve<SchemaV1, SchemaV1::StructWithVectorOfNames>::template Go<SchemaXX>(from, into);
-      ASSERT_EQ(2u, into.w.size());
-      EXPECT_EQ("Dima", into.w[0].first);
-      EXPECT_EQ("Korolev", into.w[0].last);
-      EXPECT_EQ("Max", into.w[1].first);
-      EXPECT_EQ("Zhurovich", into.w[1].last);
-    }
-    {
-      typename SchemaXX::StructWithVectorOfNames from;
-      typename SchemaV1::StructWithVectorOfNames into;
-      // `.emplace_back` can't really work on autogenerated struct. -- D.K.
-      from.w.push_back([] {
-        typename SchemaXX::Name u;
-        u.first = "Max";
-        u.last = "Zhurovich";
-        return u;
-      }());
-      from.w.push_back([] {
-        typename SchemaXX::Name u;
-        u.first = "Dima";
-        u.last = "Korolev";
-        return u;
-      }());
-      current::type_evolution::Evolve<SchemaXX, SchemaXX::StructWithVectorOfNames>::template Go<SchemaV1>(from, into);
-      ASSERT_EQ(2u, into.w.size());
-      EXPECT_EQ("Max", into.w[0].first);
-      EXPECT_EQ("Zhurovich", into.w[0].last);
-      EXPECT_EQ("Dima", into.w[1].first);
-      EXPECT_EQ("Korolev", into.w[1].last);
-    }
+    typename SchemaXX::StructWithVariant from;
+    typename SchemaV1::StructWithVariant into;
+    from.v = typename SchemaXX::StructWithStruct();
+    Value<SchemaXX::StructWithStruct>(from.v).s.x = 4;
+    current::type_evolution::Evolve<SchemaXX, SchemaXX::StructWithVariant>::template Go<SchemaV1>(from, into);
+    EXPECT_FALSE(Exists<typename SchemaV1::SimpleStruct>(into.v));
+    EXPECT_TRUE(Exists<typename SchemaV1::StructWithStruct>(into.v));
+    EXPECT_EQ(4, Value<typename SchemaV1::StructWithStruct>(into.v).s.x);
   }
+}
+}
 
+{ // Plain `StructWithVectorOfNames` tests, just copy the fields over, no evolution.
+ {// Local `StructWithVectorOfNames` into autogenerated `StructWithVectorOfNames`.
+  typename SchemaV1::StructWithVectorOfNames from;
+typename SchemaXX::StructWithVectorOfNames into;
+from.w.emplace_back("Dima", "Korolev");
+from.w.emplace_back("Max", "Zhurovich");
+current::type_evolution::Evolve<SchemaV1, SchemaV1::StructWithVectorOfNames>::template Go<SchemaXX>(from, into);
+ASSERT_EQ(2u, into.w.size());
+EXPECT_EQ("Dima", into.w[0].first);
+EXPECT_EQ("Korolev", into.w[0].last);
+EXPECT_EQ("Max", into.w[1].first);
+EXPECT_EQ("Zhurovich", into.w[1].last);
+}
+{
+  typename SchemaXX::StructWithVectorOfNames from;
+  typename SchemaV1::StructWithVectorOfNames into;
+  // `.emplace_back` can't really work on autogenerated struct. -- D.K.
+  from.w.push_back([] {
+    typename SchemaXX::Name u;
+    u.first = "Max";
+    u.last = "Zhurovich";
+    return u;
+  }());
+  from.w.push_back([] {
+    typename SchemaXX::Name u;
+    u.first = "Dima";
+    u.last = "Korolev";
+    return u;
+  }());
+  current::type_evolution::Evolve<SchemaXX, SchemaXX::StructWithVectorOfNames>::template Go<SchemaV1>(from, into);
+  ASSERT_EQ(2u, into.w.size());
+  EXPECT_EQ("Max", into.w[0].first);
+  EXPECT_EQ("Zhurovich", into.w[0].last);
+  EXPECT_EQ("Dima", into.w[1].first);
+  EXPECT_EQ("Korolev", into.w[1].last);
+}
+}
+
+{
+  // Confirm type evolution kicks in when running over an `std::vector<>`.
+  using current::type_evolution::AnotherV1ToV2Evolver;
+  using current::type_evolution::V1ToV2Evolver;
   {
-    // Confirm type evolution kicks in when running over an `std::vector<>`.
-    using current::type_evolution::V1ToV2Evolver;
-    using current::type_evolution::AnotherV1ToV2Evolver;
-    {
-      // Evolve `SchemaV1`'s `StructWithVectorOfNames` into V2 using `V1ToV2Evolver`.
-      typename SchemaV1::StructWithVectorOfNames original;
-      typename SchemaV2::StructWithVectorOfNames evoluted;
-      original.w.emplace_back("Dima", "Korolev");
-      original.w.emplace_back("Max", "Zhurovich");
-      current::type_evolution::Evolve<SchemaV1, SchemaV1::StructWithVectorOfNames, V1ToV2Evolver>::template Go<
-          SchemaV2>(original, evoluted);
-      ASSERT_EQ(2u, evoluted.w.size());
-      EXPECT_EQ("Dima Korolev", evoluted.w[0].full);
-      EXPECT_EQ("Max Zhurovich", evoluted.w[1].full);
-    }
-    {
-      // Evolve `SchemaV1`'s `StructWithVectorOfNames` into V2 using `AnotherV1ToV2Evolver`.
-      typename SchemaV1::StructWithVectorOfNames original;
-      typename SchemaV2::StructWithVectorOfNames evoluted;
-      original.w.emplace_back("Max", "Zhurovich");
-      original.w.emplace_back("Dima", "Korolev");
-      current::type_evolution::Evolve<SchemaV1, SchemaV1::StructWithVectorOfNames, AnotherV1ToV2Evolver>::template Go<
-          SchemaV2>(original, evoluted);
-      ASSERT_EQ(2u, evoluted.w.size());
-      EXPECT_EQ("Zhurovich, Max", evoluted.w[0].full);
-      EXPECT_EQ("Korolev, Dima", evoluted.w[1].full);
-    }
+    // Evolve `SchemaV1`'s `StructWithVectorOfNames` into V2 using `V1ToV2Evolver`.
+    typename SchemaV1::StructWithVectorOfNames original;
+    typename SchemaV2::StructWithVectorOfNames evoluted;
+    original.w.emplace_back("Dima", "Korolev");
+    original.w.emplace_back("Max", "Zhurovich");
+    current::type_evolution::Evolve<SchemaV1, SchemaV1::StructWithVectorOfNames, V1ToV2Evolver>::template Go<SchemaV2>(
+        original, evoluted);
+    ASSERT_EQ(2u, evoluted.w.size());
+    EXPECT_EQ("Dima Korolev", evoluted.w[0].full);
+    EXPECT_EQ("Max Zhurovich", evoluted.w[1].full);
   }
+  {
+    // Evolve `SchemaV1`'s `StructWithVectorOfNames` into V2 using `AnotherV1ToV2Evolver`.
+    typename SchemaV1::StructWithVectorOfNames original;
+    typename SchemaV2::StructWithVectorOfNames evoluted;
+    original.w.emplace_back("Max", "Zhurovich");
+    original.w.emplace_back("Dima", "Korolev");
+    current::type_evolution::Evolve<SchemaV1, SchemaV1::StructWithVectorOfNames, AnotherV1ToV2Evolver>::template Go<
+        SchemaV2>(original, evoluted);
+    ASSERT_EQ(2u, evoluted.w.size());
+    EXPECT_EQ("Zhurovich, Max", evoluted.w[0].full);
+    EXPECT_EQ("Korolev, Dima", evoluted.w[1].full);
+  }
+}
 #endif  // JUST_GENERATE_THAT_GOLDEN_FILE
 }
 #endif  // CURRENT_WINDOWS
@@ -946,40 +903,32 @@ namespace pre_evolution {
 CURRENT_STRUCT(User, SchemaV1::Name) { CURRENT_FIELD(key, std::string); };
 CURRENT_STORAGE_FIELD_ENTRY(OrderedDictionary, User, PersistedUser);
 CURRENT_STORAGE(Storage) { CURRENT_STORAGE_FIELD(user, PersistedUser); };
-}  // namespace type_evolution_test::pre_evolution
+}  // namespace pre_evolution
 namespace post_evolution {
 CURRENT_STRUCT(User, SchemaV2::Name) { CURRENT_FIELD(key, std::string); };
 CURRENT_STORAGE_FIELD_ENTRY(OrderedDictionary, User, PersistedUser);
 CURRENT_STORAGE(Storage) { CURRENT_STORAGE_FIELD(user, PersistedUser); };
-}  // namespace type_evolution_test::pre_evolution
+}  // namespace post_evolution
 }  // namespace type_evolution_test
 
 #include "golden/storage_schema_original.h"
 #include "golden/storage_schema_evolved.h"
 
 // Default evolver copy-pasted from the boilerplate to evolve the `Transaction`, type of which has changed.
-CURRENT_TYPE_EVOLVER(OriginalStorageToModifiedStorageEvolver,
-                     SchemaOriginalStorage,
-                     Transaction,
-                     {
-                       CURRENT_NATURAL_EVOLVE(SchemaOriginalStorage, SchemaModifiedStorage, from.meta, into.meta);
-                       CURRENT_NATURAL_EVOLVE(
-                           SchemaOriginalStorage, SchemaModifiedStorage, from.mutations, into.mutations);
-                     });
+CURRENT_TYPE_EVOLVER(OriginalStorageToModifiedStorageEvolver, SchemaOriginalStorage, Transaction, {
+  CURRENT_NATURAL_EVOLVE(SchemaOriginalStorage, SchemaModifiedStorage, from.meta, into.meta);
+  CURRENT_NATURAL_EVOLVE(SchemaOriginalStorage, SchemaModifiedStorage, from.mutations, into.mutations);
+});
 
 // Custom evolution for `Name` stored as part of Storage's transactions.
-CURRENT_TYPE_EVOLVER(OriginalStorageToOriginalStorageEvolver,
-                     SchemaOriginalStorage,
-                     Name,
-                     {
-                       into.first = current::strings::ToUpper(from.first);
-                       into.last = current::strings::ToUpper(from.last);
-                     });
-
-CURRENT_TYPE_EVOLVER(OriginalStorageToModifiedStorageEvolver,
-                     SchemaOriginalStorage,
-                     Name,
-                     { into.full = from.last + ", " + from.first[0]; });
+CURRENT_TYPE_EVOLVER(OriginalStorageToOriginalStorageEvolver, SchemaOriginalStorage, Name, {
+  into.first = current::strings::ToUpper(from.first);
+  into.last = current::strings::ToUpper(from.last);
+});
+
+CURRENT_TYPE_EVOLVER(OriginalStorageToModifiedStorageEvolver, SchemaOriginalStorage, Name, {
+  into.full = from.last + ", " + from.first[0];
+});
 
 TEST(TypeEvolutionTest, StorageInnerTypes) {
   // Test the plain `Name` type goes through.
@@ -1027,8 +976,7 @@ TEST(TypeEvolutionTest, StorageTransactionsEvolution) {
   using post_evolution_transaction_t = current::storage::transaction_t<type_evolution_test::post_evolution::Storage>;
 
   static_assert(
-      !std::is_same_v<typename type_evolution_test::SchemaV1::Name, typename type_evolution_test::SchemaV2::Name>,
-      "");
+      !std::is_same_v<typename type_evolution_test::SchemaV1::Name, typename type_evolution_test::SchemaV2::Name>, "");
   static_assert(!std::is_same_v<pre_evolution_transaction_t, post_evolution_transaction_t>, "");
 
   {
@@ -1205,28 +1153,32 @@ TEST(TypeEvolutionTest, StorageTransactionsEvolution) {
       auto pre_evolution_storage = pre_storage_t::CreateMasterStorage();
 
       // Two transactions with two mutations in the second transaction, to test evolution through.
-      pre_evolution_storage->ReadWriteTransaction([](MutableFields<pre_storage_t> fields) {
-        type_evolution_test::pre_evolution::User karl;
-        karl.key = "karl";
-        fields.user.Add(karl);
-      }).Wait();
-
-      pre_evolution_storage->ReadWriteTransaction([](MutableFields<pre_storage_t> fields) {
-        {
-          type_evolution_test::pre_evolution::User dima;
-          dima.key = "dima";
-          dima.first = "Dima";
-          dima.last = "Korolev";
-          fields.user.Add(dima);
-        }
-        {
-          type_evolution_test::pre_evolution::User max;
-          max.key = "max";
-          max.first = "Max";
-          max.last = "Zhurovich";
-          fields.user.Add(max);
-        }
-      }).Wait();
+      pre_evolution_storage
+          ->ReadWriteTransaction([](MutableFields<pre_storage_t> fields) {
+            type_evolution_test::pre_evolution::User karl;
+            karl.key = "karl";
+            fields.user.Add(karl);
+          })
+          .Wait();
+
+      pre_evolution_storage
+          ->ReadWriteTransaction([](MutableFields<pre_storage_t> fields) {
+            {
+              type_evolution_test::pre_evolution::User dima;
+              dima.key = "dima";
+              dima.first = "Dima";
+              dima.last = "Korolev";
+              fields.user.Add(dima);
+            }
+            {
+              type_evolution_test::pre_evolution::User max;
+              max.key = "max";
+              max.first = "Max";
+              max.last = "Zhurovich";
+              fields.user.Add(max);
+            }
+          })
+          .Wait();
 
       // As mutations took place, create two storage log files to replay, one before and one after evolution.
       //
@@ -1311,20 +1263,22 @@ TEST(TypeEvolutionTest, StorageTransactionsEvolution) {
       using restored_pre_storage_t = type_evolution_test::pre_evolution::Storage<StreamStreamPersister>;
       auto replayed_pre_evolution_storage = restored_pre_storage_t::CreateMasterStorage(pre_evolution_file_name);
 
-      replayed_pre_evolution_storage->ReadOnlyTransaction([](ImmutableFields<restored_pre_storage_t> fields) {
-        EXPECT_EQ(3u, fields.user.Size());
-        EXPECT_TRUE(Exists(fields.user["karl"]));
-        EXPECT_FALSE(Exists(fields.user["bernie"]));
-        EXPECT_FALSE(Exists(fields.user["donald"]));
-        EXPECT_TRUE(Exists(fields.user["dima"]));
-        EXPECT_TRUE(Exists(fields.user["max"]));
-        EXPECT_EQ("KARL", Value(fields.user["karl"]).first);
-        EXPECT_EQ("MARX", Value(fields.user["karl"]).last);
-        EXPECT_EQ("DIMA", Value(fields.user["dima"]).first);
-        EXPECT_EQ("KOROLEV", Value(fields.user["dima"]).last);
-        EXPECT_EQ("MAX", Value(fields.user["max"]).first);
-        EXPECT_EQ("ZHUROVICH", Value(fields.user["max"]).last);
-      }).Wait();
+      replayed_pre_evolution_storage
+          ->ReadOnlyTransaction([](ImmutableFields<restored_pre_storage_t> fields) {
+            EXPECT_EQ(3u, fields.user.Size());
+            EXPECT_TRUE(Exists(fields.user["karl"]));
+            EXPECT_FALSE(Exists(fields.user["bernie"]));
+            EXPECT_FALSE(Exists(fields.user["donald"]));
+            EXPECT_TRUE(Exists(fields.user["dima"]));
+            EXPECT_TRUE(Exists(fields.user["max"]));
+            EXPECT_EQ("KARL", Value(fields.user["karl"]).first);
+            EXPECT_EQ("MARX", Value(fields.user["karl"]).last);
+            EXPECT_EQ("DIMA", Value(fields.user["dima"]).first);
+            EXPECT_EQ("KOROLEV", Value(fields.user["dima"]).last);
+            EXPECT_EQ("MAX", Value(fields.user["max"]).first);
+            EXPECT_EQ("ZHUROVICH", Value(fields.user["max"]).last);
+          })
+          .Wait();
     }
 
     // The full end-to-end schema test: confirm type-evolved transactions s.a. "First Last" became "Last, F".
@@ -1332,17 +1286,19 @@ TEST(TypeEvolutionTest, StorageTransactionsEvolution) {
       using restored_post_storage_t = type_evolution_test::post_evolution::Storage<StreamStreamPersister>;
       auto replayed_post_evolution_storage = restored_post_storage_t::CreateMasterStorage(post_evolution_file_name);
 
-      replayed_post_evolution_storage->ReadOnlyTransaction([](ImmutableFields<restored_post_storage_t> fields) {
-        EXPECT_EQ(3u, fields.user.Size());
-        EXPECT_TRUE(Exists(fields.user["karl"]));
-        EXPECT_FALSE(Exists(fields.user["bernie"]));
-        EXPECT_FALSE(Exists(fields.user["donald"]));
-        EXPECT_TRUE(Exists(fields.user["dima"]));
-        EXPECT_TRUE(Exists(fields.user["max"]));
-        EXPECT_EQ("Marx, K", Value(fields.user["karl"]).full);
-        EXPECT_EQ("Korolev, D", Value(fields.user["dima"]).full);
-        EXPECT_EQ("Zhurovich, M", Value(fields.user["max"]).full);
-      }).Wait();
+      replayed_post_evolution_storage
+          ->ReadOnlyTransaction([](ImmutableFields<restored_post_storage_t> fields) {
+            EXPECT_EQ(3u, fields.user.Size());
+            EXPECT_TRUE(Exists(fields.user["karl"]));
+            EXPECT_FALSE(Exists(fields.user["bernie"]));
+            EXPECT_FALSE(Exists(fields.user["donald"]));
+            EXPECT_TRUE(Exists(fields.user["dima"]));
+            EXPECT_TRUE(Exists(fields.user["max"]));
+            EXPECT_EQ("Marx, K", Value(fields.user["karl"]).full);
+            EXPECT_EQ("Korolev, D", Value(fields.user["dima"]).full);
+            EXPECT_EQ("Zhurovich, M", Value(fields.user["max"]).full);
+          })
+          .Wait();
     }
   }
 }
diff --git a/typesystem/evolution/type_evolution.h b/typesystem/evolution/type_evolution.h
index e89a24219..a7e944ee8 100644
--- a/typesystem/evolution/type_evolution.h
+++ b/typesystem/evolution/type_evolution.h
@@ -120,7 +120,7 @@ struct Evolve<FROM_NAMESPACE, Optional<OPTIONAL_INNER_TYPE>, EVOLVER> {
   }
 };
 
-}  // namespace current::type_evolution
+}  // namespace type_evolution
 }  // namespace current
 
 #define CURRENT_TYPE_EVOLVER(evolver, from_namespace, type_name, ...)                      \
diff --git a/typesystem/exceptions.h b/typesystem/exceptions.h
index 705a50b00..2faa0c875 100644
--- a/typesystem/exceptions.h
+++ b/typesystem/exceptions.h
@@ -64,11 +64,11 @@ struct IncompatibleVariantTypeException : Exception {};
 
 }  // namespace current
 
+using current::IncompatibleVariantTypeException;
 using current::NoValueException;
 using current::NoValueOfTypeException;
 using current::UninitializedVariantException;
 using current::UninitializedVariantOfTypeException;
-using current::IncompatibleVariantTypeException;
 
 using current::NoValue;                     // == `const NoValueException&` for cleaner `catch (NoValue)` syntax.
 using current::NoValueOfType;               // == `const NoValueOfTypeException<T>&` for cleaner `catch ()` syntax.
diff --git a/typesystem/helpers.h b/typesystem/helpers.h
index b70b7f0f2..4fd01ae37 100644
--- a/typesystem/helpers.h
+++ b/typesystem/helpers.h
@@ -106,9 +106,8 @@ struct ExistsImplCaller<T, T> {
 struct DefaultExistsInvocation {};
 template <typename TEST = DefaultExistsInvocation, typename T>
 bool Exists(T&& x) {
-  return ExistsImplCaller<
-      std::conditional_t<std::is_same_v<TEST, DefaultExistsInvocation>, current::decay_t<T>, TEST>,
-      current::decay_t<T>>::CallExistsImpl(std::forward<T>(x));
+  return ExistsImplCaller<std::conditional_t<std::is_same_v<TEST, DefaultExistsInvocation>, current::decay_t<T>, TEST>,
+                          current::decay_t<T>>::CallExistsImpl(std::forward<T>(x));
 }
 
 template <typename OUTPUT, typename INPUT, bool HAS_VALUE_IMPL_METHOD>
@@ -150,14 +149,13 @@ struct PowerfulValueImplCaller<T, T, true> {
 
 struct DefaultValueInvocation {};
 template <typename OUTPUT = DefaultValueInvocation, typename INPUT>
-auto Value(INPUT&& x) -> decltype(PowerfulValueImplCaller<
-    std::conditional_t<std::is_same_v<OUTPUT, DefaultValueInvocation>, INPUT, OUTPUT>,
-    INPUT,
-    sfinae::ValueImplMethodTest<INPUT>::value>::AccessValue(std::declval<INPUT>())) {
-  return PowerfulValueImplCaller<
-      std::conditional_t<std::is_same_v<OUTPUT, DefaultValueInvocation>, INPUT, OUTPUT>,
-      INPUT,
-      sfinae::ValueImplMethodTest<INPUT>::value>::AccessValue(std::forward<INPUT>(x));
+auto Value(INPUT&& x) -> decltype(
+    PowerfulValueImplCaller<std::conditional_t<std::is_same_v<OUTPUT, DefaultValueInvocation>, INPUT, OUTPUT>,
+                            INPUT,
+                            sfinae::ValueImplMethodTest<INPUT>::value>::AccessValue(std::declval<INPUT>())) {
+  return PowerfulValueImplCaller<std::conditional_t<std::is_same_v<OUTPUT, DefaultValueInvocation>, INPUT, OUTPUT>,
+                                 INPUT,
+                                 sfinae::ValueImplMethodTest<INPUT>::value>::AccessValue(std::forward<INPUT>(x));
 }
 
 // MSVS is not friendly with `std::enable_if_t` as return type, but OK with it as a template parameter. -- D.K.
@@ -179,8 +177,8 @@ void CheckIntegrity(T&& x) {
 
 }  // namespace current
 
+using current::CheckIntegrity;
 using current::Exists;
 using current::Value;
-using current::CheckIntegrity;
 
 #endif  // CURRENT_TYPE_SYSTEM_HELPERS_H
diff --git a/typesystem/optional.h b/typesystem/optional.h
index e47cb10d0..99e54fd0a 100644
--- a/typesystem/optional.h
+++ b/typesystem/optional.h
@@ -528,8 +528,8 @@ bool operator>=(const T& v, const Optional<T>& x) {
 
 }  // namespace current
 
+using current::FromBarePointer;
 using current::ImmutableOptional;
 using current::Optional;
-using current::FromBarePointer;
 
 #endif  // CURRENT_TYPE_SYSTEM_OPTIONAL_H
diff --git a/typesystem/reflection/reflection.h b/typesystem/reflection/reflection.h
index d33989c48..c7ceeb3ae 100644
--- a/typesystem/reflection/reflection.h
+++ b/typesystem/reflection/reflection.h
@@ -55,7 +55,7 @@ template <NameFormat NF>
 struct CurrentTypeNameImpl<NF, reflection::TypeID, false, false, true, false> {
   static const char* GetCurrentTypeName() { return "TypeID"; }
 };
-}  // namespace current::reflection::impl
+}  // namespace impl
 
 template <typename T_TYPE>
 reflection::TypeID InternalCurrentTypeID(std::type_index top_level_type, const char* top_level_type_name);
@@ -186,9 +186,8 @@ struct RecursiveTypeTraverser {
 
     VariantCaseReflectingInnerType data(result, std::make_pair(top_level_type_, top_level_type_name_));
 
-    current::metaprogramming::call_all_constructors_with<ReflectVariantCase,
-                                                         VariantCaseReflectingInnerType,
-                                                         TypeListImpl<TS...>>(data);
+    current::metaprogramming::
+        call_all_constructors_with<ReflectVariantCase, VariantCaseReflectingInnerType, TypeListImpl<TS...>>(data);
     return CalculateTypeID(result);
   }
 
@@ -445,9 +444,8 @@ struct ReflectorImpl {
     using T_VARIANT = VariantImpl<NAME, TypeListImpl<TS...>>;
     ReflectedType_Variant result;
     result.name = CurrentTypeName<T_VARIANT, NameFormat::Z>();
-    current::metaprogramming::call_all_constructors_with<ReflectVariantCase,
-                                                         ReflectedType_Variant,
-                                                         TypeListImpl<TS...>>(result);
+    current::metaprogramming::
+        call_all_constructors_with<ReflectVariantCase, ReflectedType_Variant, TypeListImpl<TS...>>(result);
     result.type_id = CurrentTypeID<T_VARIANT>();
     return ReflectedType(std::move(result));
   }
diff --git a/typesystem/reflection/test.cc b/typesystem/reflection/test.cc
index 9f848f1b5..0899794ba 100644
--- a/typesystem/reflection/test.cc
+++ b/typesystem/reflection/test.cc
@@ -80,23 +80,23 @@ CURRENT_ENUM(Enum, uint32_t) { Value1 = 1u, Value2 = 2u };
 
 using current::reflection::Reflector;
 
-static_assert(std::is_same_v<current::reflection::FieldTypeWrapper<uint64_t>,
-                             decltype(Foo::CURRENT_REFLECTION(
-                                 current::reflection::Index<current::reflection::FieldType, 0>()))>,
-              "");
-
-static_assert(std::is_same_v<current::reflection::FieldTypeWrapper<std::vector<uint64_t>>,
-                             decltype(Bar::CURRENT_REFLECTION(
-                                 current::reflection::Index<current::reflection::FieldType, 0>()))>,
-              "");
-static_assert(std::is_same_v<current::reflection::FieldTypeWrapper<std::vector<Foo>>,
-                             decltype(Bar::CURRENT_REFLECTION(
-                                 current::reflection::Index<current::reflection::FieldType, 1>()))>,
-              "");
-static_assert(std::is_same_v<current::reflection::FieldTypeWrapper<std::vector<std::vector<Foo>>>,
-                             decltype(Bar::CURRENT_REFLECTION(
-                                 current::reflection::Index<current::reflection::FieldType, 2>()))>,
-              "");
+static_assert(
+    std::is_same_v<current::reflection::FieldTypeWrapper<uint64_t>,
+                   decltype(Foo::CURRENT_REFLECTION(current::reflection::Index<current::reflection::FieldType, 0>()))>,
+    "");
+
+static_assert(
+    std::is_same_v<current::reflection::FieldTypeWrapper<std::vector<uint64_t>>,
+                   decltype(Bar::CURRENT_REFLECTION(current::reflection::Index<current::reflection::FieldType, 0>()))>,
+    "");
+static_assert(
+    std::is_same_v<current::reflection::FieldTypeWrapper<std::vector<Foo>>,
+                   decltype(Bar::CURRENT_REFLECTION(current::reflection::Index<current::reflection::FieldType, 1>()))>,
+    "");
+static_assert(
+    std::is_same_v<current::reflection::FieldTypeWrapper<std::vector<std::vector<Foo>>>,
+                   decltype(Bar::CURRENT_REFLECTION(current::reflection::Index<current::reflection::FieldType, 2>()))>,
+    "");
 
 static_assert(std::is_same_v<current::reflection::FieldTypeWrapper<std::string>,
                              decltype(Templated<uint64_t>::CURRENT_REFLECTION(
@@ -417,9 +417,9 @@ CURRENT_STRUCT(BlahBlahBlah) {  // No templation, but still same as `[templated_
 TEST(Reflection, TemplatedTypeIDs) {
   using namespace reflection_test;
 
+  using current::reflection::CurrentTypeID;
   using current::reflection::CurrentTypeName;
   using current::reflection::NameFormat;
-  using current::reflection::CurrentTypeID;
 
   const auto foo_typeid = static_cast<uint64_t>(CurrentTypeID<Foo>());
   EXPECT_EQ(9203762249085213197ull, foo_typeid);
@@ -480,9 +480,11 @@ TEST(Reflection, TemplatedTypeIDs) {
       std::is_same_v<current::reflection::TemplateInnerType<original_name_does_not_matter_when_exporting::BlahBlahBlah>,
                      Foo>,
       "");
-  EXPECT_EQ(foo_typeid,
-            static_cast<uint64_t>(CurrentTypeID<
-                current::reflection::TemplateInnerType<original_name_does_not_matter_when_exporting::BlahBlahBlah>>()));
+  EXPECT_EQ(
+      foo_typeid,
+      static_cast<uint64_t>(
+          CurrentTypeID<
+              current::reflection::TemplateInnerType<original_name_does_not_matter_when_exporting::BlahBlahBlah>>()));
 
   // Now test that both the original and the exported templated structs reflect same way internally.
   using current::reflection::ReflectedType_Struct;
@@ -525,10 +527,10 @@ CURRENT_STRUCT(X){};
 CURRENT_STRUCT(Y){};
 namespace explicitly_declared_named_variant_one {
 CURRENT_VARIANT(Variant_B_A_X_Y_E, A, X, Y);
-}  // namespace reflection_test::explicitly_declared_named_variant_one
+}  // namespace explicitly_declared_named_variant_one
 namespace explicitly_declared_named_variant_two {
 CURRENT_VARIANT(Variant_B_A_X_Y_E, A, X, Y);
-}  // namespace reflection_test::explicitly_declared_named_variant_two
+}  // namespace explicitly_declared_named_variant_two
 
 static_assert(!std::is_same_v<explicitly_declared_named_variant_one::Variant_B_A_X_Y_E, Variant<A, X, Y>>, "");
 static_assert(!std::is_same_v<explicitly_declared_named_variant_two::Variant_B_A_X_Y_E, Variant<A, X, Y>>, "");
@@ -542,8 +544,8 @@ TEST(Reflection, VariantAndCurrentVariantHaveSameTypeID) {
   using one_t = reflection_test::explicitly_declared_named_variant_one::Variant_B_A_X_Y_E;
   using two_t = reflection_test::explicitly_declared_named_variant_two::Variant_B_A_X_Y_E;
   using vanilla_t = Variant<reflection_test::A, reflection_test::X, reflection_test::Y>;
-  using current::reflection::Reflector;
   using current::reflection::ReflectedType_Variant;
+  using current::reflection::Reflector;
   EXPECT_EQ(static_cast<uint64_t>(Value<ReflectedType_Variant>(Reflector().ReflectType<one_t>()).type_id),
             static_cast<uint64_t>(Value<ReflectedType_Variant>(Reflector().ReflectType<vanilla_t>()).type_id));
   EXPECT_EQ(static_cast<uint64_t>(Value<ReflectedType_Variant>(Reflector().ReflectType<two_t>()).type_id),
@@ -562,15 +564,19 @@ TEST(Reflection, CurrentStructInternals) {
 
   Foo foo;
   foo.i = 100u;
-  foo.CURRENT_REFLECTION([](const std::string& name, const uint64_t& value) {
-    EXPECT_EQ("i", name);
-    EXPECT_EQ(100u, value);
-  }, Index<FieldNameAndImmutableValue, 0>());
-
-  foo.CURRENT_REFLECTION([](const std::string& name, uint64_t& value) {
-    EXPECT_EQ("i", name);
-    value = 123u;
-  }, Index<FieldNameAndMutableValue, 0>());
+  foo.CURRENT_REFLECTION(
+      [](const std::string& name, const uint64_t& value) {
+        EXPECT_EQ("i", name);
+        EXPECT_EQ(100u, value);
+      },
+      Index<FieldNameAndImmutableValue, 0>());
+
+  foo.CURRENT_REFLECTION(
+      [](const std::string& name, uint64_t& value) {
+        EXPECT_EQ("i", name);
+        value = 123u;
+      },
+      Index<FieldNameAndMutableValue, 0>());
   EXPECT_EQ(123u, foo.i);
 
   static_assert(std::is_same_v<SuperType<Bar>, ::current::CurrentStruct>, "");
@@ -805,11 +811,11 @@ CURRENT_STRUCT(BaseTypeTwo){};
 
 namespace one {
 CURRENT_STRUCT(IdenticalCurrentStructWithDifferentBaseType, BaseTypeOne){};
-}  // namespace reflection_test::one
+}  // namespace one
 
 namespace two {
 CURRENT_STRUCT(IdenticalCurrentStructWithDifferentBaseType, BaseTypeTwo){};
-}  // namespace reflection_test::two
+}  // namespace two
 
 using current::reflection::Reflector;
 
@@ -820,23 +826,24 @@ TEST(Reflection, BaseTypeMatters) {
   using current::reflection::ReflectedTypeBase;
   EXPECT_NE(static_cast<uint64_t>(Value<ReflectedTypeBase>(Reflector().ReflectType<BaseTypeOne>()).type_id),
             static_cast<uint64_t>(Value<ReflectedTypeBase>(Reflector().ReflectType<BaseTypeTwo>()).type_id));
-  EXPECT_NE(
-      static_cast<uint64_t>(Value<ReflectedTypeBase>(
-                                Reflector().ReflectType<one::IdenticalCurrentStructWithDifferentBaseType>()).type_id),
-      static_cast<uint64_t>(Value<ReflectedTypeBase>(
-                                Reflector().ReflectType<two::IdenticalCurrentStructWithDifferentBaseType>()).type_id));
+  EXPECT_NE(static_cast<uint64_t>(
+                Value<ReflectedTypeBase>(Reflector().ReflectType<one::IdenticalCurrentStructWithDifferentBaseType>())
+                    .type_id),
+            static_cast<uint64_t>(
+                Value<ReflectedTypeBase>(Reflector().ReflectType<two::IdenticalCurrentStructWithDifferentBaseType>())
+                    .type_id));
   EXPECT_EQ(9200000000962478099ull,
             static_cast<uint64_t>(Value<ReflectedTypeBase>(Reflector().ReflectType<BaseTypeOne>()).type_id));
   EXPECT_EQ(9200000001392004228ull,
             static_cast<uint64_t>(Value<ReflectedTypeBase>(Reflector().ReflectType<BaseTypeTwo>()).type_id));
-  EXPECT_EQ(
-      9205123477974540226ull,
-      static_cast<uint64_t>(Value<ReflectedTypeBase>(
-                                Reflector().ReflectType<one::IdenticalCurrentStructWithDifferentBaseType>()).type_id));
-  EXPECT_EQ(
-      9205123533591385154ull,
-      static_cast<uint64_t>(Value<ReflectedTypeBase>(
-                                Reflector().ReflectType<two::IdenticalCurrentStructWithDifferentBaseType>()).type_id));
+  EXPECT_EQ(9205123477974540226ull,
+            static_cast<uint64_t>(
+                Value<ReflectedTypeBase>(Reflector().ReflectType<one::IdenticalCurrentStructWithDifferentBaseType>())
+                    .type_id));
+  EXPECT_EQ(9205123533591385154ull,
+            static_cast<uint64_t>(
+                Value<ReflectedTypeBase>(Reflector().ReflectType<two::IdenticalCurrentStructWithDifferentBaseType>())
+                    .type_id));
 }
 
 namespace reflection_test {
diff --git a/typesystem/reflection/types.h b/typesystem/reflection/types.h
index ed3ba1a55..09b8d30fa 100644
--- a/typesystem/reflection/types.h
+++ b/typesystem/reflection/types.h
@@ -114,8 +114,8 @@ CURRENT_STRUCT(ReflectedType_Primitive, ReflectedTypeBase) {
 CURRENT_STRUCT(ReflectedType_Enum, ReflectedTypeBase) {
   CURRENT_FIELD(name, std::string);
   CURRENT_FIELD(underlying_type, TypeID);
-  CURRENT_CONSTRUCTOR(ReflectedType_Enum)(const std::string& name = "", TypeID rt = TypeID::UninitializedType)
-      : name(name), underlying_type(rt) {
+  CURRENT_CONSTRUCTOR(ReflectedType_Enum)
+  (const std::string& name = "", TypeID rt = TypeID::UninitializedType) : name(name), underlying_type(rt) {
     ReflectedTypeBase::type_id = static_cast<TypeID>(TYPEID_ENUM_TYPE + current::CRC32(name));
   }
 };
@@ -128,16 +128,15 @@ CURRENT_STRUCT(ReflectedType_Vector, ReflectedTypeBase) {
 CURRENT_STRUCT(ReflectedType_Map, ReflectedTypeBase) {
   CURRENT_FIELD(key_type, TypeID);
   CURRENT_FIELD(value_type, TypeID);
-  CURRENT_CONSTRUCTOR(ReflectedType_Map)(TypeID rk = TypeID::UninitializedType, TypeID rv = TypeID::UninitializedType)
-      : key_type(rk), value_type(rv) {}
+  CURRENT_CONSTRUCTOR(ReflectedType_Map)
+  (TypeID rk = TypeID::UninitializedType, TypeID rv = TypeID::UninitializedType) : key_type(rk), value_type(rv) {}
 };
 
 CURRENT_STRUCT(ReflectedType_UnorderedMap, ReflectedTypeBase) {
   CURRENT_FIELD(key_type, TypeID);
   CURRENT_FIELD(value_type, TypeID);
-  CURRENT_CONSTRUCTOR(ReflectedType_UnorderedMap)(TypeID rk = TypeID::UninitializedType,
-                                                  TypeID rv = TypeID::UninitializedType)
-      : key_type(rk), value_type(rv) {}
+  CURRENT_CONSTRUCTOR(ReflectedType_UnorderedMap)
+  (TypeID rk = TypeID::UninitializedType, TypeID rv = TypeID::UninitializedType) : key_type(rk), value_type(rv) {}
 };
 
 CURRENT_STRUCT(ReflectedType_Set, ReflectedTypeBase) {
@@ -153,8 +152,8 @@ CURRENT_STRUCT(ReflectedType_UnorderedSet, ReflectedTypeBase) {
 CURRENT_STRUCT(ReflectedType_Pair, ReflectedTypeBase) {
   CURRENT_FIELD(first_type, TypeID);
   CURRENT_FIELD(second_type, TypeID);
-  CURRENT_CONSTRUCTOR(ReflectedType_Pair)(TypeID rf = TypeID::UninitializedType, TypeID rs = TypeID::UninitializedType)
-      : first_type(rf), second_type(rs) {}
+  CURRENT_CONSTRUCTOR(ReflectedType_Pair)
+  (TypeID rf = TypeID::UninitializedType, TypeID rs = TypeID::UninitializedType) : first_type(rf), second_type(rs) {}
 };
 
 CURRENT_STRUCT(ReflectedType_Optional, ReflectedTypeBase) {
@@ -173,8 +172,8 @@ CURRENT_STRUCT(ReflectedType_Struct_Field) {
   CURRENT_FIELD(name, std::string);
   CURRENT_FIELD(description, Optional<std::string>);
   CURRENT_DEFAULT_CONSTRUCTOR(ReflectedType_Struct_Field){};
-  CURRENT_CONSTRUCTOR(ReflectedType_Struct_Field)(
-      TypeID type_id, const std::string& name, const Optional<std::string> description)
+  CURRENT_CONSTRUCTOR(ReflectedType_Struct_Field)
+  (TypeID type_id, const std::string& name, const Optional<std::string> description)
       : type_id(type_id), name(name), description(description) {}
 };
 
diff --git a/typesystem/schema/json_schema_format.h b/typesystem/schema/json_schema_format.h
index 0d58eb23d..4d8b2711b 100644
--- a/typesystem/schema/json_schema_format.h
+++ b/typesystem/schema/json_schema_format.h
@@ -109,7 +109,7 @@ CURRENT_STRUCT(error) {
 
 // clang-format on
 
-}  // namespace current::reflection::variant_clean_type_names
+}  // namespace variant_clean_type_names
 
 CURRENT_STRUCT(JSONSchemaObjectField) {
   CURRENT_FIELD(field, std::string);
@@ -124,7 +124,7 @@ CURRENT_STRUCT(JSONSchemaObject) {
 
 using JSONSchema = std::vector<JSONSchemaObject>;
 
-}  // namespace current::reflection
+}  // namespace reflection
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_SCHEMA_JSON_SCHEMA_FORMAT_CC
diff --git a/typesystem/schema/schema.h b/typesystem/schema/schema.h
index 083101453..73f6473da 100644
--- a/typesystem/schema/schema.h
+++ b/typesystem/schema/schema.h
@@ -169,11 +169,13 @@ struct CurrentStructPrinter<CPPLanguageSelector::CurrentStructs> {
     std::ostream& os_;
     const std::string type_code_;
     OptionalNamespaceScope(std::ostream& os, TypeID type_id) : os_(os), type_code_(current::ToString(type_id)) {
-      os_ << "#ifndef CURRENT_SCHEMA_FOR_T" << type_code_ << '\n' << "#define CURRENT_SCHEMA_FOR_T" << type_code_
-          << '\n' << "namespace t" << type_code_ << " {\n";
+      os_ << "#ifndef CURRENT_SCHEMA_FOR_T" << type_code_ << '\n'
+          << "#define CURRENT_SCHEMA_FOR_T" << type_code_ << '\n'
+          << "namespace t" << type_code_ << " {\n";
     }
     ~OptionalNamespaceScope() {
-      os_ << "}  // namespace t" << type_code_ << '\n' << "#endif  // CURRENT_SCHEMA_FOR_T_" << type_code_ << '\n'
+      os_ << "}  // namespace t" << type_code_ << '\n'
+          << "#endif  // CURRENT_SCHEMA_FOR_T_" << type_code_ << '\n'
           << '\n';
     }
   };
@@ -422,8 +424,10 @@ struct LanguageSyntaxCPP : CurrentStructPrinter<CPP_LANGUAGE_SELECTOR> {
         os_ << "#endif  // CURRENT_NAMESPACE_" << nmspc << "_DEFINED\n";
 
         // Thing two: natural evolvers for all the generated types.
-        os_ << '\n' << "namespace current {\n"
-            << "namespace type_evolution {\n" << '\n';
+        os_ << '\n'
+            << "namespace current {\n"
+            << "namespace type_evolution {\n"
+            << '\n';
 
         // To only output distinct `Variant<>` & `CURRENT_VARIANT`-s once.
         // TODO(dkorolev): Strictly speaking, unnecessary, as we guard each evolver by its own `#ifdef`.
@@ -452,7 +456,8 @@ struct LanguageSyntaxCPP : CurrentStructPrinter<CPP_LANGUAGE_SELECTOR> {
             }
             const std::string origin_guard =
                 "DEFAULT_EVOLUTION_" + current::strings::ToUpper(SHA256(origin)) + "  // " + origin;
-            os_ << "#ifndef " << origin_guard << '\n' << "#define " << origin_guard << '\n'
+            os_ << "#ifndef " << origin_guard << '\n'
+                << "#define " << origin_guard << '\n'
                 << "template <typename CURRENT_ACTIVE_EVOLVER>\n"
                 << "struct Evolve<" << nmspc << ", " << origin << ", CURRENT_ACTIVE_EVOLVER> {\n"
                 << "  using FROM = " << nmspc << ";\n"
@@ -475,7 +480,8 @@ struct LanguageSyntaxCPP : CurrentStructPrinter<CPP_LANGUAGE_SELECTOR> {
             }
             os_ << "  }\n"
                 << "};\n"
-                << "#endif\n" << '\n';
+                << "#endif\n"
+                << '\n';
           } else if (Exists<ReflectedType_Variant>(type_substance)) {
             // Default evolver for `CURRENT_VARIANT`, or for a plain `Variant<>`.
             const auto bare_variant_name = Value<ReflectedType_Variant>(type_substance).name;
@@ -503,7 +509,8 @@ struct LanguageSyntaxCPP : CurrentStructPrinter<CPP_LANGUAGE_SELECTOR> {
                 "DEFAULT_EVOLUTION_" + current::strings::ToUpper(SHA256(origin)) + "  // " + origin;
             os_ << "// Default evolution for `Variant<" << current::strings::Join(cases, ", ") << ">`.\n";
             const std::string evltr = nmspc + '_' + bare_variant_name + "_Cases";
-            os_ << "#ifndef " << origin_guard << '\n' << "#define " << origin_guard << '\n'
+            os_ << "#ifndef " << origin_guard << '\n'
+                << "#define " << origin_guard << '\n'
                 << "template <typename DST, typename FROM_NAMESPACE, typename INTO, typename CURRENT_ACTIVE_EVOLVER>\n"
                 << "struct " << evltr << " {\n"
                 << "  DST& into;\n"
@@ -527,7 +534,8 @@ struct LanguageSyntaxCPP : CurrentStructPrinter<CPP_LANGUAGE_SELECTOR> {
                 << ", INTO, CURRENT_ACTIVE_EVOLVER>(into));\n"
                 << "  }\n"
                 << "};\n"
-                << "#endif\n" << '\n';
+                << "#endif\n"
+                << '\n';
           } else if (Exists<ReflectedType_Enum>(type_substance)) {
             // Default evolver for `CURRENT_ENUM`.
             const auto& e = Value<ReflectedType_Enum>(type_substance);
@@ -535,7 +543,8 @@ struct LanguageSyntaxCPP : CurrentStructPrinter<CPP_LANGUAGE_SELECTOR> {
             const std::string origin_guard =
                 "DEFAULT_EVOLUTION_" + current::strings::ToUpper(SHA256(origin)) + "  // " + origin;
             os_ << "// Default evolution for `CURRENT_ENUM(" << e.name << ")`.\n"
-                << "#ifndef " << origin_guard << '\n' << "#define " << origin_guard << '\n'
+                << "#ifndef " << origin_guard << '\n'
+                << "#define " << origin_guard << '\n'
                 << "template <typename CURRENT_ACTIVE_EVOLVER>\n"
                 << "struct Evolve<" << nmspc << ", " << origin << ", CURRENT_ACTIVE_EVOLVER> {\n"
                 << "  template <typename INTO>\n"
@@ -544,7 +553,8 @@ struct LanguageSyntaxCPP : CurrentStructPrinter<CPP_LANGUAGE_SELECTOR> {
                 << "    into = static_cast<typename INTO::" << e.name << ">(from);\n"
                 << "  }\n"
                 << "};\n"
-                << "#endif\n" << '\n';
+                << "#endif\n"
+                << '\n';
           } else if (Exists<ReflectedType_Optional>(type_substance)) {
             // Default evolver for this particular `Optional<T>`.
             // The global, top-level one, can only work if the underlying type does not change.
@@ -567,7 +577,8 @@ struct LanguageSyntaxCPP : CurrentStructPrinter<CPP_LANGUAGE_SELECTOR> {
                   "DEFAULT_EVOLUTION_" + current::strings::ToUpper(SHA256(origin)) + "  // " + origin;
               // No need to spell out evolution of `Optional<>` for basic types, string-s, and millis/micros.
               os_ << "// Default evolution for `Optional<" << bare_optional_type_name << ">`.\n"
-                  << "#ifndef " << origin_guard << '\n' << "#define " << origin_guard << '\n'
+                  << "#ifndef " << origin_guard << '\n'
+                  << "#define " << origin_guard << '\n'
                   << "template <typename CURRENT_ACTIVE_EVOLVER>\n"
                   << "struct Evolve<" << nmspc << ", " << origin << ", CURRENT_ACTIVE_EVOLVER> {\n"
                   << "  template <typename INTO, typename INTO_TYPE>\n"
@@ -584,7 +595,8 @@ struct LanguageSyntaxCPP : CurrentStructPrinter<CPP_LANGUAGE_SELECTOR> {
                   << "    }\n"
                   << "  }\n"
                   << "};\n"
-                  << "#endif\n" << '\n';
+                  << "#endif\n"
+                  << '\n';
             }
           }
         }
@@ -1259,12 +1271,12 @@ struct LanguageSyntaxImpl<Language::TypeScript> final {
           }
 #endif  // #if 0
 
-          std::string HackyGetName(const TypeID type_id, ShouldAddParens should_add_parens = ShouldAddParens::No) const {
+          std::string HackyGetName(const TypeID type_id,
+                                   ShouldAddParens should_add_parens = ShouldAddParens::No) const {
             const TSType t = self_.TSTypeName(type_id);
-            return
-              (should_add_parens == ShouldAddParens::Yes && t.need_parentheses_if_part_of_complex_expression)
-              ? ('(' + t.name + ')')
-              : t.name;
+            return (should_add_parens == ShouldAddParens::Yes && t.need_parentheses_if_part_of_complex_expression)
+                       ? ('(' + t.name + ')')
+                       : t.name;
           }
 
           // `operator()(...)`-s of this block print TypeScript type name only, without the expansion.
@@ -1610,7 +1622,7 @@ struct ToStringImpl<reflection::Language, false, true> final {
     }
   }
 };
-}  // namespace current::strings
+}  // namespace strings
 
 }  // namespace current
 
diff --git a/typesystem/schema/test.cc b/typesystem/schema/test.cc
index 88cc21f6e..068501924 100644
--- a/typesystem/schema/test.cc
+++ b/typesystem/schema/test.cc
@@ -82,9 +82,9 @@ CURRENT_VARIANT(NamedVariantXY, X, Y);  // using NamedVariantXY = Variant<X, Y>;
 
 TEST(Schema, StructSchema) {
   using namespace schema_test;
+  using current::reflection::Language;
   using current::reflection::SchemaInfo;
   using current::reflection::StructSchema;
-  using current::reflection::Language;
 
   StructSchema struct_schema;
   {
@@ -167,9 +167,9 @@ TEST(Schema, StructSchema) {
 
 TEST(Schema, VariantAloneIsTraversed) {
   using namespace schema_test;
+  using current::reflection::Language;
   using current::reflection::SchemaInfo;
   using current::reflection::StructSchema;
-  using current::reflection::Language;
 
   StructSchema struct_schema;
 
@@ -217,9 +217,9 @@ CURRENT_STRUCT(SelfContainingC, SelfContainingA) {
 
 TEST(Schema, SelfContainingStruct) {
   using namespace schema_test;
-  using current::reflection::StructSchema;
-  using current::reflection::SchemaInfo;
   using current::reflection::Language;
+  using current::reflection::SchemaInfo;
+  using current::reflection::StructSchema;
 
   StructSchema struct_schema;
   struct_schema.AddType<SelfContainingC>();
@@ -249,9 +249,9 @@ TEST(Schema, SelfContainingStruct) {
 // NOTE(dkorolev): Commented out in July 2020.
 TEST(Schema, SmokeTestFullStruct) {
   using current::FileSystem;
-  using current::reflection::StructSchema;
-  using current::reflection::SchemaInfo;
   using current::reflection::Language;
+  using current::reflection::SchemaInfo;
+  using current::reflection::StructSchema;
 
   const auto Golden = [](const std::string& s) { return FileSystem::JoinPath("golden", s); };
   const auto Serialized = [](const std::string& s) { return FileSystem::JoinPath("serialized", s); };
@@ -331,9 +331,9 @@ CURRENT_STRUCT(FS) {
 
 TEST(Schema, FSharpSanitization) {
   using namespace schema_test;
+  using current::reflection::Language;
   using current::reflection::SchemaInfo;
   using current::reflection::StructSchema;
-  using current::reflection::Language;
 
   StructSchema struct_schema;
 
@@ -359,8 +359,8 @@ namespace current {
 namespace type_evolution {
 template <typename FROM_NAMESPACE, typename FROM_TYPE, typename EVOLVER = ::current::type_evolution::NaturalEvolver>
 struct Evolve;
-}  // namespace schema_test::current::type_evolution
-}  // namespace schema_test::current
+}  // namespace type_evolution
+}  // namespace current
 
 #include "golden/smoke_test_struct.h"
 }  // namespace schema_test
@@ -457,18 +457,18 @@ namespace current {
 namespace type_evolution {
 template <typename FROM_NAMESPACE, typename FROM_TYPE, typename EVOLVER = ::current::type_evolution::NaturalEvolver>
 struct Evolve;
-}  // namespace schema_test::current::type_evolution
-}  // namespace schema_test::current
+}  // namespace type_evolution
+}  // namespace current
 
 #include "golden/smoke_test_template.h"  // The `golden/smoke_test_template{"","_2","3"}.h` files are identical.
 }  // namespace smoke_test_templates_namespace_autogenerated
 
 template <typename T>
 std::string TemplatedStructSchemaAsCPP() {
-  using current::reflection::StructSchema;
-  using current::reflection::SchemaInfo;
   using current::reflection::Language;
   using current::reflection::NamespaceToExpose;
+  using current::reflection::SchemaInfo;
+  using current::reflection::StructSchema;
 
   StructSchema struct_schema;
   struct_schema.AddType<T>();
diff --git a/typesystem/serialization/exceptions_base.h b/typesystem/serialization/exceptions_base.h
index 5e198c105..71f1f5b5f 100644
--- a/typesystem/serialization/exceptions_base.h
+++ b/typesystem/serialization/exceptions_base.h
@@ -47,14 +47,14 @@ struct InvalidJSONException : TypeSystemParseJSONException {
 
 struct JSONUninitializedVariantObjectException : TypeSystemParseJSONException {};
 
-}  // namepsace current::serialization::json
+}  // namespace json
 
-}  // namespace current::serialization
+}  // namespace serialization
 }  // namespace current
 
 using current::serialization::json::InvalidJSONException;
-using current::serialization::json::TypeSystemParseJSONException;
-using current::serialization::json::RapidJSONAssertionFailedException;
 using current::serialization::json::JSONUninitializedVariantObjectException;
+using current::serialization::json::RapidJSONAssertionFailedException;
+using current::serialization::json::TypeSystemParseJSONException;
 
 #endif  // TYPE_SYSTEM_SERIALIZATION_EXCEPTIONS_BASE_H
diff --git a/typesystem/serialization/json/enum.h b/typesystem/serialization/json/enum.h
index 3f9399bc2..c4cf16a20 100644
--- a/typesystem/serialization/json/enum.h
+++ b/typesystem/serialization/json/enum.h
@@ -63,7 +63,7 @@ struct DeserializeImpl<json::JSONParser<JSON_FORMAT>, T, std::enable_if_t<std::i
   }
 };
 
-}  // namespace current::serialization
+}  // namespace serialization
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_SERIALIZATION_JSON_ENUM_H
diff --git a/typesystem/serialization/json/exceptions.h b/typesystem/serialization/json/exceptions.h
index d8de8db56..a5b3aaa42 100644
--- a/typesystem/serialization/json/exceptions.h
+++ b/typesystem/serialization/json/exceptions.h
@@ -72,8 +72,8 @@ struct JSONSchemaException : TypeSystemParseJSONException {
   }
 };
 
-}  // namespace current::serialization::json
-}  // namespace current::serialization
+}  // namespace json
+}  // namespace serialization
 }  // namespace current
 
 #endif  // TYPE_SYSTEM_SERIALIZATION_JSON_EXCEPTIONS_H
diff --git a/typesystem/serialization/json/immutable_optional.h b/typesystem/serialization/json/immutable_optional.h
index f86a5f4c2..b69399bd8 100644
--- a/typesystem/serialization/json/immutable_optional.h
+++ b/typesystem/serialization/json/immutable_optional.h
@@ -132,8 +132,8 @@ struct DeserializeImpl<json::JSONParser<JSONFormat::NewtonsoftFSharp>, Immutable
         }
       }
       if (!ok) {
-        CURRENT_THROW(JSONSchemaException("optional as `null` or `{\"Case\":\"Some\",\"Fields\":[value]}`",
-                                          json_parser));
+        CURRENT_THROW(
+            JSONSchemaException("optional as `null` or `{\"Case\":\"Some\",\"Fields\":[value]}`", json_parser));
       }
     }
   }
@@ -146,7 +146,7 @@ struct IsJSONSerializable<ImmutableOptional<T>> {
 };
 }  // namespace json
 
-}  // namespace current::serialization
+}  // namespace serialization
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_SERIALIZATION_JSON_IMMUTABLE_OPTIONAL_H
diff --git a/typesystem/serialization/json/json.h b/typesystem/serialization/json/json.h
index a6cb9e5ff..17441083a 100644
--- a/typesystem/serialization/json/json.h
+++ b/typesystem/serialization/json/json.h
@@ -420,29 +420,29 @@ inline Optional<T> TryParseJSON(const strings::Chunk& source) {
   return TryParseJSON<T, J>(source.c_str());
 }
 
-}  // namespace current::serialization::json
-}  // namespace current::serialization
+}  // namespace json
+}  // namespace serialization
 
 // Keep top-level symbols both in `current::` and in global namespace.
+using serialization::json::InvalidJSONException;
 using serialization::json::JSON;
-using serialization::json::ParseJSON;
-using serialization::json::TryParseJSON;
-using serialization::json::PatchObjectWithJSON;
 using serialization::json::JSONFormat;
-using serialization::json::TypeSystemParseJSONException;
 using serialization::json::JSONSchemaException;
-using serialization::json::InvalidJSONException;
 using serialization::json::JSONUninitializedVariantObjectException;
+using serialization::json::ParseJSON;
+using serialization::json::PatchObjectWithJSON;
+using serialization::json::TryParseJSON;
+using serialization::json::TypeSystemParseJSONException;
 }  // namespace current
 
+using current::InvalidJSONException;
 using current::JSON;
-using current::ParseJSON;
-using current::TryParseJSON;
-using current::PatchObjectWithJSON;
 using current::JSONFormat;
-using current::TypeSystemParseJSONException;
 using current::JSONSchemaException;
-using current::InvalidJSONException;
 using current::JSONUninitializedVariantObjectException;
+using current::ParseJSON;
+using current::PatchObjectWithJSON;
+using current::TryParseJSON;
+using current::TypeSystemParseJSONException;
 
 #endif  // CURRENT_TYPE_SYSTEM_SERIALIZATION_JSON_JSON_H
diff --git a/typesystem/serialization/json/map.h b/typesystem/serialization/json/map.h
index a8cdd118a..3713bc6cc 100644
--- a/typesystem/serialization/json/map.h
+++ b/typesystem/serialization/json/map.h
@@ -88,8 +88,8 @@ struct DeserializeImpl<json::JSONParser<JSON_FORMAT>, std::map<TK, TV, TC, TA>,
   }
 
   template <typename K = TK>
-  static std::enable_if_t<!std::is_same_v<std::string, K>> DoDeserialize(
-      json::JSONParser<JSON_FORMAT>& json_parser, std::map<TK, TV, TC, TA>& destination) {
+  static std::enable_if_t<!std::is_same_v<std::string, K>> DoDeserialize(json::JSONParser<JSON_FORMAT>& json_parser,
+                                                                         std::map<TK, TV, TC, TA>& destination) {
     if (json_parser && json_parser.Current().IsArray()) {
       destination.clear();
       for (rapidjson::Value::ValueIterator cit = json_parser.Current().Begin(); cit != json_parser.Current().End();
@@ -119,7 +119,7 @@ struct IsJSONSerializable<std::map<K, V, CMP, ALLOC>> {
 };
 }  // namespace json
 
-}  // namespace current::serialization
+}  // namespace serialization
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_SERIALIZATION_JSON_MAP_H
diff --git a/typesystem/serialization/json/optional.h b/typesystem/serialization/json/optional.h
index e4105bc6b..dff392cb2 100644
--- a/typesystem/serialization/json/optional.h
+++ b/typesystem/serialization/json/optional.h
@@ -129,8 +129,8 @@ struct DeserializeImpl<json::JSONParser<JSONFormat::NewtonsoftFSharp>, Optional<
         }
       }
       if (!ok) {
-        CURRENT_THROW(JSONSchemaException("optional as `null` or `{\"Case\":\"Some\",\"Fields\":[value]}`",
-                                          json_parser));
+        CURRENT_THROW(
+            JSONSchemaException("optional as `null` or `{\"Case\":\"Some\",\"Fields\":[value]}`", json_parser));
       }
     }
   }
@@ -143,7 +143,7 @@ struct IsJSONSerializable<Optional<T>> {
 };
 }  // namespace json
 
-}  // namespace current::serialization
+}  // namespace serialization
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_SERIALIZATION_JSON_OPTIONAL_H
diff --git a/typesystem/serialization/json/pair.h b/typesystem/serialization/json/pair.h
index 544835372..262497f7e 100644
--- a/typesystem/serialization/json/pair.h
+++ b/typesystem/serialization/json/pair.h
@@ -94,7 +94,7 @@ struct IsJSONSerializable<std::pair<F, S>> {
 };
 }  // namespace json
 
-}  // namespace current::serialization
+}  // namespace serialization
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_SERIALIZATION_JSON_PAIR_H
diff --git a/typesystem/serialization/json/primitives.h b/typesystem/serialization/json/primitives.h
index 74972e3cf..c33330370 100644
--- a/typesystem/serialization/json/primitives.h
+++ b/typesystem/serialization/json/primitives.h
@@ -56,7 +56,7 @@ struct JSONValueAssignerImpl<std::chrono::milliseconds> {
     destination.SetInt64(value.count());
   }
 };
-}  // namespace curent::serialization::json
+}  // namespace json
 
 #define CURRENT_DECLARE_PRIMITIVE_TYPE(typeid_index, cpp_type, current_type, fs_type, md_type, typescript_type) \
   template <class JSON_FORMAT>                                                                                  \
@@ -176,7 +176,7 @@ struct DeserializeImpl<json::JSONParser<JSON_FORMAT>, std::chrono::microseconds>
   }
 };
 
-}  // namespace current::serialization
+}  // namespace serialization
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_SERIALIZATION_JSON_PRIMITIVES_H
diff --git a/typesystem/serialization/json/set.h b/typesystem/serialization/json/set.h
index ea36ce825..bf28d6e12 100644
--- a/typesystem/serialization/json/set.h
+++ b/typesystem/serialization/json/set.h
@@ -71,7 +71,7 @@ struct IsJSONSerializable<std::set<T, CMP, ALLOC>> {
 };
 }  // namespace json
 
-}  // namespace current::serialization
+}  // namespace serialization
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_SERIALIZATION_JSON_SET_H
diff --git a/typesystem/serialization/json/struct.h b/typesystem/serialization/json/struct.h
index baf586f1e..8a1a6a0c7 100644
--- a/typesystem/serialization/json/struct.h
+++ b/typesystem/serialization/json/struct.h
@@ -75,7 +75,7 @@ struct SerializeStructImpl<JSON_FORMAT, CurrentStruct> {
   static void SerializeStruct(JSONStructFieldsSerializer<JSON_FORMAT>&, const CurrentStruct&) {}
 };
 
-}  // namespace current::serialization::json
+}  // namespace json
 
 template <class JSON_FORMAT, typename T>
 struct SerializeImpl<json::JSONStringifier<JSON_FORMAT>,
@@ -132,7 +132,7 @@ struct DeserializeImpl<json::JSONParser<JSON_FORMAT>,
   }
 };
 
-}  // namespace current::serialization
+}  // namespace serialization
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_SERIALIZATION_JSON_STRUCT_H
diff --git a/typesystem/serialization/json/tuple.h b/typesystem/serialization/json/tuple.h
index 38ab07453..a0a2cab5c 100644
--- a/typesystem/serialization/json/tuple.h
+++ b/typesystem/serialization/json/tuple.h
@@ -45,8 +45,7 @@ struct SerializeTupleImpl {
 
 template <class JSON_FORMAT, class TUPLE, int N>
 struct SerializeTupleImpl<JSON_FORMAT, TUPLE, N, N> {
-  static void DoIt(json::JSONStringifier<JSON_FORMAT>&, const TUPLE&) {
-  }
+  static void DoIt(json::JSONStringifier<JSON_FORMAT>&, const TUPLE&) {}
 };
 
 template <class JSON_FORMAT, typename... TS>
@@ -67,8 +66,7 @@ struct DeserializeTupleImpl {
 
 template <class JSON_FORMAT, class TUPLE, int N>
 struct DeserializeTupleImpl<JSON_FORMAT, TUPLE, N, N> {
-  static void DoIt(json::JSONParser<JSON_FORMAT>&, TUPLE&) {
-  }
+  static void DoIt(json::JSONParser<JSON_FORMAT>&, TUPLE&) {}
 };
 
 template <class JSON_FORMAT, typename... TS>
@@ -98,7 +96,7 @@ struct IsJSONSerializable<std::tuple<T, TS...>> {
 };
 }  // namespace json
 
-}  // namespace current::serialization
+}  // namespace serialization
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_SERIALIZATION_JSON_TUPLE_H
diff --git a/typesystem/serialization/json/typeid.h b/typesystem/serialization/json/typeid.h
index f18d3ac0c..10f2aa4bf 100644
--- a/typesystem/serialization/json/typeid.h
+++ b/typesystem/serialization/json/typeid.h
@@ -62,7 +62,7 @@ struct IsJSONSerializable<reflection::TypeID> {
 };
 }  // namespace json
 
-}  // namespace current::serialization
+}  // namespace serialization
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_SERIALIZATION_JSON_TYPEID_H
diff --git a/typesystem/serialization/json/unordered_map.h b/typesystem/serialization/json/unordered_map.h
index 423083106..1017f320b 100644
--- a/typesystem/serialization/json/unordered_map.h
+++ b/typesystem/serialization/json/unordered_map.h
@@ -123,7 +123,7 @@ struct IsJSONSerializable<std::unordered_map<K, V, HASH, ALLOC>> {
 };
 }  // namespace json
 
-}  // namespace current::serialization
+}  // namespace serialization
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_SERIALIZATION_JSON_UNORDERED_MAP_H
diff --git a/typesystem/serialization/json/unordered_set.h b/typesystem/serialization/json/unordered_set.h
index cbb22ab05..36d5798dc 100644
--- a/typesystem/serialization/json/unordered_set.h
+++ b/typesystem/serialization/json/unordered_set.h
@@ -72,7 +72,7 @@ struct IsJSONSerializable<std::unordered_set<T, HASH, ALLOC>> {
 };
 }  // namespace json
 
-}  // namespace current::serialization
+}  // namespace serialization
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_SERIALIZATION_JSON_UNORDERED_SET_H
diff --git a/typesystem/serialization/json/variant.h b/typesystem/serialization/json/variant.h
index 3901f4481..17eedcb28 100644
--- a/typesystem/serialization/json/variant.h
+++ b/typesystem/serialization/json/variant.h
@@ -253,9 +253,8 @@ class JSONVariantPerStyle<JSONVariantStyle::Current, JSON_FORMAT, VARIANT> {
   class Impl {
    public:
     Impl() {
-      current::metaprogramming::call_all_constructors_with<Registerer,
-                                                           deserializers_map_t,
-                                                           typename VARIANT::typelist_t>(deserializers_);
+      current::metaprogramming::
+          call_all_constructors_with<Registerer, deserializers_map_t, typename VARIANT::typelist_t>(deserializers_);
     }
 
     void DoLoadVariant(JSONParser<JSON_FORMAT>& json_parser, VARIANT& destination) const {
@@ -399,7 +398,7 @@ class JSONVariantPerStyle<JSONVariantStyle::NewtonsoftFSharp, JSON_FORMAT, VARIA
   }
 };
 
-}  // namespace current::serialization::json
+}  // namespace json
 
 template <class JSON_FORMAT, typename T>
 struct SerializeImpl<json::JSONStringifier<JSON_FORMAT>, T, std::enable_if_t<IS_CURRENT_VARIANT(T)>> {
@@ -431,7 +430,7 @@ struct DeserializeImpl<json::JSONParser<JSON_FORMAT>, T, std::enable_if_t<IS_CUR
   }
 };
 
-}  // namespace current::serialization
+}  // namespace serialization
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_SERIALIZATION_JSON_VARIANT_H
diff --git a/typesystem/serialization/json/vector.h b/typesystem/serialization/json/vector.h
index fec949616..270138028 100644
--- a/typesystem/serialization/json/vector.h
+++ b/typesystem/serialization/json/vector.h
@@ -97,7 +97,7 @@ struct IsJSONSerializable<std::vector<T, ALLOC>> {
 };
 }  // namespace json
 
-}  // namespace current::serialization
+}  // namespace serialization
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_SERIALIZATION_JSON_VECTOR_H
diff --git a/typesystem/serialization/test.cc b/typesystem/serialization/test.cc
index 84983e0e2..a38f4ebe6 100644
--- a/typesystem/serialization/test.cc
+++ b/typesystem/serialization/test.cc
@@ -178,7 +178,7 @@ CURRENT_VARIANT(NestedQ, InnerA, InnerB);
 CURRENT_VARIANT(InnerVariant, WithVectorOfPairs, WithOptional);
 CURRENT_STRUCT(WithInnerVariant) { CURRENT_FIELD(v, InnerVariant); };
 
-}  // namespace serialization_test::named_variant
+}  // namespace named_variant
 }  // namespace serialization_test
 
 #if 0
@@ -816,11 +816,11 @@ TEST(JSONSerialization, Exceptions) {
 
 TEST(JSONSerialization, StructSchema) {
   using namespace serialization_test;
-  using current::reflection::TypeID;
+  using current::reflection::Language;
   using current::reflection::Reflector;
   using current::reflection::SchemaInfo;
   using current::reflection::StructSchema;
-  using current::reflection::Language;
+  using current::reflection::TypeID;
 
   StructSchema struct_schema;
   struct_schema.AddType<ComplexSerializable>();
@@ -1320,10 +1320,12 @@ TEST(JSONSerialization, TemplatedValue) {
   EXPECT_EQ(43, ParseJSON<DerivedTemplatedValue<std::string>>("{\"base\":43,\"derived\":\"meh\"}").base);
   EXPECT_EQ(100ull,
             ParseJSON<DerivedTemplatedValue<Serializable>>(
-                "{\"base\":1,\"derived\":{\"i\":100,\"s\":\"one\",\"b\":false,\"e\":0}}").derived.i);
+                "{\"base\":1,\"derived\":{\"i\":100,\"s\":\"one\",\"b\":false,\"e\":0}}")
+                .derived.i);
   EXPECT_EQ(43,
             ParseJSON<DerivedTemplatedValue<Serializable>>(
-                "{\"base\":43,\"derived\":{\"i\":1,\"s\":\"\",\"b\":true,\"e\":0}}").base);
+                "{\"base\":43,\"derived\":{\"i\":1,\"s\":\"\",\"b\":true,\"e\":0}}")
+                .base);
 }
 
 TEST(JSONSerialization, SimpleTemplatedUsage) {
@@ -1580,8 +1582,8 @@ CURRENT_STRUCT(NonEmptyDerivedFromNonTemplatedBase, NonTemplatedBase) {
 
 CURRENT_STRUCT(NonEmptyDerivedFromTemplatedBase, TemplatedBase<std::string>) {
   CURRENT_FIELD(w, uint32_t);
-  CURRENT_CONSTRUCTOR(NonEmptyDerivedFromTemplatedBase)(uint32_t i, std::string s, uint32_t w)
-      : SUPER(i, std::move(s)), w(w) {}
+  CURRENT_CONSTRUCTOR(NonEmptyDerivedFromTemplatedBase)
+  (uint32_t i, std::string s, uint32_t w) : SUPER(i, std::move(s)), w(w) {}
 };
 
 }  // namespace serialization_test
@@ -1600,7 +1602,8 @@ TEST(JSONSerialization, DerivedSupportsConstructorForwarding) {
 
   EXPECT_EQ("{'i':12321,'x':'baz'}", SingleQuoted(JSON(EmptyDerivedFromTemplatedBase(12321, "baz"))));
 
-  EXPECT_EQ("{'i':12321,'x':'baz'}", SingleQuoted(JSON(TemplateDerivedFromNonTemplatedBase<std::string>(12321, "baz"))));
+  EXPECT_EQ("{'i':12321,'x':'baz'}",
+            SingleQuoted(JSON(TemplateDerivedFromNonTemplatedBase<std::string>(12321, "baz"))));
 
   EXPECT_EQ("{'i':12321,'x':'baz','w':101}", SingleQuoted(JSON(NonEmptyDerivedFromTemplatedBase(12321, "baz", 101))));
 }
@@ -1614,9 +1617,7 @@ CURRENT_STRUCT_T(CurrentStructTUsingSubtype) {
   CURRENT_FIELD(xv, std::vector<vector_element_t>);
 };
 
-CURRENT_STRUCT_T(CurrentStructTUsingDerived) {
-  CURRENT_FIELD(x, CurrentStructTUsingSubtype<T>);
-};
+CURRENT_STRUCT_T(CurrentStructTUsingDerived) { CURRENT_FIELD(x, CurrentStructTUsingSubtype<T>); };
 
 // NOTE(dkorolev): I recall we had a `static_assert` that only `CURRENT_STRUCT`-s can be the bases
 //                 for `CURRENT_STRUCT_T`-s. This test may need to be revisited as we re-enable that check.
diff --git a/typesystem/struct.h b/typesystem/struct.h
index 14457a5d1..e2cc716d6 100644
--- a/typesystem/struct.h
+++ b/typesystem/struct.h
@@ -161,21 +161,21 @@ struct CurrentStructFieldsConsistency<T, 0u> {
   using s = CSI_##s<::crnt::r::DF>
 
 // Current structure implementation.
-#define CURRENT_STRUCT_HELPERS(s, super)                                           \
-  template <typename INSTANTIATION_TYPE>                                           \
-  struct CSI_##s;                                                                  \
-  using s = CSI_##s<::crnt::r::DF>;                                                \
-  struct CRH_##s final {                                                           \
-    constexpr static size_t CURRENT_FIELD_INDEX_BASE_IMPL = __COUNTER__;           \
-    constexpr static const char* CURRENT_STRUCT_NAME() { return #s; }              \
-    typedef CSI_##s<::crnt::r::FC> CURRENT_FIELD_COUNT_STRUCT;                     \
-    using FIELD_INDEX_BASE = ::crnt::r::FIELD_INDEX_BASE_IMPL<CRH_##s>;            \
-  };                                                                               \
-  inline CRH_##s CRHTypeExtractor(::crnt::r::TypeSelector<s>);                     \
-  struct CSSH_##s {                                                                \
-    using FIELD_INDEX_BASE = typename CRH_##s::FIELD_INDEX_BASE;                   \
-    using INTERNAL_SUPER = super;                                                  \
-    using template_inner_t_0 = void;                                               \
+#define CURRENT_STRUCT_HELPERS(s, super)                                 \
+  template <typename INSTANTIATION_TYPE>                                 \
+  struct CSI_##s;                                                        \
+  using s = CSI_##s<::crnt::r::DF>;                                      \
+  struct CRH_##s final {                                                 \
+    constexpr static size_t CURRENT_FIELD_INDEX_BASE_IMPL = __COUNTER__; \
+    constexpr static const char* CURRENT_STRUCT_NAME() { return #s; }    \
+    typedef CSI_##s<::crnt::r::FC> CURRENT_FIELD_COUNT_STRUCT;           \
+    using FIELD_INDEX_BASE = ::crnt::r::FIELD_INDEX_BASE_IMPL<CRH_##s>;  \
+  };                                                                     \
+  inline CRH_##s CRHTypeExtractor(::crnt::r::TypeSelector<s>);           \
+  struct CSSH_##s {                                                      \
+    using FIELD_INDEX_BASE = typename CRH_##s::FIELD_INDEX_BASE;         \
+    using INTERNAL_SUPER = super;                                        \
+    using template_inner_t_0 = void;                                     \
   }
 
 #define CURRENT_STRUCT_T_HELPERS(s, super)                                         \
@@ -207,7 +207,8 @@ struct CurrentStructFieldsConsistency<T, 0u> {
 #define CURRENT_STRUCT_NOT_DERIVED(s)               \
   CURRENT_STRUCT_HELPERS(s, ::crnt::CurrentStruct); \
   template <typename INSTANTIATION_TYPE>            \
-  struct CSI_##s : CSSH_##s, ::crnt::r::SUPER_IMPL<CRH_##s, INSTANTIATION_TYPE, ::crnt::CurrentStruct, std::false_type>
+  struct CSI_##s : CSSH_##s,                        \
+                   ::crnt::r::SUPER_IMPL<CRH_##s, INSTANTIATION_TYPE, ::crnt::CurrentStruct, std::false_type>
 
 #define CURRENT_STRUCT_T_NOT_DERIVED(s)                                    \
   CURRENT_STRUCT_T_HELPERS(s, ::crnt::CurrentStruct);                      \
@@ -335,10 +336,9 @@ struct CurrentStructFieldsConsistency<T, 0u> {
       class = std::enable_if_t<std::is_same_v<INSTANTIATION_TYPE_IMPL, ::current::reflection::DeclareFields>>>    \
   CSI_##s
 
-#define CURRENT_ASSIGN_OPER(s)                                                                                   \
-  template <typename INSTANTIATION_TYPE_IMPL = INSTANTIATION_TYPE,                                               \
-            class =                                                                                              \
-                std::enable_if_t<std::is_same_v<INSTANTIATION_TYPE_IMPL, ::current::reflection::DeclareFields>>> \
+#define CURRENT_ASSIGN_OPER(s)                                                                                       \
+  template <typename INSTANTIATION_TYPE_IMPL = INSTANTIATION_TYPE,                                                   \
+            class = std::enable_if_t<std::is_same_v<INSTANTIATION_TYPE_IMPL, ::current::reflection::DeclareFields>>> \
   CSI_##s& operator=
 
 #define CURRENT_DEFAULT_CONSTRUCTOR(s) CURRENT_CONSTRUCTOR(s)()
@@ -371,22 +371,19 @@ struct CurrentStructFieldsConsistency<T, 0u> {
   using CRNT_super_t = ::crnt::r::SUPER_IMPL<CRH_##s, INSTANTIATION_TYPE, CSSH_##s::INTERNAL_SUPER, std::false_type>; \
   using CRNT_super_t::CRNT_super_t
 
-#define CURRENT_USE_T_BASE_CONSTRUCTORS(s)                                                                   \
-  using CRNT_super_t =                                                                                       \
-                         ::crnt::r::SUPER_IMPL<CRTH<s>,                                                      \
-                                               INSTANTIATION_TYPE,                                           \
-                                               typename CURRENT_STRUCT_T_SUPER_HELPER_##s::INTERNAL_SUPER_T, \
-                                               std::true_type>;                                              \
+#define CURRENT_USE_T_BASE_CONSTRUCTORS(s)                                                                 \
+  using CRNT_super_t = ::crnt::r::SUPER_IMPL<CRTH<s>,                                                      \
+                                             INSTANTIATION_TYPE,                                           \
+                                             typename CURRENT_STRUCT_T_SUPER_HELPER_##s::INTERNAL_SUPER_T, \
+                                             std::true_type>;                                              \
   using CRNT_super_t::CRNT_super_t
 
-#define CURRENT_EXTRACT_T_SUBTYPE_IMPL(subtype, exported_subtype)     \
-  struct CRNT_##exported_subtype##_helper_t {                         \
-    using subtype = int;                                              \
-  };                                                                  \
-  using exported_subtype =                                            \
-    typename std::conditional_t<std::is_same_v<T, ::crnt::r::DummyT>, \
-                                CRNT_##exported_subtype##_helper_t,   \
-                                T>::subtype
+#define CURRENT_EXTRACT_T_SUBTYPE_IMPL(subtype, exported_subtype) \
+  struct CRNT_##exported_subtype##_helper_t {                     \
+    using subtype = int;                                          \
+  };                                                              \
+  using exported_subtype = typename std::                         \
+      conditional_t<std::is_same_v<T, ::crnt::r::DummyT>, CRNT_##exported_subtype##_helper_t, T>::subtype
 
 #define CETS_IMPL1(a) CURRENT_EXTRACT_T_SUBTYPE_IMPL(a, a)
 #define CETS_IMPL2(a, b) CURRENT_EXTRACT_T_SUBTYPE_IMPL(a, b)
@@ -416,7 +413,9 @@ constexpr auto HasPatchObjectImpl(int) -> decltype(sizeof(typename T::patch_obje
 }
 
 template <typename T>
-constexpr bool HasPatch() { return HasPatchObjectImpl<T>(0); }
+constexpr bool HasPatch() {
+  return HasPatchObjectImpl<T>(0);
+}
 
 // TODO(dkorolev): Find a better place for this code. Must be included from the top-level `current.h`.
 
@@ -442,7 +441,7 @@ using ::crnt::r::CurrentStructFieldsConsistency;
 using ::crnt::r::FieldType;
 using ::crnt::r::FieldTypeWrapper;
 
-}  // namespace current::reflection
+}  // namespace reflection
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_STRUCT_H
diff --git a/typesystem/test.cc b/typesystem/test.cc
index ee51d33cd..cdf3cc4c3 100644
--- a/typesystem/test.cc
+++ b/typesystem/test.cc
@@ -92,8 +92,8 @@ CURRENT_STRUCT_T(Templated) {
 CURRENT_STRUCT_T(TemplatedDerivedFromFoo, Foo) {
   CURRENT_FIELD(s, std::string);
   CURRENT_FIELD(t, T);
-  CURRENT_CONSTRUCTOR_T(TemplatedDerivedFromFoo)(const uint32_t x, const std::string& s, const T& t)
-      : SUPER(x * 1000001u), s(s), t(t) {}
+  CURRENT_CONSTRUCTOR_T(TemplatedDerivedFromFoo)
+  (const uint32_t x, const std::string& s, const T& t) : SUPER(x * 1000001u), s(s), t(t) {}
 };
 
 CURRENT_STRUCT(NonTemplateDerivedFromTemplatedDerivedFromFooString, TemplatedDerivedFromFoo<std::string>){
@@ -358,45 +358,44 @@ TEST(TypeSystemTest, ConstructingViaInitializerListIncludingSuper) {
     EXPECT_EQ(124124u, two.i);
   }
 
-  {
-    {
-      TemplatedDerivedFromFoo<uint32_t> test(42u, "foo", 1u);
-      EXPECT_EQ(42000042u, test.i);
-      EXPECT_EQ("foo", test.s);
-      EXPECT_EQ(1u, test.t);
-    }
-    {
-      TemplatedDerivedFromFoo<std::string> test(42u, "foo", "test");
-      EXPECT_EQ(42000042u, test.i);
-      EXPECT_EQ("foo", test.s);
-      EXPECT_EQ("test", test.t);
-    }
-  }
+  {{TemplatedDerivedFromFoo<uint32_t> test(42u, "foo", 1u);
+  EXPECT_EQ(42000042u, test.i);
+  EXPECT_EQ("foo", test.s);
+  EXPECT_EQ(1u, test.t);
+}
+{
+  TemplatedDerivedFromFoo<std::string> test(42u, "foo", "test");
+  EXPECT_EQ(42000042u, test.i);
+  EXPECT_EQ("foo", test.s);
+  EXPECT_EQ("test", test.t);
+}
+}
 
+{
+  NonTemplateDerivedFromTemplatedDerivedFromFooString test(1u, "s", "t");
+  EXPECT_EQ(1000001u, test.i);
+  EXPECT_EQ("s", test.s);
+  EXPECT_EQ("t", test.t);
+}
+
+#ifdef CURRENT_STRUCTS_SUPPORT_DERIVING_FROM_TEMPLATED_STRUCTS
+{
   {
-    NonTemplateDerivedFromTemplatedDerivedFromFooString test(1u, "s", "t");
+    TemplateDerivedFromTemplatedDerivedFromFooString<std::string> test(1u, "s", "t");
     EXPECT_EQ(1000001u, test.i);
     EXPECT_EQ("s", test.s);
     EXPECT_EQ("t", test.t);
   }
-
-#ifdef CURRENT_STRUCTS_SUPPORT_DERIVING_FROM_TEMPLATED_STRUCTS
   {
-    {
-      TemplateDerivedFromTemplatedDerivedFromFooString<std::string> test(1u, "s", "t");
-      EXPECT_EQ(1000001u, test.i);
-      EXPECT_EQ("s", test.s);
-      EXPECT_EQ("t", test.t);
-    }
-    {
-      TemplateDerivedFromTemplatedDerivedFromFooString<bool> test(1u, "s", true);
-      EXPECT_EQ(1000001u, test.i);
-      EXPECT_EQ("s", test.s);
-      EXPECT_TRUE(test.t);
-    }
+    TemplateDerivedFromTemplatedDerivedFromFooString<bool> test(1u, "s", true);
+    EXPECT_EQ(1000001u, test.i);
+    EXPECT_EQ("s", test.s);
+    EXPECT_TRUE(test.t);
   }
+}
 #endif  // CURRENT_STRUCTS_SUPPORT_DERIVING_FROM_TEMPLATED_STRUCTS
-};
+}
+;
 
 TEST(TypeSystemTest, ConstructingTemplatedStructs) {
   using namespace struct_definition_test;
@@ -1524,21 +1523,15 @@ TEST(TypeSystemTest, InplaceVariantConstruction) {
 
 namespace struct_definition_test {
 
-CURRENT_STRUCT(DoesNotSupportPatch) {
-  CURRENT_FIELD(x, int32_t, 0);
-};
+CURRENT_STRUCT(DoesNotSupportPatch) { CURRENT_FIELD(x, int32_t, 0); };
 
-CURRENT_STRUCT(PatchToY) {
-  CURRENT_FIELD(dy, int32_t, 0);
-};
+CURRENT_STRUCT(PatchToY) { CURRENT_FIELD(dy, int32_t, 0); };
 
 CURRENT_STRUCT(DoesSupportPatch) {
   CURRENT_FIELD(y, int32_t, 0);
 
   using patch_object_t = PatchToY;
-  void PatchWith(const patch_object_t& patch) {
-    y += patch.dy;
-  }
+  void PatchWith(const patch_object_t& patch) { y += patch.dy; }
 };
 
 }  // namespace struct_definition_test
@@ -1568,11 +1561,11 @@ TEST(TypeSystemTest, Patch) {
 namespace struct_definition_test {
 namespace inner_namespace_fails_in_april_2021 {
 namespace when_the_using_declaration_is_used {
-CURRENT_STRUCT(CurrentStructWithinNamespace) {};
-}  // namespace struct_definition_test::inner_namespace_fails_in_april_2021::when_the_using_declaration_is_used
+CURRENT_STRUCT(CurrentStructWithinNamespace){};
+}  // namespace when_the_using_declaration_is_used
 using namespace when_the_using_declaration_is_used;
-CURRENT_STRUCT(CurrentStructOutsideNamespace) {};
-}  // namespace struct_definition_test::inner_namespace_fails_in_april_2021
+CURRENT_STRUCT(CurrentStructOutsideNamespace){};
+}  // namespace inner_namespace_fails_in_april_2021
 }  // namespace struct_definition_test
 
 TEST(TypeSystemTest, UsingNamespace) {
diff --git a/typesystem/typename.h b/typesystem/typename.h
index 0f3822596..9405ede86 100644
--- a/typesystem/typename.h
+++ b/typesystem/typename.h
@@ -85,9 +85,7 @@ struct CurrentTypeNameCaller {
 
 template <NameFormat NF>
 struct CurrentTypeNameCaller<NF, CurrentSuper> {
-  static const char* CallGetCurrentTypeName() {
-    return "CurrentSuper";
-  }
+  static const char* CallGetCurrentTypeName() { return "CurrentSuper"; }
 };
 
 template <NameFormat NF, typename T>
@@ -336,7 +334,7 @@ struct CurrentTypeNameImpl<NameFormat::AsIdentifier, std::tuple<TS...>, false, f
   }
 };
 
-}  // namespace current::reflection::impl
+}  // namespace impl
 
 template <typename T, NameFormat NF = NameFormat::FullCPP>
 const char* CurrentTypeName() {
@@ -371,9 +369,9 @@ struct JoinTypeNames<NF, TypeListImpl<T, TS...>> {
   }
 };
 
-}  // namespace current::reflection::impl
+}  // namespace impl
 
-}  // namespace current::reflection
+}  // namespace reflection
 }  // namespace current
 
 #endif  // CURRENT_TYPE_SYSTEM_TYPENAME_H
diff --git a/typesystem/types.h b/typesystem/types.h
index f7c4e9494..dc63bf04f 100644
--- a/typesystem/types.h
+++ b/typesystem/types.h
@@ -148,14 +148,14 @@ struct Has_CURRENT_EXPORTED_STRUCT_NAME {
   static constexpr bool value = Has_CURRENT_EXPORTED_STRUCT_NAME_Impl<ENTRY>(0);
 };
 
-}  // namespace crnt::sfinae
+}  // namespace sfinae
 }  // namespace crnt
 
 namespace current {
 
+using ::crnt::CurrentStruct;
 using ::crnt::CurrentSuper;
 using ::crnt::CurrentSuperDeleter;
-using ::crnt::CurrentStruct;
 using ::crnt::CurrentVariant;
 
 namespace reflection {
@@ -299,14 +299,14 @@ struct VisitAllFields {
   static void WithObjectImpl(TT&&, const F&, crnt::vi::is<>) {}
 };
 
-}  // namespace current::reflection
+}  // namespace reflection
 
 namespace sfinae {
+using ::crnt::sfinae::Has_CURRENT_EXPORTED_STRUCT_NAME;
+using ::crnt::sfinae::HasCheckIntegrityImplMethod;
 using ::crnt::sfinae::HasExistsImplMethod;
 using ::crnt::sfinae::ValueImplMethodTest;
-using ::crnt::sfinae::HasCheckIntegrityImplMethod;
-using ::crnt::sfinae::Has_CURRENT_EXPORTED_STRUCT_NAME;
-}  // namespace current::sfinae
+}  // namespace sfinae
 
 }  // namespace current
 
diff --git a/typesystem/variant.h b/typesystem/variant.h
index 6098e6c02..2611f1a41 100644
--- a/typesystem/variant.h
+++ b/typesystem/variant.h
@@ -114,7 +114,7 @@ struct RuntimeTypeListHelpers<TypeListImpl<TS...>> {
 };
 #endif  // VARIANT_CHECKS_AT_RUNTIME_INSTEAD_OF_COMPILE_TIME
 
-}  // namespace current::variant
+}  // namespace variant
 
 struct IHasUncheckedMoveFromUniquePtr : CurrentVariant {
   virtual void UncheckedMoveFromUniquePtr(std::unique_ptr<current::variant::object_base_t>) = 0;
diff --git a/utils/json_schema/infer.h b/utils/json_schema/infer.h
index 31945180c..4ddfe2947 100644
--- a/utils/json_schema/infer.h
+++ b/utils/json_schema/infer.h
@@ -743,24 +743,23 @@ template <typename PATH = DoNotTrackPath>
 inline Schema SchemaFromOneJSONPerLineFile(const std::string& file_name, const PATH& path = PATH()) {
   bool first = true;
   impl::Schema schema;
-  FileSystem::ReadFileByLines(file_name,
-                              [&path, &first, &schema](std::string&& json) {
-                                rapidjson::Document document;
-                                // `&json[0]` to pass a mutable string.
-                                if (document.Parse<0>(&json[0]).HasParseError()) {
-                                  CURRENT_THROW(InferSchemaParseJSONException());
-                                }
-                                if (first) {
-                                  schema = impl::RecursivelyInferSchema(document, path);
-                                  first = false;
-                                } else {
-                                  schema = CallReduce(schema, impl::RecursivelyInferSchema(document, path));
-                                }
-                              });
+  FileSystem::ReadFileByLines(file_name, [&path, &first, &schema](std::string&& json) {
+    rapidjson::Document document;
+    // `&json[0]` to pass a mutable string.
+    if (document.Parse<0>(&json[0]).HasParseError()) {
+      CURRENT_THROW(InferSchemaParseJSONException());
+    }
+    if (first) {
+      schema = impl::RecursivelyInferSchema(document, path);
+      first = false;
+    } else {
+      schema = CallReduce(schema, impl::RecursivelyInferSchema(document, path));
+    }
+  });
   return schema;
 }
 
-}  // namespace impl
+}  // namespace current
 
 template <typename PATH = DoNotTrackPath>
 inline std::string DescribeSchema(const std::string& file_name,
diff --git a/utils/json_schema/test.cc b/utils/json_schema/test.cc
index 1f23eade0..1adc3c214 100644
--- a/utils/json_schema/test.cc
+++ b/utils/json_schema/test.cc
@@ -35,16 +35,15 @@ DEFINE_bool(regenerate_golden_inferred_schemas, false, "Set to 'true' to re-gene
 static std::vector<std::string> ListGoldenFilesWithExtension(const std::string& dir, const std::string& ext) {
   std::vector<std::string> names;
   const std::string suffix = '.' + ext;
-  current::FileSystem::ScanDir(dir,
-                               [&](const current::FileSystem::ScanDirItemInfo& item_info) {
-                                 const std::string& filename = item_info.basename;
-                                 if (filename.length() >= suffix.length()) {
-                                   const std::string prefix = filename.substr(0, filename.length() - suffix.length());
-                                   if (prefix + suffix == filename) {
-                                     names.push_back(prefix);
-                                   }
-                                 }
-                               });
+  current::FileSystem::ScanDir(dir, [&](const current::FileSystem::ScanDirItemInfo& item_info) {
+    const std::string& filename = item_info.basename;
+    if (filename.length() >= suffix.length()) {
+      const std::string prefix = filename.substr(0, filename.length() - suffix.length());
+      if (prefix + suffix == filename) {
+        names.push_back(prefix);
+      }
+    }
+  });
   return names;
 }
 
@@ -59,7 +58,8 @@ TEST(InferJSONSchema, MatchAgainstGoldenFiles) {
       EXPECT_EQ(current::utils::impl::SchemaFromOneJSONPerLineFile(file_name),
                 (ParseJSON<current::utils::impl::Schema, JSONFormat::Minimalistic>(
                     current::FileSystem::ReadFileAsString(filename_prefix + ".raw"))))
-          << "Expected:\n" << current::utils::impl::SchemaFromOneJSONPerLineFile(file_name) << "\nActual:\n"
+          << "Expected:\n"
+          << current::utils::impl::SchemaFromOneJSONPerLineFile(file_name) << "\nActual:\n"
           << JSON<JSONFormat::Minimalistic>(current::utils::impl::SchemaFromOneJSONPerLineFile(file_name))
           << "\nWhile running test case `" << test << "`.";
       EXPECT_EQ(current::FileSystem::ReadFileAsString(filename_prefix + ".tsv"),
@@ -83,9 +83,9 @@ TEST(InferJSONSchema, MatchAgainstGoldenFiles) {
 // RapidJSON usage snippets framed as unit tests. Let's keep them in this `test.cc`. -- D.K.
 TEST(RapidJSON, Smoke) {
   using rapidjson::Document;
+  using rapidjson::StringBuffer;
   using rapidjson::Value;
   using rapidjson::Writer;
-  using rapidjson::StringBuffer;
 
   std::string json;
 
@@ -123,9 +123,9 @@ TEST(RapidJSON, Smoke) {
 
 TEST(RapidJSON, Array) {
   using rapidjson::Document;
+  using rapidjson::StringBuffer;
   using rapidjson::Value;
   using rapidjson::Writer;
-  using rapidjson::StringBuffer;
 
   std::string json;
 
@@ -153,9 +153,9 @@ TEST(RapidJSON, Array) {
 
 TEST(RapidJSON, NullInString) {
   using rapidjson::Document;
+  using rapidjson::StringBuffer;
   using rapidjson::Value;
   using rapidjson::Writer;
-  using rapidjson::StringBuffer;
 
   std::string json;
 
diff --git a/utils/nginx/config.h b/utils/nginx/config.h
index 3298e7bea..608bd7a3b 100644
--- a/utils/nginx/config.h
+++ b/utils/nginx/config.h
@@ -45,8 +45,8 @@ CURRENT_STRUCT(SimpleDirective) {
   CURRENT_FIELD(parameters, std::string);
   CURRENT_FIELD_DESCRIPTION(parameters, "Nginx simple directive parameters.");
   CURRENT_DEFAULT_CONSTRUCTOR(SimpleDirective){};
-  CURRENT_CONSTRUCTOR(SimpleDirective)(const std::string& name, const std::string& parameters)
-      : name(name), parameters(parameters) {}
+  CURRENT_CONSTRUCTOR(SimpleDirective)
+  (const std::string& name, const std::string& parameters) : name(name), parameters(parameters) {}
 };
 
 CURRENT_FORWARD_DECLARE_STRUCT(BlockDirective);
@@ -91,8 +91,7 @@ CURRENT_STRUCT(LocationDirective, BlockDirective) {
 };
 // clang-format on
 
-inline LocationDirective ProxyPassLocationDirective(const std::string& location,
-                                                    const std::string& proxy_pass_to) {
+inline LocationDirective ProxyPassLocationDirective(const std::string& location, const std::string& proxy_pass_to) {
   LocationDirective result(location);
   result.Add(SimpleDirective("proxy_pass", proxy_pass_to))
       .Add(SimpleDirective("proxy_set_header", "X-Real-IP $remote_addr"))
diff --git a/utils/nginx/exceptions.h b/utils/nginx/exceptions.h
index d930b6306..7ee970e4e 100644
--- a/utils/nginx/exceptions.h
+++ b/utils/nginx/exceptions.h
@@ -57,7 +57,7 @@ struct NginxReloadConfigFailedException : NginxManagerException {
   using NginxManagerException::NginxManagerException;
 };
 
-}  // namespace current::nginx
+}  // namespace nginx
 }  // namespace current
 
 #endif  // CURRENT_UTILS_NGINX_EXCEPTIONS_H
diff --git a/utils/nginx/nginx.h b/utils/nginx/nginx.h
index b6b7b069f..fea41cf16 100644
--- a/utils/nginx/nginx.h
+++ b/utils/nginx/nginx.h
@@ -86,7 +86,7 @@ class NginxInvokerImpl final {
   mutable std::mutex mutex_;
 };
 
-}  // namespace current::nginx::impl
+}  // namespace impl
 
 inline impl::NginxInvokerImpl& NginxInvoker() { return Singleton<impl::NginxInvokerImpl>(); }
 
@@ -94,10 +94,10 @@ CURRENT_STRUCT(NginxManagerMagicNumbers) {
   CURRENT_FIELD(endpoint_number, std::string);
   CURRENT_FIELD(response_number, std::string);
   CURRENT_DEFAULT_CONSTRUCTOR(NginxManagerMagicNumbers)
-      : endpoint_number(SHA256("Random location " +
-                               ToString(random::CSRandomUInt64(0u, std::numeric_limits<uint64_t>::max())))),
-        response_number(SHA256("Random response " +
-                               ToString(random::CSRandomUInt64(0u, std::numeric_limits<uint64_t>::max())))) {}
+      : endpoint_number(
+            SHA256("Random location " + ToString(random::CSRandomUInt64(0u, std::numeric_limits<uint64_t>::max())))),
+        response_number(
+            SHA256("Random response " + ToString(random::CSRandomUInt64(0u, std::numeric_limits<uint64_t>::max())))) {}
 };
 
 class NginxManager {
@@ -154,8 +154,7 @@ class NginxManager {
       }
     }
     if (!updated) {
-      std::cerr << "Nginx hasn't properly reloaded config file '" << config_file_ << "'\nAborting."
-                << std::endl;
+      std::cerr << "Nginx hasn't properly reloaded config file '" << config_file_ << "'\nAborting." << std::endl;
       std::exit(-1);
     }
   }
@@ -171,7 +170,7 @@ class NginxManager {
   mutable std::mutex mutex_;
 };
 
-}  // namespace current::nginx
+}  // namespace nginx
 }  // namespace current
 
 #endif  // CURRENT_UTILS_NGINX_NGINX_H
diff --git a/utils/nginx/test.cc b/utils/nginx/test.cc
index f82da36ec..f23a0df54 100644
--- a/utils/nginx/test.cc
+++ b/utils/nginx/test.cc
@@ -68,8 +68,7 @@ TEST(Nginx, NginxInvokerCheckGoldenConfig) {
   auto& nginx = NginxInvoker();
   // Run test only if Nginx is available.
   if (nginx.IsNginxAvailable()) {
-    const std::string config_relative_path =
-        FileSystem::JoinPath(FileSystem::JoinPath("..", "golden"), "full.conf");
+    const std::string config_relative_path = FileSystem::JoinPath(FileSystem::JoinPath("..", "golden"), "full.conf");
     const std::string full_config_path = FileSystem::JoinPath(CurrentBinaryFullPath(), config_relative_path);
     EXPECT_TRUE(nginx.IsFullConfigValid(full_config_path));
   } else {
diff --git a/utils/operational_transformation/ot.h b/utils/operational_transformation/ot.h
index f969958a2..b254118c0 100644
--- a/utils/operational_transformation/ot.h
+++ b/utils/operational_transformation/ot.h
@@ -134,8 +134,8 @@ inline std::string OT(const std::string& json) {
   return OT(json, PassthroughProcessor());
 }
 
-}  // namespace current::utils::ot
-}  // namespace current::utils
+}  // namespace ot
+}  // namespace utils
 }  // namespace current
 
 #endif  // UTILS_OPERATIONAL_TRANSFORMATION_H