koffi 2.14.0 → 2.15.0

package/{src/core → lib/native}/base/base.hh

@@ -1,23 +1,5 @@
-// Copyright (C) 2025  Niels Martignène <niels.martignene@protonmail.com>
-
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the “Software”), to deal in
-// the Software without restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
-// Software, and to permit persons to whom the Software is furnished to do so,
-// subject to the following conditions:
-
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-
-// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2025 Niels Martignène <niels.martignene@protonmail.com>
 
 #pragma once
 
@@ -75,38 +57,40 @@
 struct sigaction;
 struct BrotliEncoderStateStruct;
 
-namespace RG {
+namespace K {
 
 // ------------------------------------------------------------------------
 // Config
 // ------------------------------------------------------------------------
 
 #if !defined(NDEBUG)
-    #define RG_DEBUG
+    #define K_DEBUG
 #endif
 
-#define RG_DEFAULT_ALLOCATOR MallocAllocator
-#define RG_BLOCK_ALLOCATOR_DEFAULT_SIZE Kibibytes(4)
+#define K_DEFAULT_ALLOCATOR MallocAllocator
+#define K_BLOCK_ALLOCATOR_DEFAULT_SIZE Kibibytes(4)
 
-#define RG_HEAPARRAY_BASE_CAPACITY 8
-#define RG_HEAPARRAY_GROWTH_FACTOR 2.0
+#define K_HEAPARRAY_BASE_CAPACITY 8
+#define K_HEAPARRAY_GROWTH_FACTOR 2.0
 
 // Must be a power-of-two
-#define RG_HASHTABLE_BASE_CAPACITY 8
-#define RG_HASHTABLE_MAX_LOAD_FACTOR 0.5
+#define K_HASHTABLE_BASE_CAPACITY 8
+#define K_HASHTABLE_MAX_LOAD_FACTOR 0.5
 
-#define RG_FMT_STRING_BASE_CAPACITY 256
-#define RG_FMT_STRING_PRINT_BUFFER_SIZE 1024
+#define K_FMT_STRING_BASE_CAPACITY 256
+#define K_FMT_STRING_PRINT_BUFFER_SIZE 1024
 
-#define RG_LINE_READER_STEP_SIZE 65536
+#define K_LINE_READER_STEP_SIZE 65536
 
-#define RG_ASYNC_MAX_THREADS 2048
-#define RG_ASYNC_MAX_IDLE_TIME 10000
-#define RG_ASYNC_MAX_PENDING_TASKS 2048
+#define K_ASYNC_MAX_THREADS 2048
+#define K_ASYNC_MAX_IDLE_TIME 10000
+#define K_ASYNC_MAX_PENDING_TASKS 2048
 
-#define RG_PROGRESS_MAX_NODES 400
-#define RG_PROGRESS_USED_NODES 100
-#define RG_PROGRESS_TEXT_SIZE 64
+#define K_PROGRESS_MAX_NODES 400
+#define K_PROGRESS_USED_NODES 100
+#define K_PROGRESS_TEXT_SIZE 64
+
+#define K_COMPLETE_PATH_LIMIT 256
 
 // ------------------------------------------------------------------------
 // Utility
@@ -125,13 +109,13 @@ extern StreamWriter *const StdErr;
 
 #if defined(__x86_64__) || defined(_M_X64) || defined(__aarch64__) || defined(_M_ARM64) || __riscv_xlen == 64 || defined(__loongarch64)
     typedef int64_t Size;
-    #define RG_SIZE_MAX INT64_MAX
+    #define K_SIZE_MAX INT64_MAX
 #elif defined(_WIN32) || defined(__APPLE__) || defined(__unix__)
     typedef int32_t Size;
-    #define RG_SIZE_MAX INT32_MAX
+    #define K_SIZE_MAX INT32_MAX
 #elif defined(__thumb__) || defined(__arm__) || defined(__wasm32__)
     typedef int32_t Size;
-    #define RG_SIZE_MAX INT32_MAX
+    #define K_SIZE_MAX INT32_MAX
 #else
     #error Machine architecture not supported
 #endif
@@ -139,7 +123,7 @@ extern StreamWriter *const StdErr;
 #if defined(_MSC_VER) || __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
     // Sane platform
 #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-    #define RG_BIG_ENDIAN
+    #define K_BIG_ENDIAN
 #else
     #error This code base is not designed to support platforms with crazy endianness
 #endif
@@ -152,16 +136,16 @@ extern StreamWriter *const StdErr;
 #endif
 static_assert(sizeof(double) == 8, "This code base is not designed to support single-precision double floats");
 
-#define RG_STRINGIFY_(a) #a
-#define RG_STRINGIFY(a) RG_STRINGIFY_(a)
-#define RG_CONCAT_(a, b) a ## b
-#define RG_CONCAT(a, b) RG_CONCAT_(a, b)
-#define RG_UNIQUE_NAME(prefix) RG_CONCAT(prefix, __LINE__)
-#define RG_FORCE_EXPAND(x) x
-#define RG_IGNORE (void)!
+#define K_STRINGIFY_(a) #a
+#define K_STRINGIFY(a) K_STRINGIFY_(a)
+#define K_CONCAT_(a, b) a ## b
+#define K_CONCAT(a, b) K_CONCAT_(a, b)
+#define K_UNIQUE_NAME(prefix) K_CONCAT(prefix, __LINE__)
+#define K_FORCE_EXPAND(x) x
+#define K_IGNORE (void)!
 
 #if defined(__GNUC__) || defined(__clang__)
-    #define RG_PUSH_NO_WARNINGS \
+    #define K_PUSH_NO_WARNINGS \
         _Pragma("GCC diagnostic push") \
         _Pragma("GCC diagnostic ignored \"-Wall\"") \
         _Pragma("GCC diagnostic ignored \"-Wextra\"") \
@@ -173,7 +157,7 @@ static_assert(sizeof(double) == 8, "This code base is not designed to support si
         _Pragma("GCC diagnostic ignored \"-Wunused-parameter\"") \
         _Pragma("GCC diagnostic ignored \"-Wzero-as-null-pointer-constant\"") \
         _Pragma("GCC diagnostic ignored \"-Winvalid-offsetof\"")
-    #define RG_POP_NO_WARNINGS \
+    #define K_POP_NO_WARNINGS \
         _Pragma("GCC diagnostic pop")
 
     #if !defined(SCNd8)
@@ -186,8 +170,8 @@ static_assert(sizeof(double) == 8, "This code base is not designed to support si
         #define SCNu8 "hhu"
     #endif
 #elif defined(_MSC_VER)
-    #define RG_PUSH_NO_WARNINGS __pragma(warning(push, 0))
-    #define RG_POP_NO_WARNINGS __pragma(warning(pop))
+    #define K_PUSH_NO_WARNINGS __pragma(warning(push, 0))
+    #define K_POP_NO_WARNINGS __pragma(warning(pop))
 
     #define __restrict__ __restrict
 #else
@@ -209,73 +193,73 @@ static_assert(sizeof(double) == 8, "This code base is not designed to support si
 extern "C" void AssertMessage(const char *filename, int line, const char *cond);
 
 #if defined(_MSC_VER)
-    #define RG_DEBUG_BREAK() __debugbreak()
+    #define K_DEBUG_BREAK() __debugbreak()
 #elif defined(__clang__)
-    #define RG_DEBUG_BREAK() __builtin_debugtrap()
+    #define K_DEBUG_BREAK() __builtin_debugtrap()
 #elif defined(__i386__) || defined(__x86_64__)
-    #define RG_DEBUG_BREAK() __asm__ __volatile__("int $0x03")
+    #define K_DEBUG_BREAK() __asm__ __volatile__("int $0x03")
 #elif defined(__thumb__)
-    #define RG_DEBUG_BREAK() __asm__ __volatile__(".inst 0xde01")
+    #define K_DEBUG_BREAK() __asm__ __volatile__(".inst 0xde01")
 #elif defined(__aarch64__)
-    #define RG_DEBUG_BREAK() __asm__ __volatile__(".inst 0xd4200000")
+    #define K_DEBUG_BREAK() __asm__ __volatile__(".inst 0xd4200000")
 #elif defined(__arm__)
-    #define RG_DEBUG_BREAK() __asm__ __volatile__(".inst 0xe7f001f0")
+    #define K_DEBUG_BREAK() __asm__ __volatile__(".inst 0xe7f001f0")
 #elif defined(__riscv)
-    #define RG_DEBUG_BREAK() __asm__ __volatile__("ebreak")
+    #define K_DEBUG_BREAK() __asm__ __volatile__("ebreak")
 #elif defined(__loongarch64)
-    #define RG_DEBUG_BREAK() __asm__ __volatile__("break 1")
+    #define K_DEBUG_BREAK() __asm__ __volatile__("break 1")
 #endif
 
 #if defined(_MSC_VER) || __EXCEPTIONS
-    #define RG_BAD_ALLOC() \
+    #define K_BAD_ALLOC() \
         do { \
             throw std::bad_alloc(); \
         } while (false)
 #else
-    #define RG_BAD_ALLOC() \
+    #define K_BAD_ALLOC() \
         do { \
             PrintLn(StdErr, "Memory allocation failed"); \
             abort(); \
         } while (false);
 #endif
 
-#define RG_CRITICAL(Cond, ...) \
+#define K_CRITICAL(Cond, ...) \
     do { \
         if (!(Cond)) [[unlikely]] { \
             PrintLn(StdErr, __VA_ARGS__); \
             abort(); \
         } \
     } while (false)
-#if defined(RG_DEBUG)
-    #define RG_ASSERT(Cond) \
+#if defined(K_DEBUG)
+    #define K_ASSERT(Cond) \
         do { \
             if (!(Cond)) [[unlikely]] { \
-                RG::AssertMessage(__FILE__, __LINE__, RG_STRINGIFY(Cond)); \
-                RG_DEBUG_BREAK(); \
+                K::AssertMessage(__FILE__, __LINE__, K_STRINGIFY(Cond)); \
+                K_DEBUG_BREAK(); \
                 abort(); \
             } \
         } while (false)
 #else
-    #define RG_ASSERT(Cond) \
+    #define K_ASSERT(Cond) \
         do { \
             (void)sizeof(Cond); \
         } while (false)
 #endif
 
-#if defined(RG_DEBUG)
-    #define RG_UNREACHABLE() \
+#if defined(K_DEBUG)
+    #define K_UNREACHABLE() \
         do { \
-            RG::AssertMessage(__FILE__, __LINE__, "Reached code marked as UNREACHABLE"); \
-            RG_DEBUG_BREAK(); \
+            K::AssertMessage(__FILE__, __LINE__, "Reached code marked as UNREACHABLE"); \
+            K_DEBUG_BREAK(); \
             abort(); \
         } while (false)
 #elif defined(__GNUC__) || defined(__clang__)
-    #define RG_UNREACHABLE() __builtin_unreachable()
+    #define K_UNREACHABLE() __builtin_unreachable()
 #else
-    #define RG_UNREACHABLE() __assume(0)
+    #define K_UNREACHABLE() __assume(0)
 #endif
 
-#define RG_DELETE_COPY(Cls) \
+#define K_DELETE_COPY(Cls) \
     Cls(const Cls&) = delete; \
     Cls &operator=(const Cls&) = delete;
 
@@ -289,11 +273,11 @@ constexpr Size Kibibytes(Size len) { return len * 1024; }
 constexpr Size Megabytes(Size len) { return len * 1000 * 1000; }
 constexpr Size Kilobytes(Size len) { return len * 1000; }
 
-#define RG_SIZE(Type) ((RG::Size)sizeof(Type))
+#define K_SIZE(Type) ((K::Size)sizeof(Type))
 template <typename T, unsigned N>
 char (&ComputeArraySize(T const (&)[N]))[N];
-#define RG_BITS(Type) (8 * RG_SIZE(Type))
-#define RG_LEN(Array) RG_SIZE(RG::ComputeArraySize(Array))
+#define K_BITS(Type) (8 * K_SIZE(Type))
+#define K_LEN(Array) K_SIZE(K::ComputeArraySize(Array))
 
 static constexpr inline uint16_t ReverseBytes(uint16_t u)
 {
@@ -328,7 +312,7 @@ static constexpr inline int32_t ReverseBytes(int32_t i)
 static constexpr inline int64_t ReverseBytes(int64_t i)
     { return (int64_t)ReverseBytes((uint64_t)i); }
 
-#if defined(RG_BIG_ENDIAN)
+#if defined(K_BIG_ENDIAN)
 template <typename T>
 constexpr T LittleEndian(T v) { return ReverseBytes(v); }
 template <typename T>
@@ -478,9 +462,9 @@ constexpr T BigEndian(T v) { return ReverseBytes(v); }
 #endif
 
 #if __cplusplus >= 202002L && (defined(_MSC_VER) || defined(__clang__) || __GNUC__ >= 11)
-    #define RG_CONSTINIT constinit
+    #define K_CONSTINIT constinit
 #else
-    #define RG_CONSTINIT const
+    #define K_CONSTINIT const
 #endif
 
 static inline Size AlignLen(Size len, Size align)
@@ -507,7 +491,7 @@ static inline T *AlignDown(T *ptr, Size align)
 // even if length is 0. This is dumb, work around this.
 static inline void *MemCpy(void *__restrict__ dest, const void *__restrict__ src, Size len)
 {
-    RG_ASSERT(len >= 0);
+    K_ASSERT(len >= 0);
 
 #if defined(__clang__)
     // LLVM guarantees sane behavior
@@ -521,7 +505,7 @@ static inline void *MemCpy(void *__restrict__ dest, const void *__restrict__ src
 }
 static inline void *MemMove(void *dest, const void *src, Size len)
 {
-    RG_ASSERT(len >= 0);
+    K_ASSERT(len >= 0);
 
 #if defined(__clang__)
     // LLVM guarantees sane behavior
@@ -535,7 +519,7 @@ static inline void *MemMove(void *dest, const void *src, Size len)
 }
 static inline void *MemSet(void *dest, int c, Size len)
 {
-    RG_ASSERT(len >= 0);
+    K_ASSERT(len >= 0);
 
 #if defined(__clang__)
     // LLVM guarantees sane behavior
@@ -556,8 +540,8 @@ void *MemMem(const void *src, Size src_len, const void *needle, Size needle_len)
 
 static inline void *MemMem(const void *src, Size src_len, const void *needle, Size needle_len)
 {
-    RG_ASSERT(src_len >= 0);
-    RG_ASSERT(needle_len > 0);
+    K_ASSERT(src_len >= 0);
+    K_ASSERT(needle_len > 0);
 
     void *ptr = memmem(src, (size_t)src_len, needle, (size_t)needle_len);
     return ptr;
@@ -565,6 +549,9 @@ static inline void *MemMem(const void *src, Size src_len, const void *needle, Si
 
 #endif
 
+// Implemented for translations, but we need it before we get to this part
+const char *T(const char *key);
+
 template <typename T, typename = typename std::enable_if<std::is_enum<T>::value, T>>
 typename std::underlying_type<T>::type MaskEnum(T value)
 {
@@ -574,7 +561,7 @@ typename std::underlying_type<T>::type MaskEnum(T value)
 
 template <typename Fun>
 class DeferGuard {
-    RG_DELETE_COPY(DeferGuard)
+    K_DELETE_COPY(DeferGuard)
 
     Fun f;
     bool enabled;
@@ -610,14 +597,35 @@ DeferGuard<Fun> operator+(DeferGuardHelper, Fun &&f)
 // Write 'DEFER { code };' to do something at the end of the current scope, you
 // can use DEFER_N(Name) if you need to disable the guard for some reason, and
 // DEFER_NC(Name, Captures) if you need to capture values.
-#define RG_DEFER \
-    auto RG_UNIQUE_NAME(defer) = RG::DeferGuardHelper() + [&]()
-#define RG_DEFER_N(Name) \
-    auto Name = RG::DeferGuardHelper() + [&]()
-#define RG_DEFER_C(...) \
-    auto RG_UNIQUE_NAME(defer) = RG::DeferGuardHelper() + [&, __VA_ARGS__]()
-#define RG_DEFER_NC(Name, ...) \
-    auto Name = RG::DeferGuardHelper() + [&, __VA_ARGS__]()
+#define K_DEFER \
+    auto K_UNIQUE_NAME(defer) = K::DeferGuardHelper() + [&]()
+#define K_DEFER_N(Name) \
+    auto Name = K::DeferGuardHelper() + [&]()
+#define K_DEFER_C(...) \
+    auto K_UNIQUE_NAME(defer) = K::DeferGuardHelper() + [&, __VA_ARGS__]()
+#define K_DEFER_NC(Name, ...) \
+    auto Name = K::DeferGuardHelper() + [&, __VA_ARGS__]()
+
+template <typename T>
+class NoDestroy {
+    K_DELETE_COPY(NoDestroy);
+
+    alignas(T) uint8_t data[K_SIZE(T)];
+
+public:
+    template <class... Args>
+    NoDestroy(Args&&... args) { new (data) T(std::forward<Args>(args)...); }
+
+    ~NoDestroy() = default;
+
+    const T *Get() const { return (const T *)(data); }
+    T *Get() { return (T*)data; }
+
+    const T &operator*() const { return *Get(); }
+    T& operator*() { return *Get(); }
+    const T *operator->() const { return Get(); }
+    T *operator->() { return Get(); }
+};
 
 // Heavily inspired from FunctionRef in LLVM
 template<typename Fn> class FunctionRef;
@@ -648,24 +656,6 @@ public:
     bool IsValid() const { return callback; }
 };
 
-#define RG_INIT_(ClassName) \
-    class ClassName { \
-    public: \
-        ClassName(); \
-    }; \
-    static ClassName RG_UNIQUE_NAME(init); \
-    ClassName::ClassName()
-#define RG_INIT(Name) RG_INIT_(RG_CONCAT(RG_UNIQUE_NAME(InitHelper), Name))
-
-#define RG_EXIT_(ClassName) \
-    class ClassName { \
-    public: \
-        ~ClassName(); \
-    }; \
-    static ClassName RG_UNIQUE_NAME(exit); \
-    ClassName::~ClassName()
-#define RG_EXIT(Name) RG_EXIT_(RG_CONCAT(RG_UNIQUE_NAME(ExitHelper), Name))
-
 template <typename T>
 T MultiCmp()
 {
@@ -730,19 +720,19 @@ public:
 
         Size operator*() const
         {
-            RG_ASSERT(offset <= RG_LEN(bitset->data));
+            K_ASSERT(offset <= K_LEN(bitset->data));
 
-            if (offset == RG_LEN(bitset->data))
+            if (offset == K_LEN(bitset->data))
                 return -1;
-            return offset * RG_SIZE(size_t) * 8 + ctz;
+            return offset * K_SIZE(size_t) * 8 + ctz;
         }
 
         Iterator &operator++()
         {
-            RG_ASSERT(offset <= RG_LEN(bitset->data));
+            K_ASSERT(offset <= K_LEN(bitset->data));
 
             while (!bits) {
-                if (offset == RG_LEN(bitset->data) - 1)
+                if (offset == K_LEN(bitset->data) - 1)
                     return *this;
                 bits = bitset->data[++offset];
             }
@@ -769,14 +759,14 @@ public:
     typedef Iterator<Bitset> iterator_type;
 
     static constexpr Size Bits = N;
-    size_t data[(N + RG_BITS(size_t) - 1) / RG_BITS(size_t)] = {};
+    size_t data[(N + K_BITS(size_t) - 1) / K_BITS(size_t)] = {};
 
     constexpr Bitset() = default;
     constexpr Bitset(std::initializer_list<Size> bits)
     {
         for (Size idx: bits) {
-            Size offset = idx / (RG_SIZE(size_t) * 8);
-            size_t mask = (size_t)1 << (idx % (RG_SIZE(size_t) * 8));
+            Size offset = idx / (K_SIZE(size_t) * 8);
+            size_t mask = (size_t)1 << (idx % (K_SIZE(size_t) * 8));
 
             data[offset] |= mask;
         }
@@ -784,22 +774,22 @@ public:
 
     void Clear()
     {
-        MemSet(data, 0, RG_SIZE(data));
+        MemSet(data, 0, K_SIZE(data));
     }
 
     Iterator<Bitset> begin() { return Iterator<Bitset>(this, 0); }
     Iterator<const Bitset> begin() const { return Iterator<const Bitset>(this, 0); }
-    Iterator<Bitset> end() { return Iterator<Bitset>(this, RG_LEN(data)); }
-    Iterator<const Bitset> end() const { return Iterator<const Bitset>(this, RG_LEN(data)); }
+    Iterator<Bitset> end() { return Iterator<Bitset>(this, K_LEN(data)); }
+    Iterator<const Bitset> end() const { return Iterator<const Bitset>(this, K_LEN(data)); }
 
     Size PopCount() const
     {
         Size count = 0;
         for (size_t bits: data) {
-#if RG_SIZE_MAX == INT64_MAX
-            count += RG::PopCount((uint64_t)bits);
+#if K_SIZE_MAX == INT64_MAX
+            count += K::PopCount((uint64_t)bits);
 #else
-            count += RG::PopCount((uint32_t)bits);
+            count += K::PopCount((uint32_t)bits);
 #endif
         }
         return count;
@@ -807,28 +797,28 @@ public:
 
     inline bool Test(Size idx) const
     {
-        RG_ASSERT(idx >= 0 && idx < N);
+        K_ASSERT(idx >= 0 && idx < N);
 
-        Size offset = idx / (RG_SIZE(size_t) * 8);
-        size_t mask = (size_t)1 << (idx % (RG_SIZE(size_t) * 8));
+        Size offset = idx / (K_SIZE(size_t) * 8);
+        size_t mask = (size_t)1 << (idx % (K_SIZE(size_t) * 8));
 
         return data[offset] & mask;
     }
     inline void Set(Size idx, bool value = true)
     {
-        RG_ASSERT(idx >= 0 && idx < N);
+        K_ASSERT(idx >= 0 && idx < N);
 
-        Size offset = idx / (RG_SIZE(size_t) * 8);
-        size_t mask = (size_t)1 << (idx % (RG_SIZE(size_t) * 8));
+        Size offset = idx / (K_SIZE(size_t) * 8);
+        size_t mask = (size_t)1 << (idx % (K_SIZE(size_t) * 8));
 
         data[offset] = ApplyMask(data[offset], mask, value);
     }
     inline bool TestAndSet(Size idx, bool value = true)
     {
-        RG_ASSERT(idx >= 0 && idx < N);
+        K_ASSERT(idx >= 0 && idx < N);
 
-        Size offset = idx / (RG_SIZE(size_t) * 8);
-        size_t mask = (size_t)1 << (idx % (RG_SIZE(size_t) * 8));
+        Size offset = idx / (K_SIZE(size_t) * 8);
+        size_t mask = (size_t)1 << (idx % (K_SIZE(size_t) * 8));
 
         bool ret = data[offset] & mask;
         data[offset] = ApplyMask(data[offset], mask, value);
@@ -838,7 +828,7 @@ public:
 
     Bitset &operator&=(const Bitset &other)
     {
-        for (Size i = 0; i < RG_LEN(data); i++) {
+        for (Size i = 0; i < K_LEN(data); i++) {
             data[i] &= other.data[i];
         }
         return *this;
@@ -846,7 +836,7 @@ public:
     Bitset operator&(const Bitset &other)
     {
         Bitset ret;
-        for (Size i = 0; i < RG_LEN(data); i++) {
+        for (Size i = 0; i < K_LEN(data); i++) {
             ret.data[i] = data[i] & other.data[i];
         }
         return ret;
@@ -854,7 +844,7 @@ public:
 
     Bitset &operator|=(const Bitset &other)
     {
-        for (Size i = 0; i < RG_LEN(data); i++) {
+        for (Size i = 0; i < K_LEN(data); i++) {
             data[i] |= other.data[i];
         }
         return *this;
@@ -862,7 +852,7 @@ public:
     Bitset operator|(const Bitset &other)
     {
         Bitset ret;
-        for (Size i = 0; i < RG_LEN(data); i++) {
+        for (Size i = 0; i < K_LEN(data); i++) {
             ret.data[i] = data[i] | other.data[i];
         }
         return ret;
@@ -870,7 +860,7 @@ public:
 
     Bitset &operator^=(const Bitset &other)
     {
-        for (Size i = 0; i < RG_LEN(data); i++) {
+        for (Size i = 0; i < K_LEN(data); i++) {
             data[i] ^= other.data[i];
         }
         return *this;
@@ -878,7 +868,7 @@ public:
     Bitset operator^(const Bitset &other)
     {
         Bitset ret;
-        for (Size i = 0; i < RG_LEN(data); i++) {
+        for (Size i = 0; i < K_LEN(data); i++) {
             ret.data[i] = data[i] ^ other.data[i];
         }
         return ret;
@@ -886,7 +876,7 @@ public:
 
     Bitset &Flip()
     {
-        for (Size i = 0; i < RG_LEN(data); i++) {
+        for (Size i = 0; i < K_LEN(data); i++) {
             data[i] = ~data[i];
         }
         return *this;
@@ -894,7 +884,7 @@ public:
     Bitset operator~()
     {
         Bitset ret;
-        for (Size i = 0; i < RG_LEN(data); i++) {
+        for (Size i = 0; i < K_LEN(data); i++) {
             ret.data[i] = ~data[i];
         }
         return ret;
@@ -936,12 +926,12 @@ struct Span {
 
     constexpr T &operator[](Size idx)
     {
-        RG_ASSERT(idx >= 0 && idx < len);
+        K_ASSERT(idx >= 0 && idx < len);
         return ptr[idx];
     }
     constexpr const T &operator[](Size idx) const
     {
-        RG_ASSERT(idx >= 0 && idx < len);
+        K_ASSERT(idx >= 0 && idx < len);
         return ptr[idx];
     }
 
@@ -963,8 +953,8 @@ struct Span {
 
     constexpr Span Take(Size offset, Size sub_len) const
     {
-        RG_ASSERT(sub_len >= 0 && sub_len <= len);
-        RG_ASSERT(offset >= 0 && offset <= len - sub_len);
+        K_ASSERT(sub_len >= 0 && sub_len <= len);
+        K_ASSERT(offset >= 0 && offset <= len - sub_len);
 
         Span<T> sub = { ptr + offset, sub_len };
         return sub;
@@ -1005,7 +995,7 @@ struct Span<const char> {
 
     constexpr char operator[](Size idx) const
     {
-        RG_ASSERT(idx >= 0 && idx < len);
+        K_ASSERT(idx >= 0 && idx < len);
         return ptr[idx];
     }
 
@@ -1017,8 +1007,8 @@ struct Span<const char> {
 
     constexpr Span Take(Size offset, Size sub_len) const
     {
-        RG_ASSERT(sub_len >= 0 && sub_len <= len);
-        RG_ASSERT(offset >= 0 && offset <= len - sub_len);
+        K_ASSERT(sub_len >= 0 && sub_len <= len);
+        K_ASSERT(offset >= 0 && offset <= len - sub_len);
 
         Span<const char> sub = { ptr + offset, sub_len };
         return sub;
@@ -1051,14 +1041,14 @@ public:
     Size stride;
 
     Strider() = default;
-    constexpr Strider(T *ptr_) : ptr(ptr_), stride(RG_SIZE(T)) {}
+    constexpr Strider(T *ptr_) : ptr(ptr_), stride(K_SIZE(T)) {}
     constexpr Strider(T *ptr_, Size stride_) : ptr(ptr_), stride(stride_) {}
 
     constexpr bool IsValid() const { return ptr; }
 
     constexpr T &operator[](Size idx) const
     {
-        RG_ASSERT(idx >= 0);
+        K_ASSERT(idx >= 0);
         return *(T *)((uint8_t *)ptr + (idx * stride));
     }
 };
@@ -1066,7 +1056,7 @@ public:
 template <typename T>
 static constexpr inline Strider<T> MakeStrider(T *ptr)
 {
-    return Strider<T>(ptr, RG_SIZE(T));
+    return Strider<T>(ptr, K_SIZE(T));
 }
 template <typename T>
 static constexpr inline Strider<T> MakeStrider(T *ptr, Size stride)
@@ -1076,7 +1066,7 @@ static constexpr inline Strider<T> MakeStrider(T *ptr, Size stride)
 template <typename T, Size N>
 static constexpr inline Strider<T> MakeStrider(T (&arr)[N])
 {
-    return Strider<T>(arr, RG_SIZE(T));
+    return Strider<T>(arr, K_SIZE(T));
 }
 
 enum class AllocFlag {
@@ -1085,7 +1075,7 @@ enum class AllocFlag {
 };
 
 class Allocator {
-    RG_DELETE_COPY(Allocator)
+    K_DELETE_COPY(Allocator)
 
 public:
     Allocator() = default;
@@ -1101,7 +1091,7 @@ Allocator *GetNullAllocator();
 
 static inline void *AllocateRaw(Allocator *alloc, Size size, unsigned int flags = 0)
 {
-    RG_ASSERT(size >= 0);
+    K_ASSERT(size >= 0);
 
     if (!alloc) {
         alloc = GetDefaultAllocator();
@@ -1118,7 +1108,7 @@ T *AllocateOne(Allocator *alloc, unsigned int flags = 0)
         alloc = GetDefaultAllocator();
     }
 
-    Size size = RG_SIZE(T);
+    Size size = K_SIZE(T);
 
     T *ptr = (T *)alloc->Allocate(size, flags);
     return ptr;
@@ -1127,13 +1117,13 @@ T *AllocateOne(Allocator *alloc, unsigned int flags = 0)
 template <typename T>
 Span<T> AllocateSpan(Allocator *alloc, Size len, unsigned int flags = 0)
 {
-    RG_ASSERT(len >= 0);
+    K_ASSERT(len >= 0);
 
     if (!alloc) {
         alloc = GetDefaultAllocator();
     }
 
-    Size size = len * RG_SIZE(T);
+    Size size = len * K_SIZE(T);
 
     T *ptr = (T *)alloc->Allocate(size, flags);
     return MakeSpan(ptr, len);
@@ -1142,7 +1132,7 @@ Span<T> AllocateSpan(Allocator *alloc, Size len, unsigned int flags = 0)
 static inline void *ResizeRaw(Allocator *alloc, void *ptr, Size old_size, Size new_size,
                               unsigned int flags = 0)
 {
-    RG_ASSERT(new_size >= 0);
+    K_ASSERT(new_size >= 0);
 
     if (!alloc) {
         alloc = GetDefaultAllocator();
@@ -1156,14 +1146,14 @@ template <typename T>
 Span<T> ResizeSpan(Allocator *alloc, Span<T> mem, Size new_len,
                    unsigned int flags = 0)
 {
-    RG_ASSERT(new_len >= 0);
+    K_ASSERT(new_len >= 0);
 
     if (!alloc) {
         alloc = GetDefaultAllocator();
     }
 
-    Size old_size = mem.len * RG_SIZE(T);
-    Size new_size = new_len * RG_SIZE(T);
+    Size old_size = mem.len * K_SIZE(T);
+    Size new_size = new_len * K_SIZE(T);
 
     mem.ptr = (T *)alloc->Resize(mem.ptr, old_size, new_size, flags);
     return MakeSpan(mem.ptr, new_len);
@@ -1185,7 +1175,7 @@ void ReleaseOne(Allocator *alloc, T *ptr)
         alloc = GetDefaultAllocator();
     }
 
-    alloc->Release((void *)ptr, RG_SIZE(T));
+    alloc->Release((void *)ptr, K_SIZE(T));
 }
 
 template<typename T>
@@ -1195,7 +1185,7 @@ void ReleaseSpan(Allocator *alloc, Span<T> mem)
         alloc = GetDefaultAllocator();
     }
 
-    Size size = mem.len * RG_SIZE(T);
+    Size size = mem.len * K_SIZE(T);
 
     alloc->Release((void *)mem.ptr, size);
 }
@@ -1246,10 +1236,10 @@ class BlockAllocator: public Allocator {
     uint8_t *last_alloc = nullptr;
 
 public:
-    BlockAllocator(Size block_size = RG_BLOCK_ALLOCATOR_DEFAULT_SIZE)
+    BlockAllocator(Size block_size = K_BLOCK_ALLOCATOR_DEFAULT_SIZE)
         : block_size(block_size)
     {
-        RG_ASSERT(block_size > 0);
+        K_ASSERT(block_size > 0);
     }
 
     BlockAllocator(BlockAllocator &&other) { *this = std::move(other); }
@@ -1288,9 +1278,9 @@ public:
     RetainPtr(T *p, void (*delete_func)(std::remove_const_t<T> *))
         : p(p)
     {
-        RG_ASSERT(p);
-        RG_ASSERT(delete_func);
-        RG_ASSERT(!p->delete_func || delete_func == p->delete_func);
+        K_ASSERT(p);
+        K_ASSERT(delete_func);
+        K_ASSERT(!p->delete_func || delete_func == p->delete_func);
 
         p->Ref();
         p->delete_func = delete_func;
@@ -1299,7 +1289,7 @@ public:
         : p(p)
     {
         if (p) {
-            RG_ASSERT(p->delete_func);
+            K_ASSERT(p->delete_func);
 
             if (ref) {
                 p->Ref();
@@ -1346,7 +1336,7 @@ public:
 
     T &operator*() const
     {
-        RG_ASSERT(p);
+        K_ASSERT(p);
         return *p;
     }
     T *operator->() const { return p; }
@@ -1363,7 +1353,7 @@ public:
     bool Unref() const
     {
         int new_count = --refcount;
-        RG_ASSERT(new_count >= 0);
+        K_ASSERT(new_count >= 0);
         return new_count;
     }
 
@@ -1545,7 +1535,6 @@ static inline bool StartsWith(Span<const char> str, Span<const char> prefix)
             return false;
         i++;
     }
-
     return (i == prefix.len);
 }
 static inline bool StartsWith(Span<const char> str, const char *prefix)
@@ -1556,9 +1545,18 @@ static inline bool StartsWith(Span<const char> str, const char *prefix)
             return false;
         i++;
     }
-
     return !prefix[i];
 }
+static inline bool StartsWith(const char *str, Span<const char> prefix)
+{
+    Size i = 0;
+    while (str[i] && i < prefix.len) {
+        if (str[i] != prefix[i])
+            return false;
+        i++;
+    }
+    return (i == prefix.len);
+}
 static inline bool StartsWith(const char *str, const char *prefix)
 {
     Size i = 0;
@@ -1567,14 +1565,55 @@ static inline bool StartsWith(const char *str, const char *prefix)
             return false;
         i++;
     }
+    return !prefix[i];
+}
 
+static inline bool StartsWithI(Span<const char> str, Span<const char> prefix)
+{
+    Size i = 0;
+    while (i < str.len && i < prefix.len) {
+        if (LowerAscii(str[i]) != LowerAscii(prefix[i]))
+            return false;
+        i++;
+    }
+    return (i == prefix.len);
+}
+static inline bool StartsWithI(Span<const char> str, const char *prefix)
+{
+    Size i = 0;
+    while (i < str.len && prefix[i]) {
+        if (LowerAscii(str[i]) != LowerAscii(prefix[i]))
+            return false;
+        i++;
+    }
+    return !prefix[i];
+}
+static inline bool StartsWithI(const char *str, Span<const char> prefix)
+{
+    Size i = 0;
+    while (str[i] && i < prefix.len) {
+        if (LowerAscii(str[i]) != LowerAscii(prefix[i]))
+            return false;
+        i++;
+    }
+    return (i == prefix.len);
+}
+static inline bool StartsWithI(const char *str, const char *prefix)
+{
+    Size i = 0;
+    while (str[i] && prefix[i]) {
+        if (LowerAscii(str[i]) != LowerAscii(prefix[i]))
+            return false;
+        i++;
+    }
     return !prefix[i];
 }
 
-static inline bool EndsWith(Span<const char> str, const char *suffix)
+static inline bool EndsWith(Span<const char> str, Span<const char> suffix)
 {
     Size i = str.len - 1;
-    Size j = (Size)strlen(suffix) - 1;
+    Size j = suffix.len - 1;
+
     while (i >= 0 && j >= 0) {
         if (str[i] != suffix[j])
             return false;
@@ -1585,6 +1624,21 @@ static inline bool EndsWith(Span<const char> str, const char *suffix)
 
     return j < 0;
 }
+static inline bool EndsWithI(Span<const char> str, Span<const char> suffix)
+{
+    Size i = str.len - 1;
+    Size j = suffix.len - 1;
+
+    while (i >= 0 && j >= 0) {
+        if (LowerAscii(str[i]) != LowerAscii(suffix[j]))
+            return false;
+
+        i--;
+        j--;
+    }
+
+    return j < 0;
+}
 
 static inline Size FindStr(Span<const char> str, Span<const char> needle)
 {
@@ -1649,16 +1703,15 @@ static inline Span<const char> SplitStr(Span<const char> str, char split_char, S
 static inline Span<const char> SplitStr(const char *str, char split_char, const char **out_remainder = nullptr)
     { return SplitStr((char *)str, split_char, (char **)out_remainder); }
 
-static inline Span<char> SplitStr(Span<char> str, const char *split_str, Span<char> *out_remainder = nullptr)
+static inline Span<char> SplitStr(Span<char> str, Span<const char> split, Span<char> *out_remainder = nullptr)
 {
-    RG_ASSERT(split_str[0]);
+    K_ASSERT(split.len);
 
     Size part_len = 0;
     while (part_len < str.len) {
-        if (StartsWith(str.Take(part_len, str.len - part_len), split_str)) {
+        if (StartsWith(str.Take(part_len, str.len - part_len), split)) {
             if (out_remainder) {
-                Size split_len = strlen(split_str);
-                *out_remainder = str.Take(part_len + split_len, str.len - part_len - split_len);
+                *out_remainder = str.Take(part_len + split.len, str.len - part_len - split.len);
             }
             return str.Take(0, part_len);
         }
@@ -1670,16 +1723,15 @@ static inline Span<char> SplitStr(Span<char> str, const char *split_str, Span<ch
     }
     return str;
 }
-static inline Span<char> SplitStr(char *str, const char *split_str, char **out_remainder = nullptr)
+static inline Span<char> SplitStr(char *str, Span<const char> split, char **out_remainder = nullptr)
 {
-    RG_ASSERT(split_str[0]);
+    K_ASSERT(split.len);
 
     Size part_len = 0;
     while (str[part_len]) {
-        if (StartsWith(str + part_len, split_str)) {
+        if (StartsWith(str + part_len, split)) {
             if (out_remainder) {
-                Size split_len = strlen(split_str);
-                *out_remainder = str + part_len + split_len;
+                *out_remainder = str + part_len + split.len;
             }
             return MakeSpan(str, part_len);
         }
@@ -1691,10 +1743,10 @@ static inline Span<char> SplitStr(char *str, const char *split_str, char **out_r
     }
     return MakeSpan(str, part_len);
 }
-static inline Span<const char> SplitStr(Span<const char> str, const char *split_str, Span<const char> *out_remainder = nullptr)
-    { return SplitStr(MakeSpan((char *)str.ptr, str.len), split_str, (Span<char> *)out_remainder); }
-static inline Span<const char> SplitStr(const char *str, const char *split_str, const char **out_remainder = nullptr)
-    { return SplitStr((char *)str, split_str, (char **)out_remainder); }
+static inline Span<const char> SplitStr(Span<const char> str, Span<const char> split, Span<const char> *out_remainder = nullptr)
+    { return SplitStr(MakeSpan((char *)str.ptr, str.len), split, (Span<char> *)out_remainder); }
+static inline Span<const char> SplitStr(const char *str, Span<const char> split, const char **out_remainder = nullptr)
+    { return SplitStr((char *)str, split, (char **)out_remainder); }
 
 static inline Span<char> SplitStrLine(Span<char> str, Span<char> *out_remainder = nullptr)
 {
@@ -1890,116 +1942,8 @@ static inline Span<const char> TrimStrRight(Span<const char> str, const char *tr
 static inline Span<const char> TrimStr(Span<const char> str, const char *trim_chars = " \t\r\n")
     { return TrimStr(MakeSpan((char *)str.ptr, str.len), trim_chars); }
 
-static inline int CountUtf8Bytes(char c)
-{
-    int ones = CountLeadingZeros((uint32_t)~c << 24);
-    return std::min(std::max(ones, 1), 4);
-}
-
-static constexpr inline Size DecodeUtf8(const char *str, int32_t *out_c)
-{
-    RG_ASSERT(str[0]);
-
-#define BYTE(Idx) ((uint8_t)str[Idx])
-
-    if (BYTE(0) < 0x80) {
-        *out_c = BYTE(0);
-        return 1;
-    } else if (BYTE(0) - 0xC2 > 0xF4 - 0xC2) [[unlikely]] {
-        return 0;
-    } else if (BYTE(1)) [[likely]] {
-        if (BYTE(0) < 0xE0 && (BYTE(1) & 0xC0) == 0x80) {
-            *out_c = ((BYTE(0) & 0x1F) << 6) | (BYTE(1) & 0x3F);
-            return 2;
-        } else if (BYTE(2)) [[likely]] {
-            if (BYTE(0) < 0xF0 &&
-                   (BYTE(1) & 0xC0) == 0x80 &&
-                   (BYTE(2) & 0xC0) == 0x80) {
-                *out_c = ((BYTE(0) & 0xF) << 12) | ((BYTE(1) & 0x3F) << 6) | (BYTE(2) & 0x3F);
-                return 3;
-            } else if (BYTE(3)) [[likely]] {
-                if ((BYTE(1) & 0xC0) == 0x80 &&
-                       (BYTE(2) & 0xC0) == 0x80 &&
-                       (BYTE(3) & 0xC0) == 0x80) {
-                    *out_c = ((BYTE(0) & 0x7) << 18) | ((BYTE(1) & 0x3F) << 12) | ((BYTE(2) & 0x3F) << 6) | (BYTE(3) & 0x3F);
-                    return 4;
-                }
-            }
-        }
-    }
-
-#undef BYTE
-
-    return 0;
-}
-
-static constexpr inline Size DecodeUtf8(Span<const char> str, Size offset, int32_t *out_c)
-{
-    RG_ASSERT(offset < str.len);
-
-    str = str.Take(offset, str.len - offset);
-
-#define BYTE(Idx) ((uint8_t)str[Idx])
-
-    if (BYTE(0) < 0x80) {
-        *out_c = BYTE(0);
-        return 1;
-    } else if (BYTE(0) - 0xC2 > 0xF4 - 0xC2) [[unlikely]] {
-        return 0;
-    } else if (BYTE(0) < 0xE0 && str.len >= 2 && (BYTE(1) & 0xC0) == 0x80) {
-        *out_c = ((BYTE(0) & 0x1F) << 6) | (BYTE(1) & 0x3F);
-        return 2;
-    } else if (BYTE(0) < 0xF0 && str.len >= 3 && (BYTE(1) & 0xC0) == 0x80 &&
-                                                 (BYTE(2) & 0xC0) == 0x80) {
-        *out_c = ((BYTE(0) & 0xF) << 12) | ((BYTE(1) & 0x3F) << 6) | (BYTE(2) & 0x3F);
-        return 3;
-    } else if (str.len >= 4 && (BYTE(1) & 0xC0) == 0x80 &&
-                               (BYTE(2) & 0xC0) == 0x80 &&
-                               (BYTE(3) & 0xC0) == 0x80) {
-        *out_c = ((BYTE(0) & 0x7) << 18) | ((BYTE(1) & 0x3F) << 12) | ((BYTE(2) & 0x3F) << 6) | (BYTE(3) & 0x3F);
-        return 4;
-    } else {
-        return 0;
-    }
-
-#undef BYTE
-}
-
-static constexpr inline int32_t DecodeUtf8(const char *str)
-{
-    int32_t uc = -1;
-    DecodeUtf8(str, &uc);
-    return uc;
-}
-
-static inline Size EncodeUtf8(int32_t c, char out_buf[4])
-{
-    if (c < 0x80) {
-        out_buf[0] = (char)c;
-        return 1;
-    } else if (c < 0x800) {
-        out_buf[0] = (char)(0xC0 | (c >> 6));
-        out_buf[1] = (char)(0x80 | (c & 0x3F));
-        return 2;
-    } else if (c >= 0xD800 && c < 0xE000) {
-        return 0;
-    } else if (c < 0x10000) {
-        out_buf[0] = (char)(0xE0 | (c >> 12));
-        out_buf[1] = (char)(0x80 | ((c >> 6) & 0x3F));
-        out_buf[2] = (char)(0x80 | (c & 0x3F));
-        return 3;
-    } else if (c < 0x110000) {
-        out_buf[0] = (char)(0xF0 | (c >> 18));
-        out_buf[1] = (char)(0x80 | ((c >> 12) & 0x3F));
-        out_buf[2] = (char)(0x80 | ((c >> 6) & 0x3F));
-        out_buf[3] = (char)(0x80 | (c & 0x3F));
-        return 4;
-    } else {
-        return 0;
-    }
-}
-
-bool IsValidUtf8(Span<const char> str);
+int CmpNatural(Span<const char> str1, Span<const char> str2);
+int CmpNaturalI(Span<const char> str1, Span<const char> str2);
 
 // ------------------------------------------------------------------------
 // Collections
@@ -2017,7 +1961,7 @@ public:
     constexpr LocalArray() = default;
     constexpr LocalArray(std::initializer_list<T> l)
     {
-        RG_ASSERT(l.size() <= N);
+        K_ASSERT(l.size() <= N);
         for (const T &it: l) {
             data[len++] = it;
         }
@@ -2040,16 +1984,16 @@ public:
     T *end() { return data + len; }
     const T *end() const { return data + len; }
 
-    Size Available() const { return RG_LEN(data) - len; }
+    Size Available() const { return K_LEN(data) - len; }
 
     T &operator[](Size idx)
     {
-        RG_ASSERT(idx >= 0 && idx < len);
+        K_ASSERT(idx >= 0 && idx < len);
         return data[idx];
     }
     const T &operator[](Size idx) const
     {
-        RG_ASSERT(idx >= 0 && idx < len);
+        K_ASSERT(idx >= 0 && idx < len);
         return data[idx];
     }
 
@@ -2069,7 +2013,7 @@ public:
 
     T *AppendDefault(Size count = 1)
     {
-        RG_ASSERT(len <= N - count);
+        K_ASSERT(len <= N - count);
 
         T *first = data + len;
         if constexpr(!std::is_trivial<T>::value) {
@@ -2078,7 +2022,7 @@ public:
                 len++;
             }
         } else {
-            MemSet(first, 0, count * RG_SIZE(T));
+            MemSet(first, 0, count * K_SIZE(T));
             len += count;
         }
 
@@ -2087,7 +2031,7 @@ public:
 
     T *Append(const T &value)
     {
-        RG_ASSERT(len < N);
+        K_ASSERT(len < N);
 
         T *it = data + len;
         *it = value;
@@ -2097,7 +2041,7 @@ public:
     }
     T *Append(T &&value)
     {
-        RG_ASSERT(len < N);
+        K_ASSERT(len < N);
 
         T *it = data + len;
         *it = std::move(value);
@@ -2107,7 +2051,7 @@ public:
     }
     T *Append(Span<const T> values)
     {
-        RG_ASSERT(values.len <= N - len);
+        K_ASSERT(values.len <= N - len);
 
         T *it = data + len;
         for (Size i = 0; i < values.len; i++) {
@@ -2120,7 +2064,7 @@ public:
 
     void RemoveFrom(Size first)
     {
-        RG_ASSERT(first >= 0 && first <= len);
+        K_ASSERT(first >= 0 && first <= len);
 
         for (Size i = first; i < len; i++) {
             data[i] = T();
@@ -2129,7 +2073,7 @@ public:
     }
     void RemoveLast(Size count = 1)
     {
-        RG_ASSERT(count >= 0 && count <= len);
+        K_ASSERT(count >= 0 && count <= len);
         RemoveFrom(len - count);
     }
 
@@ -2171,8 +2115,8 @@ public:
     HeapArray &operator=(HeapArray &&other)
     {
         Clear();
-        MemMove(this, &other, RG_SIZE(other));
-        MemSet(&other, 0, RG_SIZE(other));
+        MemMove(this, &other, K_SIZE(other));
+        MemSet(&other, 0, K_SIZE(other));
         return *this;
     }
     HeapArray(const HeapArray &other) { *this = other; }
@@ -2185,7 +2129,7 @@ public:
                 ptr[i] = other.ptr[i];
             }
         } else {
-            MemCpy(ptr, other.ptr, other.len * RG_SIZE(*ptr));
+            MemCpy(ptr, other.ptr, other.len * K_SIZE(*ptr));
         }
         len = other.len;
         return *this;
@@ -2209,12 +2153,12 @@ public:
 
     T &operator[](Size idx)
     {
-        RG_ASSERT(idx >= 0 && idx < len);
+        K_ASSERT(idx >= 0 && idx < len);
         return ptr[idx];
     }
     const T &operator[](Size idx) const
     {
-        RG_ASSERT(idx >= 0 && idx < len);
+        K_ASSERT(idx >= 0 && idx < len);
         return ptr[idx];
     }
 
@@ -2234,7 +2178,7 @@ public:
 
     void SetCapacity(Size new_capacity)
     {
-        RG_ASSERT(new_capacity >= 0);
+        K_ASSERT(new_capacity >= 0);
 
         if (new_capacity != capacity) {
             if (len > new_capacity) {
@@ -2244,7 +2188,7 @@ public:
                 len = new_capacity;
             }
 
-            ptr = (T *)ResizeRaw(allocator, ptr, capacity * RG_SIZE(T), new_capacity * RG_SIZE(T));
+            ptr = (T *)ResizeRaw(allocator, ptr, capacity * K_SIZE(T), new_capacity * K_SIZE(T));
             capacity = new_capacity;
         }
     }
@@ -2258,18 +2202,18 @@ public:
 
     T *Grow(Size reserve_capacity = 1)
     {
-        RG_ASSERT(capacity >= 0);
-        RG_ASSERT(reserve_capacity >= 0);
-        RG_ASSERT((size_t)capacity + (size_t)reserve_capacity <= RG_SIZE_MAX);
+        K_ASSERT(capacity >= 0);
+        K_ASSERT(reserve_capacity >= 0);
+        K_ASSERT((size_t)capacity + (size_t)reserve_capacity <= K_SIZE_MAX);
 
         if (reserve_capacity > capacity - len) {
             Size needed = capacity + reserve_capacity;
 
             Size new_capacity;
-            if (needed <= RG_HEAPARRAY_BASE_CAPACITY) {
-                new_capacity = RG_HEAPARRAY_BASE_CAPACITY;
+            if (needed <= K_HEAPARRAY_BASE_CAPACITY) {
+                new_capacity = K_HEAPARRAY_BASE_CAPACITY;
             } else {
-                new_capacity = (Size)((double)(needed - 1) * RG_HEAPARRAY_GROWTH_FACTOR);
+                new_capacity = (Size)((double)(needed - 1) * K_HEAPARRAY_GROWTH_FACTOR);
             }
 
             SetCapacity(new_capacity);
@@ -2291,7 +2235,7 @@ public:
                 len++;
             }
         } else {
-            MemSet(first, 0, count * RG_SIZE(T));
+            MemSet(first, 0, count * K_SIZE(T));
             len += count;
         }
 
@@ -2336,7 +2280,7 @@ public:
 
     void RemoveFrom(Size first)
     {
-        RG_ASSERT(first >= 0 && first <= len);
+        K_ASSERT(first >= 0 && first <= len);
 
         if constexpr(!std::is_trivial<T>::value) {
             for (Size i = first; i < len; i++) {
@@ -2347,7 +2291,7 @@ public:
     }
     void RemoveLast(Size count = 1)
     {
-        RG_ASSERT(count >= 0 && count <= len);
+        K_ASSERT(count >= 0 && count <= len);
         RemoveFrom(len - count);
     }
 
@@ -2377,7 +2321,7 @@ public:
 
 template <typename T, Size BucketSize = 64, typename AllocatorType = BlockAllocator>
 class BucketArray {
-    RG_DELETE_COPY(BucketArray)
+    K_DELETE_COPY(BucketArray)
 
 public:
     struct Bucket {
@@ -2495,8 +2439,8 @@ public:
     BucketArray &operator=(BucketArray &&other)
     {
         ClearBucketsAndValues();
-        MemMove(this, &other, RG_SIZE(other));
-        MemSet(&other, 0, RG_SIZE(other));
+        MemMove(this, &other, K_SIZE(other));
+        MemSet(&other, 0, K_SIZE(other));
         return *this;
     }
 
@@ -2529,7 +2473,7 @@ public:
 
     const T &operator[](Size idx) const
     {
-        RG_ASSERT(idx >= 0 && idx < count);
+        K_ASSERT(idx >= 0 && idx < count);
 
         idx += offset;
         Size bucket_idx = idx / BucketSize;
@@ -2547,7 +2491,7 @@ public:
         if (bucket_idx >= buckets.len) {
             Bucket *new_bucket = AllocateOne<Bucket>(buckets.allocator);
             new (&new_bucket->allocator) AllocatorType();
-            new_bucket->values = (T *)AllocateRaw(&new_bucket->allocator, BucketSize * RG_SIZE(T));
+            new_bucket->values = (T *)AllocateRaw(&new_bucket->allocator, BucketSize * K_SIZE(T));
 
             buckets.Append(new_bucket);
         }
@@ -2572,7 +2516,7 @@ public:
 
     void RemoveFrom(Size from)
     {
-        RG_ASSERT(from >= 0 && from <= count);
+        K_ASSERT(from >= 0 && from <= count);
 
         if (from == count)
             return;
@@ -2598,13 +2542,13 @@ public:
     }
     void RemoveLast(Size n = 1)
     {
-        RG_ASSERT(n >= 0 && n <= count);
+        K_ASSERT(n >= 0 && n <= count);
         RemoveFrom(count - n);
     }
 
     void RemoveFirst(Size n = 1)
     {
-        RG_ASSERT(n >= 0 && n <= count);
+        K_ASSERT(n >= 0 && n <= count);
 
         if (n == count) {
             Clear();
@@ -2623,7 +2567,7 @@ public:
                 DeleteBucket(buckets[i]);
             }
             MemMove(&buckets[0], &buckets[end_bucket_idx],
-                    (buckets.len - end_bucket_idx) * RG_SIZE(Bucket *));
+                    (buckets.len - end_bucket_idx) * K_SIZE(Bucket *));
             buckets.RemoveLast(end_bucket_idx);
         }
 
@@ -2650,7 +2594,7 @@ public:
 
         count = (it.bucket_idx * BucketSize) + it.bucket_offset - offset;
 
-        RG_ASSERT(it == end());
+        K_ASSERT(it == end());
     }
     void RemoveFrom(const Iterator<const BucketArray<T, BucketSize>> &it) { return RemoveFrom((iterator_type)it); }
 
@@ -2670,7 +2614,7 @@ public:
                 DeleteBucket(buckets[i]);
             }
             MemMove(&buckets[0], &buckets[it.bucket_idx],
-                    (buckets.len - it.bucket_idx) * RG_SIZE(Bucket *));
+                    (buckets.len - it.bucket_idx) * K_SIZE(Bucket *));
             buckets.RemoveLast(it.bucket_idx);
         }
 
@@ -2736,18 +2680,18 @@ public:
 
         ValueType &operator*()
         {
-            RG_ASSERT(!table->IsEmpty(offset));
+            K_ASSERT(!table->IsEmpty(offset));
             return table->data[offset];
         }
         const ValueType &operator*() const
         {
-            RG_ASSERT(!table->IsEmpty(offset));
+            K_ASSERT(!table->IsEmpty(offset));
             return table->data[offset];
         }
 
         Iterator &operator++()
         {
-            RG_ASSERT(offset < table->capacity);
+            K_ASSERT(offset < table->capacity);
             while (++offset < table->capacity && table->IsEmpty(offset));
             return *this;
         }
@@ -2793,8 +2737,8 @@ public:
     HashTable &operator=(HashTable &&other)
     {
         Clear();
-        MemMove(this, &other, RG_SIZE(other));
-        MemSet(&other, 0, RG_SIZE(other));
+        MemMove(this, &other, K_SIZE(other));
+        MemSet(&other, 0, K_SIZE(other));
         return *this;
     }
     HashTable(const HashTable &other) { *this = other; }
@@ -2829,7 +2773,7 @@ public:
 
         count = 0;
         if (used) {
-            size_t len = (size_t)(capacity + (RG_SIZE(size_t) * 8) - 1) / RG_SIZE(size_t);
+            size_t len = (size_t)(capacity + (K_SIZE(size_t) * 8) - 1) / K_SIZE(size_t);
             MemSet(used, 0, len);
         }
     }
@@ -2886,7 +2830,7 @@ public:
         return ptr;
     }
 
-    ValueType *TrySet(const ValueType &value, bool *out_inserted = nullptr)
+    ValueType *InsertOrGet(const ValueType &value, bool *out_inserted = nullptr)
     {
         const KeyType &key = Handler::GetKey(value);
 
@@ -2902,7 +2846,7 @@ public:
         }
         return ptr;
     }
-    ValueType *TrySetDefault(const KeyType &key, bool *out_inserted = nullptr)
+    ValueType *InsertOrGetDefault(const KeyType &key, bool *out_inserted = nullptr)
     {
         bool inserted;
         ValueType *ptr = Insert(key, &inserted);
@@ -2923,7 +2867,7 @@ public:
             return;
 
         Size clear_idx = it - data;
-        RG_ASSERT(!IsEmpty(clear_idx));
+        K_ASSERT(!IsEmpty(clear_idx));
 
         it->~ValueType();
         count--;
@@ -2943,7 +2887,7 @@ public:
 
             MarkUsed(clear_idx);
             MarkEmpty(idx);
-            MemMove(&data[clear_idx], &data[idx], RG_SIZE(*data));
+            MemMove(&data[clear_idx], &data[idx], K_SIZE(*data));
 
             clear_idx = idx;
         }
@@ -2958,9 +2902,9 @@ public:
         if (count) {
             Size new_capacity = (Size)1 << (64 - CountLeadingZeros((uint64_t)count));
 
-            if (new_capacity < RG_HASHTABLE_BASE_CAPACITY) {
-                new_capacity = RG_HASHTABLE_BASE_CAPACITY;
-            } else if (count > (double)new_capacity * RG_HASHTABLE_MAX_LOAD_FACTOR) {
+            if (new_capacity < K_HASHTABLE_BASE_CAPACITY) {
+                new_capacity = K_HASHTABLE_BASE_CAPACITY;
+            } else if (count > (double)new_capacity * K_HASHTABLE_MAX_LOAD_FACTOR) {
                 new_capacity *= 2;
             }
 
@@ -3004,7 +2948,7 @@ private:
             Size idx = HashToIndex(hash);
             ValueType *it = Find(&idx, key);
             if (!it) {
-                if (count >= (Size)((double)capacity * RG_HASHTABLE_MAX_LOAD_FACTOR)) {
+                if (count >= (Size)((double)capacity * K_HASHTABLE_MAX_LOAD_FACTOR)) {
                     Rehash(capacity << 1);
                     idx = HashToIndex(hash);
                     while (!IsEmpty(idx)) {
@@ -3021,7 +2965,7 @@ private:
                 return it;
             }
         } else {
-            Rehash(RG_HASHTABLE_BASE_CAPACITY);
+            Rehash(K_HASHTABLE_BASE_CAPACITY);
 
             Size idx = HashToIndex(hash);
             count++;
@@ -3036,7 +2980,7 @@ private:
     {
         if (new_capacity == capacity)
             return;
-        RG_ASSERT(count <= new_capacity);
+        K_ASSERT(count <= new_capacity);
 
         size_t *old_used = used;
         ValueType *old_data = data;
@@ -3044,9 +2988,9 @@ private:
 
         if (new_capacity) {
             used = (size_t *)AllocateRaw(allocator,
-                                         (new_capacity + (RG_SIZE(size_t) * 8) - 1) / RG_SIZE(size_t),
+                                         (new_capacity + (K_SIZE(size_t) * 8) - 1) / K_SIZE(size_t),
                                          (int)AllocFlag::Zero);
-            data = (ValueType *)AllocateRaw(allocator, new_capacity * RG_SIZE(ValueType));
+            data = (ValueType *)AllocateRaw(allocator, new_capacity * K_SIZE(ValueType));
             for (Size i = 0; i < new_capacity; i++) {
                 new (&data[i]) ValueType();
             }
@@ -3068,22 +3012,22 @@ private:
             capacity = 0;
         }
 
-        ReleaseRaw(allocator, old_used, (old_capacity + (RG_SIZE(size_t) * 8) - 1) / RG_SIZE(size_t));
-        ReleaseRaw(allocator, old_data, old_capacity * RG_SIZE(ValueType));
+        ReleaseRaw(allocator, old_used, (old_capacity + (K_SIZE(size_t) * 8) - 1) / K_SIZE(size_t));
+        ReleaseRaw(allocator, old_data, old_capacity * K_SIZE(ValueType));
     }
 
     inline void MarkUsed(Size idx)
     {
-        used[idx / (RG_SIZE(size_t) * 8)] |= (1ull << (idx % (RG_SIZE(size_t) * 8)));
+        used[idx / (K_SIZE(size_t) * 8)] |= (1ull << (idx % (K_SIZE(size_t) * 8)));
     }
     inline void MarkEmpty(Size idx)
     {
-        used[idx / (RG_SIZE(size_t) * 8)] &= ~(1ull << (idx % (RG_SIZE(size_t) * 8)));
+        used[idx / (K_SIZE(size_t) * 8)] &= ~(1ull << (idx % (K_SIZE(size_t) * 8)));
     }
 
     inline bool IsEmpty(size_t *used, Size idx) const
     {
-        bool empty = !(used[idx / (RG_SIZE(size_t) * 8)] & (1ull << (idx % (RG_SIZE(size_t) * 8))));
+        bool empty = !(used[idx / (K_SIZE(size_t) * 8)] & (1ull << (idx % (K_SIZE(size_t) * 8))));
         return empty;
     }
     inline bool IsEmpty(Size idx) const { return IsEmpty(used, idx); }
@@ -3167,7 +3111,7 @@ DEFINE_INTEGER_HASH_TRAITS_32(unsigned int, constexpr);
 #endif
 DEFINE_INTEGER_HASH_TRAITS_64(long long, constexpr);
 DEFINE_INTEGER_HASH_TRAITS_64(unsigned long long, constexpr);
-#if RG_SIZE_MAX == INT64_MAX
+#if K_SIZE_MAX == INT64_MAX
     DEFINE_INTEGER_HASH_TRAITS_64(void *);
     DEFINE_INTEGER_HASH_TRAITS_64(const void *);
 #else
@@ -3194,7 +3138,7 @@ static constexpr inline uint64_t HashStr(Span<const char> str)
         } :
 #endif
         [](const char *p) {
-#if defined(RG_BIG_ENDIAN)
+#if defined(K_BIG_ENDIAN)
             uint64_t result = ((uint64_t)p[0] << 56) |
                               ((uint64_t)p[1] << 48) |
                               ((uint64_t)p[2] << 40) |
@@ -3275,7 +3219,7 @@ public:
     static constexpr bool Test(Span<const char> key1, const char * key2) { return key1 == key2; }
 };
 
-#define RG_HASHTABLE_HANDLER_EX_N(Name, ValueType, KeyType, KeyMember, HashFunc, TestFunc) \
+#define K_HASHTABLE_HANDLER_EX_N(Name, ValueType, KeyType, KeyMember, HashFunc, TestFunc) \
     class Name { \
     public: \
         static constexpr KeyType GetKey(const ValueType &value) \
@@ -3289,16 +3233,16 @@ public:
         static constexpr bool TestKeys(KeyType key1, TestKey key2) \
             { return TestFunc((key1), (key2)); } \
     }
-#define RG_HASHTABLE_HANDLER_EX(ValueType, KeyType, KeyMember, HashFunc, TestFunc) \
-    RG_HASHTABLE_HANDLER_EX_N(HashHandler, ValueType, KeyType, KeyMember, HashFunc, TestFunc)
-#define RG_HASHTABLE_HANDLER(ValueType, KeyMember) \
-    RG_HASHTABLE_HANDLER_EX(ValueType, decltype(ValueType::KeyMember), KeyMember, HashTraits<decltype(ValueType::KeyMember)>::Hash, HashTraits<decltype(ValueType::KeyMember)>::Test)
-#define RG_HASHTABLE_HANDLER_N(Name, ValueType, KeyMember) \
-    RG_HASHTABLE_HANDLER_EX_N(Name, ValueType, decltype(ValueType::KeyMember), KeyMember, HashTraits<decltype(ValueType::KeyMember)>::Hash, HashTraits<decltype(ValueType::KeyMember)>::Test)
-#define RG_HASHTABLE_HANDLER_T(ValueType, KeyType, KeyMember) \
-    RG_HASHTABLE_HANDLER_EX(ValueType, KeyType, KeyMember, HashTraits<KeyType>::Hash, HashTraits<KeyType>::Test)
-#define RG_HASHTABLE_HANDLER_NT(Name, ValueType, KeyType, KeyMember) \
-    RG_HASHTABLE_HANDLER_EX_N(Name, ValueType, KeyType, KeyMember, HashTraits<KeyType>::Hash, HashTraits<KeyType>::Test)
+#define K_HASHTABLE_HANDLER_EX(ValueType, KeyType, KeyMember, HashFunc, TestFunc) \
+    K_HASHTABLE_HANDLER_EX_N(HashHandler, ValueType, KeyType, KeyMember, HashFunc, TestFunc)
+#define K_HASHTABLE_HANDLER(ValueType, KeyMember) \
+    K_HASHTABLE_HANDLER_EX(ValueType, decltype(ValueType::KeyMember), KeyMember, HashTraits<decltype(ValueType::KeyMember)>::Hash, HashTraits<decltype(ValueType::KeyMember)>::Test)
+#define K_HASHTABLE_HANDLER_N(Name, ValueType, KeyMember) \
+    K_HASHTABLE_HANDLER_EX_N(Name, ValueType, decltype(ValueType::KeyMember), KeyMember, HashTraits<decltype(ValueType::KeyMember)>::Hash, HashTraits<decltype(ValueType::KeyMember)>::Test)
+#define K_HASHTABLE_HANDLER_T(ValueType, KeyType, KeyMember) \
+    K_HASHTABLE_HANDLER_EX(ValueType, KeyType, KeyMember, HashTraits<KeyType>::Hash, HashTraits<KeyType>::Test)
+#define K_HASHTABLE_HANDLER_NT(Name, ValueType, KeyType, KeyMember) \
+    K_HASHTABLE_HANDLER_EX_N(Name, ValueType, KeyType, KeyMember, HashTraits<KeyType>::Hash, HashTraits<KeyType>::Test)
 
 template <typename KeyType, typename ValueType>
 class HashMap {
@@ -3307,7 +3251,7 @@ public:
         KeyType key;
         ValueType value;
 
-        RG_HASHTABLE_HANDLER(Bucket, key);
+        K_HASHTABLE_HANDLER(Bucket, key);
     };
 
     HashTable<KeyType, Bucket> table;
@@ -3346,15 +3290,15 @@ public:
         return table_it;
     }
 
-    ValueType *TrySet(const KeyType &key, const ValueType &value, bool *out_inserted = nullptr)
+    ValueType *InsertOrGet(const KeyType &key, const ValueType &value, bool *out_inserted = nullptr)
     {
-        Bucket *ptr = table.TrySet({ key, value }, out_inserted);
+        Bucket *ptr = table.InsertOrGet({ key, value }, out_inserted);
         return &ptr->value;
     }
-    Bucket *TrySetDefault(const KeyType &key, bool *out_inserted = nullptr)
+    Bucket *InsertOrGetDefault(const KeyType &key, bool *out_inserted = nullptr)
     {
         bool inserted;
-        Bucket *ptr = table.TrySetDefault(key, &inserted);
+        Bucket *ptr = table.InsertOrGetDefault(key, &inserted);
 
         if (inserted) {
             ptr->key = key;
@@ -3417,14 +3361,23 @@ public:
         { return table.FindValue(value, default_value); }
 
     ValueType *Set(const ValueType &value) { return table.Set(value); }
-    ValueType *TrySet(const ValueType &value, bool *out_inserted = nullptr)
-        { return table.TrySet(value, out_inserted); }
+
+    ValueType *InsertOrGet(const ValueType &value, bool *out_inserted = nullptr)
+        { return table.InsertOrGet(value, out_inserted); }
+    bool InsertOrFail(const ValueType &value)
+    {
+        bool inserted;
+        InsertOrGet(value, &inserted);
+        return inserted;
+    }
 
     void Remove(ValueType *it) { table.Remove(it); }
     template <typename T = ValueType>
     void Remove(const T &value) { Remove(Find(value)); }
 
     void Trim() { table.Trim(); }
+
+private:
 };
 
 // XXX: Switch to perfect hashing later on
@@ -3436,13 +3389,13 @@ public:
         ValueType value;
     };
 
-    size_t used[(N + (RG_SIZE(size_t) * 8) - 1) / RG_SIZE(size_t)] = {};
+    size_t used[(N + (K_SIZE(size_t) * 8) - 1) / K_SIZE(size_t)] = {};
     Bucket data[N] = {};
     Size count = 0;
 
     constexpr ConstMap(std::initializer_list<Bucket> l)
     {
-        RG_CRITICAL(l.size() <= N, "ConstMap<%1> cannot be store %2 values", N, l.size());
+        K_CRITICAL(l.size() <= N, "ConstMap<%1> cannot be store %2 values", N, l.size());
 
         for (const Bucket &it: l) {
             Bucket *bucket = Insert(it.key);
@@ -3516,11 +3469,11 @@ private:
 
     constexpr void MarkUsed(Size idx)
     {
-        used[idx / (RG_SIZE(size_t) * 8)] |= (1ull << (idx % (RG_SIZE(size_t) * 8)));
+        used[idx / (K_SIZE(size_t) * 8)] |= (1ull << (idx % (K_SIZE(size_t) * 8)));
     }
     constexpr bool IsEmpty(Size idx) const
     {
-        bool empty = !(used[idx / (RG_SIZE(size_t) * 8)] & (1ull << (idx % (RG_SIZE(size_t) * 8))));
+        bool empty = !(used[idx / (K_SIZE(size_t) * 8)] & (1ull << (idx % (K_SIZE(size_t) * 8))));
         return empty;
     }
 
@@ -3537,7 +3490,7 @@ private:
 union LocalDate {
     int32_t value;
     struct {
-#if defined(RG_BIG_ENDIAN)
+#if defined(K_BIG_ENDIAN)
         int16_t year;
         int8_t month;
         int8_t day;
@@ -3549,12 +3502,12 @@ union LocalDate {
     } st;
 
     LocalDate() = default;
-#if defined(RG_BIG_ENDIAN)
+#if defined(K_BIG_ENDIAN)
     LocalDate(int16_t year, int8_t month, int8_t day)
-        : st({ year, month, day }) { RG_ASSERT(IsValid()); }
+        : st({ year, month, day }) { K_ASSERT(IsValid()); }
 #else
     LocalDate(int16_t year, int8_t month, int8_t day)
-        : st({ day, month, year }) { RG_ASSERT(IsValid()); }
+        : st({ day, month, year }) { K_ASSERT(IsValid()); }
 #endif
 
     static inline bool IsLeapYear(int16_t year)
@@ -3651,6 +3604,13 @@ static inline int64_t GetClockCounter()
     int64_t counter = ((int64_t)counter_high << 32) | counter_low;
     return counter;
 }
+#elif defined(__aarch64__)
+static inline int64_t GetClockCounter()
+{
+    uint64_t counter;
+    __asm__ __volatile__ ("mrs %0, cntvct_el0" : "=r" (counter));
+    return counter;
+}
 #endif
 
 struct TimeSpec {
@@ -3676,10 +3636,11 @@ int64_t ComposeTimeUTC(const TimeSpec &spec);
 // ------------------------------------------------------------------------
 
 enum class FmtType {
-    Str1,
-    Str2,
-    Buffer,
+    Str,
+    PadStr,
+    RepeatStr,
     Char,
+    Buffer,
     Custom,
     Bool,
     Integer,
@@ -3690,15 +3651,19 @@ enum class FmtType {
     Octal,
     BigHex,
     SmallHex,
+    BigBytes,
+    SmallBytes,
     MemorySize,
     DiskSize,
     Date,
     TimeISO,
     TimeNice,
-    Random,
+    List,
     FlagNames,
     FlagOptions,
-    Span
+    Random,
+    SafeStr,
+    SafeChar
 };
 
 template <typename T>
@@ -3733,7 +3698,7 @@ public:
     template <typename T>
     explicit FmtCustom(const T &obj)
     {
-        static_assert(RG_SIZE(*this) <= RG_SIZE(raw));
+        static_assert(K_SIZE(*this) <= K_SIZE(raw));
         new (raw) Concrete<T>(&obj, &FmtTraits<T>::Format);
     }
 
@@ -3748,14 +3713,18 @@ class FmtArg {
 public:
     FmtType type;
     union {
-        const char *str1;
-        Span<const char> str2;
+        Span<const char> str;
+        struct {
+            const char *str;
+            int count;
+        } repeat;
         char buf[32];
         char ch;
         FmtCustom custom;
         bool b;
         int64_t i;
         uint64_t u;
+        Span<const uint8_t> hex;
         struct {
             float value;
             int min_prec;
@@ -3783,68 +3752,123 @@ public:
                 Span<const struct OptionDesc> options;
             } u;
             const char *separator;
-        } flags;
-
-        struct {
-            FmtType type;
-            int type_len;
-            const void *ptr;
-            Size len;
-            const char *separator;
-        } span;
+        } list;
     } u;
 
-    int repeat = 1;
-    int pad_len = 0;
-    char pad_char = 0;
+    int pad = 0;
+    char padding = 0;
 
     FmtArg() = default;
-    FmtArg(std::nullptr_t) : type(FmtType::Str1) { u.str1 = "(null)"; }
-    FmtArg(const char *str) : type(FmtType::Str1) { u.str1 = str ? str : "(null)"; }
-    FmtArg(Span<const char> str) : type(FmtType::Str2) { u.str2 = str; }
-    FmtArg(char c) : type(FmtType::Char) { u.ch = c; }
-    FmtArg(const FmtCustom &custom) : type(FmtType::Custom) { u.custom = custom; }
-    FmtArg(bool b) : type(FmtType::Bool) { u.b = b; }
-    FmtArg(unsigned char i)  : type(FmtType::Unsigned) { u.u = i; }
-    FmtArg(short i) : type(FmtType::Integer) { u.i = i; }
-    FmtArg(unsigned short i) : type(FmtType::Unsigned) { u.u = i; }
-    FmtArg(int i) : type(FmtType::Integer) { u.i = i; }
-    FmtArg(unsigned int i) : type(FmtType::Unsigned) { u.u = i; }
-    FmtArg(long i) : type(FmtType::Integer) { u.i = i; }
-    FmtArg(unsigned long i) : type(FmtType::Unsigned) { u.u = i; }
-    FmtArg(long long i) : type(FmtType::Integer) { u.i = i; }
-    FmtArg(unsigned long long i) : type(FmtType::Unsigned) { u.u = i; }
-    FmtArg(float f) : type(FmtType::Float) { u.f = { f, 0, INT_MAX }; }
-    FmtArg(double d) : type(FmtType::Double) { u.d = { d, 0, INT_MAX }; }
-    FmtArg(const void *ptr) : type(FmtType::BigHex) { u.u = (uint64_t)ptr; }
-    FmtArg(const LocalDate &date) : type(FmtType::Date) { u.date = date; }
-
-    FmtArg &Repeat(int new_repeat) { repeat = new_repeat; return *this; }
-    FmtArg &Pad(int len, char c = ' ') { pad_char = c; pad_len = len; return *this; }
-    FmtArg &Pad0(int len) { return Pad(len, '0'); }
+    FmtArg(const FmtArg &other) = default;
+    FmtArg(std::nullptr_t) : FmtArg(FmtType::Str) { u.str = "(null)"; }
+    FmtArg(const char *str) : FmtArg(FmtType::Str) { u.str = str ? str : "(null)"; }
+    FmtArg(Span<const char> str) : FmtArg(FmtType::Str) { u.str = str; }
+    FmtArg(char c) : FmtArg(FmtType::Char) { u.ch = c; }
+    FmtArg(const FmtCustom &custom) : FmtArg(FmtType::Custom) { u.custom = custom; }
+    FmtArg(bool b) : FmtArg(FmtType::Bool) { u.b = b; }
+    FmtArg(unsigned char i) : FmtArg(FmtType::Unsigned) { u.u = i; }
+    FmtArg(short i) : FmtArg(FmtType::Integer) { u.i = i; }
+    FmtArg(unsigned short i) : FmtArg(FmtType::Unsigned) { u.u = i; }
+    FmtArg(int i) : FmtArg(FmtType::Integer) { u.i = i; }
+    FmtArg(unsigned int i) : FmtArg(FmtType::Unsigned) { u.u = i; }
+    FmtArg(long i) : FmtArg(FmtType::Integer) { u.i = i; }
+    FmtArg(unsigned long i) : FmtArg(FmtType::Unsigned) { u.u = i; }
+    FmtArg(long long i) : FmtArg(FmtType::Integer) { u.i = i; }
+    FmtArg(unsigned long long i) : FmtArg(FmtType::Unsigned) { u.u = i; }
+    FmtArg(float f) : FmtArg(FmtType::Float) { u.f = { f, 0, INT_MAX }; }
+    FmtArg(double d) : FmtArg(FmtType::Double) { u.d = { d, 0, INT_MAX }; }
+    FmtArg(const void *ptr) : FmtArg(FmtType::BigHex) { u.u = (uint64_t)ptr; }
+    FmtArg(const LocalDate &date) : FmtArg(FmtType::Date) { u.date = date; }
+
+protected:
+    FmtArg(FmtType type) : type(type) {}
+};
+
+class FmtSafe: public FmtArg {
+public:
+    FmtSafe() = default;
+    FmtSafe(FmtArg arg) : FmtArg(arg) {}
+    FmtSafe(std::nullptr_t) : FmtArg(FmtType::Str) { u.str = "(null)"; }
+    FmtSafe(const char *str) : FmtArg(FmtType::SafeStr) { u.str = str ? str : "(null)"; } // safe
+    FmtSafe(Span<const char> str) : FmtArg(FmtType::SafeStr) { u.str = str; } // safe
+    FmtSafe(char c) : FmtArg(FmtType::SafeChar) { u.ch = c; } // safe
+    FmtSafe(const FmtCustom &custom) : FmtArg(custom) {}
+    FmtSafe(bool b) : FmtArg(b) {}
+    FmtSafe(unsigned char i) : FmtArg(i) {}
+    FmtSafe(short i) : FmtArg(i) {}
+    FmtSafe(unsigned short i) : FmtArg(i) {}
+    FmtSafe(int i) : FmtArg(i) {}
+    FmtSafe(unsigned int i) : FmtArg(i) {}
+    FmtSafe(long i) : FmtArg(i) {}
+    FmtSafe(unsigned long i) : FmtArg(i) {}
+    FmtSafe(long long i) : FmtArg(i) {}
+    FmtSafe(unsigned long long i) : FmtArg(i) {}
+    FmtSafe(float f) : FmtArg(f) {}
+    FmtSafe(double d) : FmtArg(d) {}
+    FmtSafe(const void *ptr) : FmtArg(ptr) {}
+    FmtSafe(const LocalDate &date) : FmtArg(date) {}
 };
 
-static inline FmtArg FmtBin(uint64_t u)
+static inline FmtArg FmtInt(long long i, int pad = 0, char padding = '0')
+{
+    FmtArg arg;
+    arg.type = FmtType::Integer;
+    arg.u.i = i;
+    arg.pad = pad;
+    arg.padding = padding;
+    return arg;
+}
+static inline FmtArg FmtInt(unsigned long long u, int pad = 0, char padding = '0')
+{
+    FmtArg arg;
+    arg.type = FmtType::Unsigned;
+    arg.u.u = u;
+    arg.pad = pad;
+    arg.padding = padding;
+    return arg;
+}
+static inline FmtArg FmtInt(unsigned char u, int pad = 0, char padding = '0') { return FmtInt((unsigned long long)u, pad, padding); }
+static inline FmtArg FmtInt(short i, int pad = 0, char padding = '0') { return FmtInt((long long)i, pad, padding); }
+static inline FmtArg FmtInt(unsigned short u, int pad = 0, char padding = '0') { return FmtInt((unsigned long long)u, pad, padding); }
+static inline FmtArg FmtInt(int i, int pad = 0, char padding = '0') { return FmtInt((long long)i, pad, padding); }
+static inline FmtArg FmtInt(unsigned int u, int pad = 0, char padding = '0') { return FmtInt((unsigned long long)u, pad, padding); }
+static inline FmtArg FmtInt(long i, int pad = 0, char padding = '0') { return FmtInt((long long)i, pad, padding); }
+static inline FmtArg FmtInt(unsigned long u, int pad = 0, char padding = '0') { return FmtInt((unsigned long long)u, pad, padding); }
+
+static inline FmtArg FmtBin(uint64_t u, int pad = 0, char padding = '0')
 {
     FmtArg arg;
     arg.type = FmtType::Binary;
     arg.u.u = u;
+    arg.pad = pad;
+    arg.padding = padding;
     return arg;
 }
-static inline FmtArg FmtOctal(uint64_t u)
+static inline FmtArg FmtOctal(uint64_t u, int pad = 0, char padding = '0')
 {
     FmtArg arg;
     arg.type = FmtType::Octal;
     arg.u.u = u;
+    arg.pad = pad;
+    arg.padding = padding;
     return arg;
 }
-static inline FmtArg FmtHex(uint64_t u, FmtType type = FmtType::BigHex)
+static inline FmtArg FmtHex(uint64_t u, int pad = 0, char padding = '0')
 {
-    RG_ASSERT(type == FmtType::BigHex || type == FmtType::SmallHex);
-
     FmtArg arg;
-    arg.type = type;
+    arg.type = FmtType::BigHex;
     arg.u.u = u;
+    arg.pad = pad;
+    arg.padding = padding;
+    return arg;
+}
+static inline FmtArg FmtHexSmall(uint64_t u, int pad = 0, char padding = '0')
+{
+    FmtArg arg;
+    arg.type = FmtType::SmallHex;
+    arg.u.u = u;
+    arg.pad = pad;
+    arg.padding = padding;
     return arg;
 }
 
@@ -3905,56 +3929,77 @@ static inline FmtArg FmtTimeNice(TimeSpec spec, bool ms = false)
     return arg;
 }
 
-static inline FmtArg FmtRandom(Size len, const char *chars = nullptr)
+static inline FmtArg FmtList(Span<const char *const> names, const char *sep = ", ")
 {
-    RG_ASSERT(len < 256);
-    len = std::min(len, (Size)256);
-
     FmtArg arg;
-    arg.type = FmtType::Random;
-    arg.u.random.len = len;
-    arg.u.random.chars = chars;
+    arg.type = FmtType::List;
+    arg.u.list.u.names = names;
+    arg.u.list.separator = sep;
     return arg;
 }
-
 static inline FmtArg FmtFlags(uint64_t flags, Span<const char *const> names, const char *sep = ", ")
 {
     FmtArg arg;
     arg.type = FmtType::FlagNames;
-    arg.u.flags.flags = flags & ((1ull << names.len) - 1);
-    arg.u.flags.u.names = names;
-    arg.u.flags.separator = sep;
+    arg.u.list.flags = flags & ((1ull << names.len) - 1);
+    arg.u.list.u.names = names;
+    arg.u.list.separator = sep;
     return arg;
 }
-
 static inline FmtArg FmtFlags(uint64_t flags, Span<const struct OptionDesc> options, const char *sep = ", ")
 {
     FmtArg arg;
     arg.type = FmtType::FlagOptions;
-    arg.u.flags.flags = flags & ((1ull << options.len) - 1);
-    arg.u.flags.u.options = options;
-    arg.u.flags.separator = sep;
+    arg.u.list.flags = flags & ((1ull << options.len) - 1);
+    arg.u.list.u.options = options;
+    arg.u.list.separator = sep;
     return arg;
 }
 
-template <typename T>
-FmtArg FmtSpan(Span<T> arr, FmtType type, const char *sep = ", ")
+static inline FmtArg FmtPad(Span<const char> str, int pad, char padding = ' ')
 {
     FmtArg arg;
-    arg.type = FmtType::Span;
-    arg.u.span.type = type;
-    arg.u.span.type_len = RG_SIZE(T);
-    arg.u.span.ptr = (const void *)arr.ptr;
-    arg.u.span.len = arr.len;
-    arg.u.span.separator = sep;
+    arg.type = FmtType::PadStr;
+    arg.u.str = str;
+    arg.pad = pad;
+    arg.padding = padding;
+    return arg;
+}
+static inline FmtArg FmtRepeat(const char *str, int count)
+{
+    FmtArg arg;
+    arg.type = FmtType::RepeatStr;
+    arg.u.repeat.str = str;
+    arg.u.repeat.count = count;
+    return arg;
+}
+
+static inline FmtArg FmtHex(Span<const uint8_t> buf)
+{
+    FmtArg arg;
+    arg.type = FmtType::BigBytes;
+    arg.u.hex = buf;
+    return arg;
+}
+static inline FmtArg FmtHexSmall(Span<const uint8_t> buf)
+{
+    FmtArg arg;
+    arg.type = FmtType::SmallBytes;
+    arg.u.hex = buf;
+    return arg;
+}
+
+static inline FmtArg FmtRandom(Size len, const char *chars = nullptr)
+{
+    K_ASSERT(len < 256);
+    len = std::min(len, (Size)256);
+
+    FmtArg arg;
+    arg.type = FmtType::Random;
+    arg.u.random.len = len;
+    arg.u.random.chars = chars;
     return arg;
 }
-template <typename T>
-FmtArg FmtSpan(Span<T> arr, const char *sep = ", ") { return FmtSpan(arr, FmtArg(T()).type, sep); }
-template <typename T, Size N>
-FmtArg FmtSpan(T (&arr)[N], FmtType type, const char *sep = ", ") { return FmtSpan(MakeSpan(arr), type, sep); }
-template <typename T, Size N>
-FmtArg FmtSpan(T (&arr)[N], const char *sep = ", ") { return FmtSpan(MakeSpan(arr), sep); }
 
 class FmtUpperAscii {
     Span<const char> str;
@@ -3976,23 +4021,34 @@ public:
     operator FmtArg() const { return FmtCustom(*this); }
 };
 
-class FmtEscape {
+class FmtUrlSafe {
+    Span<const char> str;
+    const char *passthrough;
+
+public:
+    FmtUrlSafe(Span<const char> str, const char *passthrough)
+        : str(str), passthrough(passthrough) {}
+
+    void Format(FunctionRef<void(Span<const char>)> append) const;
+    operator FmtArg() const { return FmtCustom(*this); }
+};
+
+class FmtHtmlSafe {
     Span<const char> str;
 
 public:
-    FmtEscape(Span<const char> str) : str(str) {}
+    FmtHtmlSafe(Span<const char> str) : str(str) {}
 
     void Format(FunctionRef<void(Span<const char>)> append) const;
     operator FmtArg() const { return FmtCustom(*this); }
 };
 
-class FmtUrlSafe {
+class FmtEscape {
     Span<const char> str;
-    const char *passthrough;
+    char quote;
 
 public:
-    FmtUrlSafe(Span<const char> str, const char *passthrough)
-        : str(str), passthrough(passthrough) {}
+    FmtEscape(Span<const char> str, char quote) : str(str), quote(quote) {}
 
     void Format(FunctionRef<void(Span<const char>)> append) const;
     operator FmtArg() const { return FmtCustom(*this); }
@@ -4097,11 +4153,11 @@ static inline void Log(LogLevel level, const char *ctx, const char *fmt)
 template <typename... Args>
 static inline void Log(LogLevel level, const char *ctx, const char *fmt, Args... args)
 {
-    const FmtArg fmt_args[] = { FmtArg(args)... };
+    const FmtArg fmt_args[] = { FmtSafe(args)... };
     LogFmt(level, ctx, fmt, fmt_args);
 }
 
-#if defined(RG_DEBUG) && __cplusplus >= 202002L && __has_include(<source_location>)
+#if defined(K_DEBUG) && __cplusplus >= 202002L && __has_include(<source_location>)
     struct LogContext {
         const char *fmt;
         char str[56] = {};
@@ -4157,7 +4213,7 @@ static inline void Log(LogLevel level, const char *ctx, const char *fmt, Args...
     template <typename... Args>
     static inline void LogError(LogContext ctx, Args... args) { Log(LogLevel::Error, ctx.str, ctx.fmt, args...); }
 #else
-    #if defined(RG_DEBUG)
+    #if defined(K_DEBUG)
         template <typename... Args>
         static inline void LogDebug(Args... args) { Log(LogLevel::Debug, "Debug: ", args...); }
     #else
@@ -4167,9 +4223,9 @@ static inline void Log(LogLevel level, const char *ctx, const char *fmt, Args...
     template <typename... Args>
     static inline void LogInfo(Args... args) { Log(LogLevel::Info, nullptr, args...); }
     template <typename... Args>
-    static inline void LogWarning(Args... args) { Log(LogLevel::Warning, "Warning: ", args...); }
+    static inline void LogWarning(Args... args) { Log(LogLevel::Warning, T("Warning: "), args...); }
     template <typename... Args>
-    static inline void LogError(Args... args) { Log(LogLevel::Error, "Error: ", args...); }
+    static inline void LogError(Args... args) { Log(LogLevel::Error, T("Error: "), args...); }
 #endif
 
 void SetLogHandler(const std::function<LogFunc> &func, bool vt100);
@@ -4202,7 +4258,7 @@ struct ProgressInfo {
 typedef void ProgressFunc(Span<const ProgressInfo> states);
 
 class ProgressHandle {
-    char text[RG_PROGRESS_TEXT_SIZE] = {};
+    char text[K_PROGRESS_TEXT_SIZE] = {};
 
     std::atomic<ProgressNode *> node = nullptr;
 
@@ -4222,7 +4278,7 @@ public:
     template<typename... Args>
     void SetFmt(int64_t value, int64_t min, int64_t max, const char *fmt, Args... args)
     {
-        char buf[RG_PROGRESS_TEXT_SIZE];
+        char buf[K_PROGRESS_TEXT_SIZE];
         Fmt(buf, fmt, args...);
 
         Set(value, min, max, (const char *)buf);
@@ -4240,7 +4296,7 @@ public:
 
 private:
     ProgressNode *AcquireNode();
-    void CopyText(Span<const char> text, char out[RG_PROGRESS_TEXT_SIZE]);
+    void CopyText(Span<const char> text, char out[K_PROGRESS_TEXT_SIZE]);
 };
 
 void SetProgressHandler(const std::function<ProgressFunc> &func);
@@ -4253,15 +4309,15 @@ void DefaultProgressHandler(Span<const ProgressInfo> bars);
 // ------------------------------------------------------------------------
 
 #if defined(_WIN32)
-    #define RG_PATH_SEPARATORS "\\/"
-    #define RG_PATH_DELIMITER ';'
-    #define RG_EXECUTABLE_EXTENSION ".exe"
-    #define RG_SHARED_LIBRARY_EXTENSION ".dll"
+    #define K_PATH_SEPARATORS "\\/"
+    #define K_PATH_DELIMITER ';'
+    #define K_EXECUTABLE_EXTENSION ".exe"
+    #define K_SHARED_LIBRARY_EXTENSION ".dll"
 #else
-    #define RG_PATH_SEPARATORS "/"
-    #define RG_PATH_DELIMITER ':'
-    #define RG_EXECUTABLE_EXTENSION ""
-    #define RG_SHARED_LIBRARY_EXTENSION ".so"
+    #define K_PATH_SEPARATORS "/"
+    #define K_PATH_DELIMITER ':'
+    #define K_EXECUTABLE_EXTENSION ""
+    #define K_SHARED_LIBRARY_EXTENSION ".so"
 #endif
 
 #if defined(_WIN32)
@@ -4308,11 +4364,11 @@ static const char *const CompressionTypeExtensions[] = {
 Span<const char> GetPathDirectory(Span<const char> filename);
 Span<const char> GetPathExtension(Span<const char> filename,
                                   CompressionType *out_compression_type = nullptr);
-CompressionType GetPathCompression(Span<const char> filename);
 
 enum class NormalizeFlag {
     EndWithSeparator = 1 << 0,
-    ForceSlash = 1 << 1
+    ForceSlash = 1 << 1,
+    NoExpansion = 1 << 2
 };
 
 Span<char> NormalizePath(Span<const char> path, Span<const char> root_directory, unsigned int flags, Allocator *alloc);
@@ -4326,6 +4382,7 @@ static inline Span<char> NormalizePath(Span<const char> path, Allocator *alloc)
 bool PathIsAbsolute(const char *path);
 bool PathIsAbsolute(Span<const char> path);
 bool PathContainsDotDot(const char *path);
+bool PathContainsDotDot(Span<const char> path);
 
 enum class StatFlag {
     SilentMissing = 1 << 0,
@@ -4398,7 +4455,20 @@ static inline RenameResult RenameFile(const char *src_filename, const char *dest
     { return RenameFile(src_filename, dest_filename, 0, flags); }
 
 bool ResizeFile(int fd, const char *filename, int64_t len);
-bool SetFileMetaData(int fd, const char *filename, int64_t mtime, int64_t ctime, uint32_t mode);
+
+#if !defined(_WIN32)
+bool SetFileMode(int fd, const char *filename, uint32_t mode);
+static inline bool SetFileMode(const char *filename, uint32_t mode)
+    { return SetFileMode(-1, filename, mode); }
+
+bool SetFileOwner(int fd, const char *filename, uint32_t uid, uint32_t gid);
+static inline bool SetFileOwner(const char *filename, uint32_t uid, uint32_t gid)
+    { return SetFileOwner(-1, filename, uid, gid); }
+#endif
+
+bool SetFileTimes(int fd, const char *filename, int64_t mtime, int64_t ctime);
+static inline bool SetFileTimes(const char *filename, int64_t mtime, int64_t ctime)
+    { return SetFileTimes(-1, filename, mtime, ctime); }
 
 struct VolumeInfo {
     int64_t total;
@@ -4523,7 +4593,7 @@ void CloseHandleSafe(void **handle_ptr); // HANDLE
 #else
 void SetSignalHandler(int signal, void (*func)(int), struct sigaction *prev = nullptr);
 
-bool CreatePipe(int pfd[2]);
+bool CreatePipe(bool block, int out_pfd[2]);
 void CloseDescriptorSafe(int *fd_ptr);
 #endif
 
@@ -4547,7 +4617,7 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                         HeapArray<uint8_t> *out_buf, int *out_code);
 
 // Simple variants
-static inline bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,int *out_code)
+static inline bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info, int *out_code)
     { return ExecuteCommandLine(cmd_line, info, {}, {}, out_code); }
 static inline bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                                       Span<const uint8_t> in_buf,
@@ -4587,18 +4657,34 @@ void WaitDelay(int64_t delay);
 
 #if !defined(__wasi__)
 
-enum class WaitForResult {
-    Exit,
+enum class WaitResult {
+    Ready,
+    Timeout,
     Interrupt,
     Message,
-    Timeout
+    Exit
+};
+
+struct WaitSource {
+#if defined(_WIN32)
+    // Special-cased on Windows: set to NULL to wait for the Win32 message pump too
+    void *handle; // HANDLE
+    int timeout;
+#else
+    int fd;
+    int timeout;
+    int events = 0;
+#endif
 };
 
-// After WaitForInterrupt() has been called once (even with timeout 0), a few
-// signals (such as SIGINT, SIGHUP) and their Windows equivalent will be permanently ignored.
-// Beware, on Unix platforms, this may not work correctly if not called from the main thread.
-WaitForResult WaitForInterrupt(int64_t timeout = -1);
-void SignalWaitFor();
+// After WaitEvents() has been called once (even with timeout 0), a few signals (such as SIGINT, SIGHUP)
+// and their Windows equivalent will be permanently ignored.
+// Only the main thread (running main) will get WaitResult::Message events (and SIGUSR1).
+WaitResult WaitEvents(Span<const WaitSource> sources, int64_t timeout, uint64_t *out_ready = nullptr);
+WaitResult WaitEvents(int64_t timeout);
+
+void PostWaitMessage();
+void PostTerminate();
 
 #endif
 
@@ -4613,19 +4699,72 @@ bool DropRootIdentity();
 bool NotifySystemd();
 #endif
 
-#define RG_RESTART_EINTR(CallCode, ErrorCond) \
+#define K_RESTART_EINTR(CallCode, ErrorCond) \
     ([&]() { \
         decltype(CallCode) ret; \
         while ((ret = (CallCode)) ErrorCond && errno == EINTR); \
         return ret; \
     })()
 
+class InitHelper {
+public:
+    const char *name;
+    InitHelper *next = nullptr;
+
+    InitHelper(const char *name);
+    virtual void Run() = 0;
+};
+
+class FinalizeHelper {
+public:
+    const char *name;
+    FinalizeHelper *next = nullptr;
+
+    FinalizeHelper(const char *name);
+    virtual void Run() = 0;
+};
+
+#define K_INIT_(ClassName, Name) \
+    class ClassName: public InitHelper { \
+    public: \
+        ClassName(): InitHelper(Name) {} \
+        void Run() override; \
+    }; \
+    static ClassName K_UNIQUE_NAME(init); \
+    void ClassName::Run()
+#define K_INIT(Name) K_INIT_(K_CONCAT(K_UNIQUE_NAME(InitHelper), Name), K_STRINGIFY(Name))
+
+#define K_FINALIZE_(ClassName, Name) \
+    class ClassName: public FinalizeHelper { \
+    public: \
+        ClassName(): FinalizeHelper(Name) {} \
+        void Run() override; \
+    }; \
+    static ClassName K_UNIQUE_NAME(finalize); \
+    void ClassName::Run()
+#define K_FINALIZE(Name) K_FINALIZE_(K_CONCAT(K_UNIQUE_NAME(FinalizeHelper), Name), K_STRINGIFY(Name))
+
+#define K_EXIT_(ClassName) \
+    class ClassName { \
+    public: \
+        ~ClassName(); \
+    }; \
+    static ClassName K_UNIQUE_NAME(exit); \
+    ClassName::~ClassName()
+#define K_EXIT(Name) K_EXIT_(K_CONCAT(K_UNIQUE_NAME(ExitHelper), Name))
+
 void InitApp();
+void ExitApp();
+
 int Main(int argc, char **argv);
 
 static inline int RunApp(int argc, char **argv)
 {
+    K_CRITICAL(argc >= 1, "First argument is missing");
+
     InitApp();
+    K_DEFER { ExitApp(); };
+
     return Main(argc, argv);
 }
 
@@ -4661,10 +4800,10 @@ enum class ParseFlag {
     Validate = 1 << 1,
     End = 1 << 2
 };
-#define RG_DEFAULT_PARSE_FLAGS ((int)ParseFlag::Log | (int)ParseFlag::Validate | (int)ParseFlag::End)
+#define K_DEFAULT_PARSE_FLAGS ((int)ParseFlag::Log | (int)ParseFlag::Validate | (int)ParseFlag::End)
 
 template <typename T>
-bool ParseInt(Span<const char> str, T *out_value, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
+bool ParseInt(Span<const char> str, T *out_value, unsigned int flags = K_DEFAULT_PARSE_FLAGS,
               Span<const char> *out_remaining = nullptr)
 {
     if (!str.len) [[unlikely]] {
@@ -4723,20 +4862,20 @@ overflow:
     return false;
 }
 
-bool ParseBool(Span<const char> str, bool *out_value, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
+bool ParseBool(Span<const char> str, bool *out_value, unsigned int flags = K_DEFAULT_PARSE_FLAGS,
                Span<const char> *out_remaining = nullptr);
 
-bool ParseSize(Span<const char> str, int64_t *out_size, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
+bool ParseSize(Span<const char> str, int64_t *out_size, unsigned int flags = K_DEFAULT_PARSE_FLAGS,
                Span<const char> *out_remaining = nullptr);
-#if RG_SIZE_MAX < INT64_MAX
+#if K_SIZE_MAX < INT64_MAX
 static inline bool ParseSize(Span<const char> str, Size *out_size,
-                             unsigned int flags = RG_DEFAULT_PARSE_FLAGS, Span<const char> *out_remaining = nullptr)
+                             unsigned int flags = K_DEFAULT_PARSE_FLAGS, Span<const char> *out_remaining = nullptr)
 {
     int64_t size = 0;
     if (!ParseSize(str, &size, flags, out_remaining))
         return false;
 
-    if (size > RG_SIZE_MAX) [[unlikely]] {
+    if (size > K_SIZE_MAX) [[unlikely]] {
         if (flags & (int)ParseFlag::Log) {
             LogError("Size value is too high");
         }
@@ -4748,13 +4887,13 @@ static inline bool ParseSize(Span<const char> str, Size *out_size,
 }
 #endif
 
-bool ParseDate(Span<const char> date_str, LocalDate *out_date, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
+bool ParseDate(Span<const char> date_str, LocalDate *out_date, unsigned int flags = K_DEFAULT_PARSE_FLAGS,
                Span<const char> *out_remaining = nullptr);
 
-bool ParseDuration(Span<const char> str, int64_t *out_duration, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
+bool ParseDuration(Span<const char> str, int64_t *out_duration, unsigned int flags = K_DEFAULT_PARSE_FLAGS,
                    Span<const char> *out_remaining = nullptr);
 static inline bool ParseDuration(Span<const char> str, int *out_duration,
-                                 unsigned int flags = RG_DEFAULT_PARSE_FLAGS, Span<const char> *out_remaining = nullptr)
+                                 unsigned int flags = K_DEFAULT_PARSE_FLAGS, Span<const char> *out_remaining = nullptr)
 {
     int64_t duration = 0;
     if (!ParseDuration(str, &duration, flags, out_remaining))
@@ -4772,12 +4911,15 @@ static inline bool ParseDuration(Span<const char> str, int *out_duration,
 }
 
 bool ParseVersion(Span<const char> str, int parts, int multiplier, int64_t *out_duration,
-                  unsigned int flags = RG_DEFAULT_PARSE_FLAGS, Span<const char> *out_remaining = nullptr);
+                  unsigned int flags = K_DEFAULT_PARSE_FLAGS, Span<const char> *out_remaining = nullptr);
 
 // ------------------------------------------------------------------------
 // Random
 // ------------------------------------------------------------------------
 
+void InitChaCha20(uint32_t state[16], const uint8_t key[32], const uint8_t iv[8], const uint8_t counter[8] = nullptr);
+void RunChaCha20(uint32_t state[16], uint8_t out_buf[64]);
+
 void FillRandomSafe(void *buf, Size len);
 static inline void FillRandomSafe(Span<uint8_t> buf) { FillRandomSafe(buf.ptr, buf.len); }
 
@@ -4788,14 +4930,13 @@ public:
     FastRandom();
     FastRandom(uint64_t seed);
 
+    uint64_t Next();
+
     void Fill(void *buf, Size len);
     void Fill(Span<uint8_t> buf) { Fill(buf.ptr, buf.len); }
 
     int GetInt(int min, int max);
     int64_t GetInt64(int64_t min, int64_t max);
-
-private:
-    uint64_t Next();
 };
 
 template <typename T>
@@ -4811,11 +4952,12 @@ public:
     T operator()()
     {
         T value;
-        rng.Fill(&value, RG_SIZE(value));
+        rng.Fill(&value, K_SIZE(value));
         return value;
     }
 };
 
+uint64_t GetRandom();
 int GetRandomInt(int min, int max);
 int64_t GetRandomInt64(int64_t min, int64_t max);
 
@@ -4848,12 +4990,10 @@ bool InitWinsock();
 
 int CreateSocket(SocketType type, int flags);
 
-bool BindIPSocket(int sock, SocketType type, int port);
+bool BindIPSocket(int sock, SocketType type, const char *addr, int port);
 bool BindUnixSocket(int sock, const char *path);
-
-int OpenIPSocket(SocketType type, int port, int flags);
-int OpenUnixSocket(const char *path, int flags);
-int ConnectToUnixSocket(const char *path, int flags);
+bool ConnectIPSocket(int sock, const char *addr, int port);
+bool ConnectUnixSocket(int sock, const char *path);
 
 // Only for sockets on Windows
 void SetDescriptorNonBlock(int fd, bool enable);
@@ -4868,7 +5008,7 @@ void CloseSocket(int fd);
 // ------------------------------------------------------------------------
 
 class Async {
-    RG_DELETE_COPY(Async)
+    K_DELETE_COPY(Async)
 
 #if !defined(__wasi__)
     std::atomic_bool success { true };
@@ -4914,7 +5054,7 @@ class StreamDecoder;
 class StreamEncoder;
 
 class StreamReader {
-    RG_DELETE_COPY(StreamReader)
+    K_DELETE_COPY(StreamReader)
 
     enum class SourceType {
         Memory,
@@ -4962,16 +5102,13 @@ class StreamReader {
 
 public:
     StreamReader() { Close(true); }
-    StreamReader(Span<const uint8_t> buf, const char *filename = nullptr,
-                 CompressionType compression_type = CompressionType::None)
+    StreamReader(Span<const uint8_t> buf, const char *filename, CompressionType compression_type = CompressionType::None)
         : StreamReader() { Open(buf, filename, compression_type); }
-    StreamReader(int fd, const char *filename,
-                 CompressionType compression_type = CompressionType::None)
+    StreamReader(int fd, const char *filename, CompressionType compression_type = CompressionType::None)
         : StreamReader() { Open(fd, filename, compression_type); }
-    StreamReader(const char *filename,
-                 CompressionType compression_type = CompressionType::None)
+    StreamReader(const char *filename, CompressionType compression_type = CompressionType::None)
         : StreamReader() { Open(filename, compression_type); }
-    StreamReader(const std::function<Size(Span<uint8_t>)> &func, const char *filename = nullptr,
+    StreamReader(const std::function<Size(Span<uint8_t>)> &func, const char *filename,
                  CompressionType compression_type = CompressionType::None)
         : StreamReader() { Open(func, filename, compression_type); }
     ~StreamReader() { Close(true); }
@@ -4979,12 +5116,10 @@ public:
     // Call before Open. Takes ownership and deletes the decoder at the end.
     void SetDecoder(StreamDecoder *decoder);
 
-    bool Open(Span<const uint8_t> buf, const char *filename = nullptr,
-              CompressionType compression_type = CompressionType::None);
-    bool Open(int fd, const char *filename,
-              CompressionType compression_type = CompressionType::None);
+    bool Open(Span<const uint8_t> buf, const char *filename, CompressionType compression_type = CompressionType::None);
+    bool Open(int fd, const char *filename, CompressionType compression_type = CompressionType::None);
     OpenResult Open(const char *filename, CompressionType compression_type = CompressionType::None);
-    bool Open(const std::function<Size(Span<uint8_t>)> &func, const char *filename = nullptr,
+    bool Open(const std::function<Size(Span<uint8_t>)> &func, const char *filename,
               CompressionType compression_type = CompressionType::None);
     bool Close() { return Close(false); }
 
@@ -5004,7 +5139,11 @@ public:
     // Thread safe methods
     Size Read(Span<uint8_t> out_buf);
     Size Read(Span<char> out_buf) { return Read(out_buf.As<uint8_t>()); }
-    Size Read(Size buf_len, void *out_buf) { return Read(MakeSpan((uint8_t *)out_buf, buf_len)); }
+
+    // Thread safe methods
+    Size ReadFill(Span<uint8_t> out_buf);
+    Size ReadFill(Span<char> out_buf) { return ReadFill(out_buf.As<uint8_t>()); }
+    Size ReadFill(Size buf_len, void *out_buf) { return ReadFill(MakeSpan((uint8_t *)out_buf, buf_len)); }
 
     Size ReadAll(Size max_len, HeapArray<uint8_t> *out_buf);
     Size ReadAll(Size max_len, HeapArray<char> *out_buf)
@@ -5026,12 +5165,12 @@ private:
 static inline Size ReadFile(const char *filename, Span<uint8_t> out_buf)
 {
     StreamReader st(filename);
-    return st.Read(out_buf);
+    return st.ReadFill(out_buf);
 }
 static inline Size ReadFile(const char *filename, Span<char> out_buf)
 {
     StreamReader st(filename);
-    return st.Read(out_buf);
+    return st.ReadFill(out_buf);
 }
 static inline Size ReadFile(const char *filename, Size max_len, HeapArray<uint8_t> *out_buf)
 {
@@ -5071,16 +5210,16 @@ public:
     StreamDecompressorHelper(CompressionType type, CreateDecompressorFunc *func);
 };
 
-#define RG_REGISTER_DECOMPRESSOR(Type, Cls) \
-    static StreamDecoder *RG_UNIQUE_NAME(CreateDecompressor)(StreamReader *reader, CompressionType type) \
+#define K_REGISTER_DECOMPRESSOR(Type, Cls) \
+    static StreamDecoder *K_UNIQUE_NAME(CreateDecompressor)(StreamReader *reader, CompressionType type) \
     { \
         StreamDecoder *decompressor = new Cls(reader, type); \
         return decompressor; \
     } \
-    static StreamDecompressorHelper RG_UNIQUE_NAME(CreateDecompressorHelper)((Type), RG_UNIQUE_NAME(CreateDecompressor))
+    static StreamDecompressorHelper K_UNIQUE_NAME(CreateDecompressorHelper)((Type), K_UNIQUE_NAME(CreateDecompressor))
 
 class LineReader {
-    RG_DELETE_COPY(LineReader)
+    K_DELETE_COPY(LineReader)
 
     HeapArray<char> buf;
     Span<char> view = {};
@@ -5107,14 +5246,14 @@ public:
 };
 
 enum class StreamWriterFlag {
-    Exclusive = 1 << 0,
-    Atomic = 1 << 1,
-    NoBuffer = 1 << 2,
-    LineBuffer = 1 << 3
+    Exclusive = 1 << 0, // Only for files
+    Atomic = 1 << 1, // Only for files
+    NoBuffer = 1 << 2, // Only for files and descriptors
+    LineBuffer = 1 << 3 // Only for files and descriptors
 };
 
 class StreamWriter {
-    RG_DELETE_COPY(StreamWriter)
+    K_DELETE_COPY(StreamWriter)
 
     enum class DestinationType {
         Memory,
@@ -5167,14 +5306,14 @@ class StreamWriter {
 
 public:
     StreamWriter() { Close(true); }
-    StreamWriter(HeapArray<uint8_t> *mem, const char *filename = nullptr,
+    StreamWriter(HeapArray<uint8_t> *mem, const char *filename, unsigned int flags = 0,
                  CompressionType compression_type = CompressionType::None,
                  CompressionSpeed compression_speed = CompressionSpeed::Default)
-        : StreamWriter() { Open(mem, filename, compression_type, compression_speed); }
-    StreamWriter(HeapArray<char> *mem, const char *filename = nullptr,
+        : StreamWriter() { Open(mem, filename, flags, compression_type, compression_speed); }
+    StreamWriter(HeapArray<char> *mem, const char *filename, unsigned int flags = 0,
                  CompressionType compression_type = CompressionType::None,
                  CompressionSpeed compression_speed = CompressionSpeed::Default)
-        : StreamWriter() { Open(mem, filename, compression_type, compression_speed); }
+        : StreamWriter() { Open(mem, filename, flags, compression_type, compression_speed); }
     StreamWriter(int fd, const char *filename, unsigned int flags = 0,
                  CompressionType compression_type = CompressionType::None,
                  CompressionSpeed compression_speed = CompressionSpeed::Default)
@@ -5183,29 +5322,29 @@ public:
                  CompressionType compression_type = CompressionType::None,
                  CompressionSpeed compression_speed = CompressionSpeed::Default)
         : StreamWriter() { Open(filename, flags, compression_type, compression_speed); }
-    StreamWriter(const std::function<bool(Span<const uint8_t>)> &func, const char *filename = nullptr,
+    StreamWriter(const std::function<bool(Span<const uint8_t>)> &func, const char *filename, unsigned int flags = 0,
                  CompressionType compression_type = CompressionType::None,
                  CompressionSpeed compression_speed = CompressionSpeed::Default)
-        : StreamWriter() { Open(func, filename, compression_type, compression_speed); }
+        : StreamWriter() { Open(func, filename, flags, compression_type, compression_speed); }
     ~StreamWriter() { Close(true); }
 
     // Call before Open. Takes ownership and deletes the encoder at the end.
     void SetEncoder(StreamEncoder *encoder);
 
-    bool Open(HeapArray<uint8_t> *mem, const char *filename = nullptr,
+    bool Open(HeapArray<uint8_t> *mem, const char *filename, unsigned int flags = 0,
               CompressionType compression_type = CompressionType::None,
               CompressionSpeed compression_speed = CompressionSpeed::Default);
-    bool Open(HeapArray<char> *mem, const char *filename = nullptr,
+    bool Open(HeapArray<char> *mem, const char *filename, unsigned int flags = 0,
               CompressionType compression_type = CompressionType::None,
               CompressionSpeed compression_speed = CompressionSpeed::Default)
-        { return Open((HeapArray<uint8_t> *)mem, filename, compression_type, compression_speed); }
+        { return Open((HeapArray<uint8_t> *)mem, filename, flags, compression_type, compression_speed); }
     bool Open(int fd, const char *filename, unsigned int flags = 0,
               CompressionType compression_type = CompressionType::None,
               CompressionSpeed compression_speed = CompressionSpeed::Default);
     bool Open(const char *filename, unsigned int flags = 0,
               CompressionType compression_type = CompressionType::None,
               CompressionSpeed compression_speed = CompressionSpeed::Default);
-    bool Open(const std::function<bool(Span<const uint8_t>)> &func, const char *filename = nullptr,
+    bool Open(const std::function<bool(Span<const uint8_t>)> &func, const char *filename, unsigned int flags = 0,
               CompressionType compression_type = CompressionType::None,
               CompressionSpeed compression_speed = CompressionSpeed::Default);
     bool Close() { return Close(false); }
@@ -5283,13 +5422,13 @@ public:
     StreamCompressorHelper(CompressionType type, CreateCompressorFunc *func);
 };
 
-#define RG_REGISTER_COMPRESSOR(Type, Cls) \
-    static StreamEncoder *RG_UNIQUE_NAME(CreateCompressor)(StreamWriter *writer, CompressionType type, CompressionSpeed speed) \
+#define K_REGISTER_COMPRESSOR(Type, Cls) \
+    static StreamEncoder *K_UNIQUE_NAME(CreateCompressor)(StreamWriter *writer, CompressionType type, CompressionSpeed speed) \
     { \
         StreamEncoder *compressor = new Cls(writer, type, speed); \
         return compressor; \
     } \
-    static StreamCompressorHelper RG_UNIQUE_NAME(CreateCompressorHelper)((Type), RG_UNIQUE_NAME(CreateCompressor))
+    static StreamCompressorHelper K_UNIQUE_NAME(CreateCompressorHelper)((Type), K_UNIQUE_NAME(CreateCompressor))
 
 bool SpliceStream(StreamReader *reader, int64_t max_len, StreamWriter *writer, Span<uint8_t> buf,
                   FunctionRef<void(int64_t, int64_t)> progress = [](int64_t, int64_t) {});
@@ -5322,7 +5461,7 @@ struct IniProperty {
 };
 
 class IniParser {
-    RG_DELETE_COPY(IniParser)
+    K_DELETE_COPY(IniParser)
 
     HeapArray<char> current_section;
 
@@ -5362,7 +5501,7 @@ struct AssetInfo {
     CompressionType compression_type;
     Span<const uint8_t> data;
 
-    RG_HASHTABLE_HANDLER(AssetInfo, name);
+    K_HASHTABLE_HANDLER(AssetInfo, name);
 };
 
 #if defined(FELIX_HOT_ASSETS)
@@ -5415,6 +5554,29 @@ Span<const uint8_t> PatchFile(const AssetInfo &asset, Allocator *alloc,
 Span<const char> PatchFile(Span<const char> data, Allocator *alloc,
                            FunctionRef<void(Span<const char> key, StreamWriter *)> func);
 
+// ------------------------------------------------------------------------
+// Translations
+// ------------------------------------------------------------------------
+
+struct TranslationTable {
+    struct Pair {
+        const char *key;
+        const char *value;
+    };
+
+    const char *language;
+    Span<Pair> messages;
+
+    K_HASHTABLE_HANDLER(TranslationTable, language);
+};
+
+extern "C" const Span<const TranslationTable> TranslationTables;
+
+void InitLocales(Span<const TranslationTable> tables);
+
+// Resets the localgale to the process default if lang is NULL or is unknown
+void ChangeThreadLocale(const char *name);
+
 // ------------------------------------------------------------------------
 // Options
 // ------------------------------------------------------------------------
@@ -5437,7 +5599,7 @@ enum class OptionType {
 };
 
 class OptionParser {
-    RG_DELETE_COPY(OptionParser)
+    K_DELETE_COPY(OptionParser)
 
     Span<const char *> args;
     OptionMode mode;
@@ -5516,6 +5678,8 @@ bool OptionToEnum(Span<const OptionDesc> options, Span<const char> str, T *out_v
 template <typename T>
 bool OptionToEnumI(Span<const char *const> options, Span<const char> str, T *out_value)
 {
+    static_assert(std::is_enum<T>::value);
+
     for (Size i = 0; i < options.len; i++) {
         const char *opt = options[i];
 
@@ -5531,6 +5695,8 @@ bool OptionToEnumI(Span<const char *const> options, Span<const char> str, T *out
 template <typename T>
 bool OptionToEnumI(Span<const OptionDesc> options, Span<const char> str, T *out_value)
 {
+    static_assert(std::is_enum<T>::value);
+
     for (Size i = 0; i < options.len; i++) {
         const OptionDesc &desc = options[i];
 
@@ -5608,10 +5774,23 @@ bool OptionToFlagI(Span<const OptionDesc> options, Span<const char> str, T *out_
 // ------------------------------------------------------------------------
 
 struct PromptChoice {
-    char c;
     const char *str;
+    char c;
+};
+
+enum class CompleteResult {
+    Success,
+    TooMany,
+    Error
 };
 
+struct CompleteChoice {
+    const char *name;
+    const char *value;
+};
+
+typedef CompleteResult CompleteFunc(Span<const char> value, Allocator *alloc, HeapArray<CompleteChoice> *out_choices);
+
 class ConsolePrompter {
     int prompt_columns = 0;
 
@@ -5631,8 +5810,9 @@ class ConsolePrompter {
 #endif
 
 public:
-    const char *prompt = ">>> ";
+    const char *prompt = ">>>";
     const char *mask = nullptr;
+    std::function<CompleteFunc> complete = {};
 
     HeapArray<char> str;
 
@@ -5667,8 +5847,6 @@ private:
     Vec2<int> GetConsoleSize();
     int32_t ReadChar();
 
-    int ComputeWidth(Span<const char> str);
-
     void EnsureNulTermination();
 };
 
@@ -5679,6 +5857,13 @@ static inline const char *Prompt(const char *prompt, Allocator *alloc)
 Size PromptEnum(const char *prompt, Span<const PromptChoice> choices, Size value = 0);
 Size PromptEnum(const char *prompt, Span<const char *const> strings, Size value = 0);
 
+// Returns -1 if cancelled, otherwise it's 1 for Yes and or 0 for No
+int PromptYN(const char *prompt);
+
+const char *PromptPath(const char *prompt, const char *default_path, Span<const char> root_directory, Allocator *alloc);
+static inline const char *PromptPath(const char *prompt, Allocator *alloc)
+    { return PromptPath(prompt, nullptr, GetWorkingDirectory(), alloc); }
+
 // ------------------------------------------------------------------------
 // Mime types
 // ------------------------------------------------------------------------
@@ -5691,7 +5876,118 @@ bool CanCompressFile(const char *filename);
 // Unicode
 // ------------------------------------------------------------------------
 
-int ComputeCharacterWidth(int32_t uc);
+static inline int CountUtf8Bytes(char c)
+{
+    int ones = CountLeadingZeros((uint32_t)~c << 24);
+    return std::min(std::max(ones, 1), 4);
+}
+
+static constexpr inline Size DecodeUtf8(const char *str, int32_t *out_c)
+{
+    K_ASSERT(str[0]);
+
+#define BYTE(Idx) ((uint8_t)str[Idx])
+
+    if (BYTE(0) < 0x80) {
+        *out_c = BYTE(0);
+        return 1;
+    } else if (BYTE(0) - 0xC2 > 0xF4 - 0xC2) [[unlikely]] {
+        return 0;
+    } else if (BYTE(1)) [[likely]] {
+        if (BYTE(0) < 0xE0 && (BYTE(1) & 0xC0) == 0x80) {
+            *out_c = ((BYTE(0) & 0x1F) << 6) | (BYTE(1) & 0x3F);
+            return 2;
+        } else if (BYTE(2)) [[likely]] {
+            if (BYTE(0) < 0xF0 &&
+                   (BYTE(1) & 0xC0) == 0x80 &&
+                   (BYTE(2) & 0xC0) == 0x80) {
+                *out_c = ((BYTE(0) & 0xF) << 12) | ((BYTE(1) & 0x3F) << 6) | (BYTE(2) & 0x3F);
+                return 3;
+            } else if (BYTE(3)) [[likely]] {
+                if ((BYTE(1) & 0xC0) == 0x80 &&
+                       (BYTE(2) & 0xC0) == 0x80 &&
+                       (BYTE(3) & 0xC0) == 0x80) {
+                    *out_c = ((BYTE(0) & 0x7) << 18) | ((BYTE(1) & 0x3F) << 12) | ((BYTE(2) & 0x3F) << 6) | (BYTE(3) & 0x3F);
+                    return 4;
+                }
+            }
+        }
+    }
+
+#undef BYTE
+
+    return 0;
+}
+
+static constexpr inline Size DecodeUtf8(Span<const char> str, Size offset, int32_t *out_c)
+{
+    K_ASSERT(offset < str.len);
+
+    str = str.Take(offset, str.len - offset);
+
+#define BYTE(Idx) ((uint8_t)str[Idx])
+
+    if (BYTE(0) < 0x80) {
+        *out_c = BYTE(0);
+        return 1;
+    } else if (BYTE(0) - 0xC2 > 0xF4 - 0xC2) [[unlikely]] {
+        return 0;
+    } else if (BYTE(0) < 0xE0 && str.len >= 2 && (BYTE(1) & 0xC0) == 0x80) {
+        *out_c = ((BYTE(0) & 0x1F) << 6) | (BYTE(1) & 0x3F);
+        return 2;
+    } else if (BYTE(0) < 0xF0 && str.len >= 3 && (BYTE(1) & 0xC0) == 0x80 &&
+                                                 (BYTE(2) & 0xC0) == 0x80) {
+        *out_c = ((BYTE(0) & 0xF) << 12) | ((BYTE(1) & 0x3F) << 6) | (BYTE(2) & 0x3F);
+        return 3;
+    } else if (str.len >= 4 && (BYTE(1) & 0xC0) == 0x80 &&
+                               (BYTE(2) & 0xC0) == 0x80 &&
+                               (BYTE(3) & 0xC0) == 0x80) {
+        *out_c = ((BYTE(0) & 0x7) << 18) | ((BYTE(1) & 0x3F) << 12) | ((BYTE(2) & 0x3F) << 6) | (BYTE(3) & 0x3F);
+        return 4;
+    } else {
+        return 0;
+    }
+
+#undef BYTE
+}
+
+static constexpr inline int32_t DecodeUtf8(const char *str)
+{
+    int32_t uc = -1;
+    DecodeUtf8(str, &uc);
+    return uc;
+}
+
+static inline Size EncodeUtf8(int32_t c, char out_buf[4])
+{
+    if (c < 0x80) {
+        out_buf[0] = (char)c;
+        return 1;
+    } else if (c < 0x800) {
+        out_buf[0] = (char)(0xC0 | (c >> 6));
+        out_buf[1] = (char)(0x80 | (c & 0x3F));
+        return 2;
+    } else if (c >= 0xD800 && c < 0xE000) {
+        return 0;
+    } else if (c < 0x10000) {
+        out_buf[0] = (char)(0xE0 | (c >> 12));
+        out_buf[1] = (char)(0x80 | ((c >> 6) & 0x3F));
+        out_buf[2] = (char)(0x80 | (c & 0x3F));
+        return 3;
+    } else if (c < 0x110000) {
+        out_buf[0] = (char)(0xF0 | (c >> 18));
+        out_buf[1] = (char)(0x80 | ((c >> 12) & 0x3F));
+        out_buf[2] = (char)(0x80 | ((c >> 6) & 0x3F));
+        out_buf[3] = (char)(0x80 | (c & 0x3F));
+        return 4;
+    } else {
+        return 0;
+    }
+}
+
+bool IsValidUtf8(Span<const char> str);
+
+int ComputeUnicodeWidth(Span<const char> str);
 
 bool IsXidStart(int32_t uc);
 bool IsXidContinue(int32_t uc);