koffi 2.14.1 → 2.15.1

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

@@ -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>
 
 #include "base.hh"
 #include "crc.inc"
@@ -115,6 +97,7 @@
 #if defined(__linux__)
     #include <sys/syscall.h>
     #include <sys/sendfile.h>
+    #include <sys/eventfd.h>
 #endif
 #if defined(__APPLE__)
     #include <sys/random.h>
@@ -767,25 +750,6 @@ int64_t GetUnixTime()
 #endif
 }
 
-int64_t GetMonotonicTime()
-{
-#if defined(_WIN32)
-    return (int64_t)GetTickCount64();
-#elif defined(__EMSCRIPTEN__)
-    return (int64_t)emscripten_get_now();
-#elif defined(CLOCK_MONOTONIC_COARSE)
-    struct timespec ts;
-    K_CRITICAL(clock_gettime(CLOCK_MONOTONIC_COARSE, &ts) == 0, "clock_gettime(CLOCK_MONOTONIC_COARSE) failed: %1", strerror(errno));
-
-    return (int64_t)ts.tv_sec * 1000 + (int64_t)ts.tv_nsec / 1000000;
-#else
-    struct timespec ts;
-    K_CRITICAL(clock_gettime(CLOCK_MONOTONIC, &ts) == 0, "clock_gettime(CLOCK_MONOTONIC) failed: %1", strerror(errno));
-
-    return (int64_t)ts.tv_sec * 1000 + (int64_t)ts.tv_nsec / 1000000;
-#endif
-}
-
 TimeSpec DecomposeTimeUTC(int64_t time)
 {
     TimeSpec spec = {};
@@ -879,6 +843,39 @@ int64_t ComposeTimeUTC(const TimeSpec &spec)
     return time;
 }
 
+// ------------------------------------------------------------------------
+// Clock
+// ------------------------------------------------------------------------
+
+int64_t GetMonotonicClock()
+{
+    static std::atomic_int64_t memory;
+
+#if defined(_WIN32)
+    int64_t clock = (int64_t)GetTickCount64();
+#elif defined(__EMSCRIPTEN__)
+    int64_t clock = emscripten_get_now();
+#elif defined(CLOCK_MONOTONIC_COARSE)
+    struct timespec ts;
+    K_CRITICAL(clock_gettime(CLOCK_MONOTONIC_COARSE, &ts) == 0, "clock_gettime(CLOCK_MONOTONIC_COARSE) failed: %1", strerror(errno));
+
+    int64_t clock = (int64_t)ts.tv_sec * 1000 + (int64_t)ts.tv_nsec / 1000000;
+#else
+    struct timespec ts;
+    K_CRITICAL(clock_gettime(CLOCK_MONOTONIC, &ts) == 0, "clock_gettime(CLOCK_MONOTONIC) failed: %1", strerror(errno));
+
+    int64_t clock = (int64_t)ts.tv_sec * 1000 + (int64_t)ts.tv_nsec / 1000000;
+#endif
+
+    // Protect against clock going backwards
+    int64_t prev = memory.load(std::memory_order_relaxed);
+    if (clock < prev) [[unlikely]]
+        return prev;
+    memory.compare_exchange_weak(prev, clock, std::memory_order_relaxed, std::memory_order_relaxed);
+
+    return clock;
+}
+
 // ------------------------------------------------------------------------
 // Strings
 // ------------------------------------------------------------------------
@@ -932,6 +929,75 @@ Span<char> DuplicateString(Span<const char> str, Allocator *alloc)
     return MakeSpan(new_str, str.len);
 }
 
+template <typename CompareFunc>
+static inline int NaturalCmp(Span<const char> str1, Span<const char> str2, CompareFunc cmp)
+{
+    Size i = 0;
+    Size j = 0;
+
+    while (i < str1.len && j < str2.len) {
+        int delta = cmp(str1[i], str2[j]);
+
+        if (delta) {
+            if (IsAsciiDigit(str1[i]) && IsAsciiDigit(str2[i])) {
+                while (i < str1.len && str1[i] == '0') {
+                    i++;
+                }
+                while (j < str2.len && str2[j] == '0') {
+                    j++;
+                }
+
+                bool digit1 = false;
+                bool digit2 = false;
+                int bias = 0;
+
+                for (;;) {
+                    digit1 = (i < str1.len) && IsAsciiDigit(str1[i]);
+                    digit2 = (j < str2.len) && IsAsciiDigit(str2[j]);
+
+                    if (!digit1 || !digit2)
+                        break;
+
+                    bias = bias ? bias : cmp(str1[i], str2[j]);
+                    i++;
+                    j++;
+                }
+
+                if (!digit1 && !digit2 && bias) {
+                    return bias;
+                } else if (digit1 || digit2) {
+                    return digit1 ? 1 : -1;
+                }
+            } else {
+                return delta;
+            }
+        } else {
+            i++;
+            j++;
+        }
+    }
+
+    if (i == str1.len && j < str2.len) {
+        return -1;
+    } else if (i < str1.len) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+int CmpNatural(Span<const char> str1, Span<const char> str2)
+{
+    auto cmp = [](int a, int b) { return a - b; };
+    return NaturalCmp(str1, str2, cmp);
+}
+
+int CmpNaturalI(Span<const char> str1, Span<const char> str2)
+{
+    auto cmp = [](int a, int b) { return LowerAscii(a) - LowerAscii(b); };
+    return NaturalCmp(str1, str2, cmp);
+}
+
 // ------------------------------------------------------------------------
 // Format
 // ------------------------------------------------------------------------
@@ -940,6 +1006,8 @@ static const char DigitPairs[201] = "0001020304050607080910111213141516171819202
                                     "25262728293031323334353637383940414243444546474849"
                                     "50515253545556575859606162636465666768697071727374"
                                     "75767778798081828384858687888990919293949596979899";
+static const char BigHexLiterals[] = "0123456789ABCDEF";
+static const char SmallHexLiterals[] = "0123456789abcdef";
 
 static Span<char> FormatUnsignedToDecimal(uint64_t value, char out_buf[32])
 {
@@ -975,13 +1043,11 @@ static Span<char> FormatUnsignedToBinary(uint64_t value, char out_buf[64])
 
 static Span<char> FormatUnsignedToOctal(uint64_t value, char out_buf[64])
 {
-    static const char literals[] = "012345678";
-
     Size offset = 64;
     do {
         uint64_t digit = value & 0x7;
         value >>= 3;
-        out_buf[--offset] = literals[digit];
+        out_buf[--offset] = BigHexLiterals[digit];
     } while (value);
 
     return MakeSpan(out_buf + offset, 64 - offset);
@@ -989,13 +1055,11 @@ static Span<char> FormatUnsignedToOctal(uint64_t value, char out_buf[64])
 
 static Span<char> FormatUnsignedToBigHex(uint64_t value, char out_buf[32])
 {
-    static const char literals[] = "0123456789ABCDEF";
-
     Size offset = 32;
     do {
         uint64_t digit = value & 0xF;
         value >>= 4;
-        out_buf[--offset] = literals[digit];
+        out_buf[--offset] = BigHexLiterals[digit];
     } while (value);
 
     return MakeSpan(out_buf + offset, 32 - offset);
@@ -1003,13 +1067,11 @@ static Span<char> FormatUnsignedToBigHex(uint64_t value, char out_buf[32])
 
 static Span<char> FormatUnsignedToSmallHex(uint64_t value, char out_buf[32])
 {
-    static const char literals[] = "0123456789abcdef";
-
     Size offset = 32;
     do {
         uint64_t digit = value & 0xF;
         value >>= 4;
-        out_buf[--offset] = literals[digit];
+        out_buf[--offset] = SmallHexLiterals[digit];
     } while (value);
 
     return MakeSpan(out_buf + offset, 32 - offset);
@@ -1185,406 +1247,429 @@ Span<const char> FormatFloatingPoint(T value, bool non_zero, int min_prec, int m
 #endif
 }
 
+template <typename AppendFunc>
+static inline void AppendPad(Size pad, char padding, AppendFunc append)
+{
+    for (Size i = 0; i < pad; i++) {
+        append(padding);
+    }
+}
+
+template <typename AppendFunc>
+static inline void AppendSafe(char c, AppendFunc append)
+{
+    if (IsAsciiControl(c))
+        return;
+
+    append(c);
+}
+
 template <typename AppendFunc>
 static inline void ProcessArg(const FmtArg &arg, AppendFunc append)
 {
-    for (int i = 0; i < arg.repeat; i++) {
-        LocalArray<char, 2048> out_buf;
-        char num_buf[128];
-        Span<const char> out = {};
+    switch (arg.type) {
+        case FmtType::Str: { append(arg.u.str); } break;
 
-        Size pad_len = arg.pad_len;
+        case FmtType::PadStr: {
+            append(arg.u.str);
+            AppendPad(arg.pad - arg.u.str.len, arg.padding, append);
+        } break;
+        case FmtType::RepeatStr: {
+            Span<const char> str = arg.u.repeat.str;
 
-        switch (arg.type) {
-            case FmtType::Str1: { out = arg.u.str1; } break;
-            case FmtType::Str2: { out = arg.u.str2; } break;
-            case FmtType::Buffer: { out = arg.u.buf; } break;
-            case FmtType::Char: { out = MakeSpan(&arg.u.ch, 1); } break;
+            for (int i = 0; i < arg.u.repeat.count; i++) {
+                append(str);
+            }
+        } break;
 
-            case FmtType::Custom: { arg.u.custom.Format(append); } break;
+        case FmtType::Char: { append(MakeSpan(&arg.u.ch, 1)); } break;
+        case FmtType::Buffer: {
+            Span<const char> str = arg.u.buf;
+            append(str);
+        } break;
+        case FmtType::Custom: { arg.u.custom.Format(append); } break;
 
-            case FmtType::Bool: {
-                if (arg.u.b) {
-                    out = "true";
-                } else {
-                    out = "false";
-                }
-            } break;
+        case FmtType::Bool: { append(arg.u.b ? "true" : "false"); } break;
+
+        case FmtType::Integer: {
+            if (arg.u.i < 0) {
+                char buf[128];
+                Span<const char> str = FormatUnsignedToDecimal((uint64_t)-arg.u.i, buf);
 
-            case FmtType::Integer: {
-                if (arg.u.i < 0) {
-                    if (arg.pad_len < 0 && arg.pad_char == '0') {
+                if (arg.pad) {
+                    if (arg.padding == '0') {
                         append('-');
+                        AppendPad((Size)arg.pad - str.len - 1, arg.padding, append);
                     } else {
-                        out_buf.Append('-');
+                        AppendPad((Size)arg.pad - str.len - 1, arg.padding, append);
+                        append('-');
                     }
-
-                    out_buf.Append(FormatUnsignedToDecimal((uint64_t)-arg.u.i, num_buf));
-                    out = out_buf;
                 } else {
-                    out = FormatUnsignedToDecimal((uint64_t)arg.u.i, num_buf);
+                    append('-');
                 }
-            } break;
-            case FmtType::Unsigned: {
-                out = FormatUnsignedToDecimal(arg.u.u, num_buf);
-            } break;
-            case FmtType::Float: {
-                static const uint32_t ExponentMask = 0x7f800000u;
-                static const uint32_t MantissaMask = 0x007fffffu;
-                static const uint32_t SignMask = 0x80000000u;
 
-                union { float f; uint32_t u32; } u;
-                u.f = arg.u.f.value;
+                append(str);
+            } else {
+                char buf[128];
+                Span<const char> str = FormatUnsignedToDecimal((uint64_t)arg.u.i, buf);
 
-                if ((u.u32 & ExponentMask) == ExponentMask) {
-                    uint32_t mantissa = u.u32 & MantissaMask;
+                AppendPad((Size)arg.pad - str.len, arg.padding, append);
+                append(str);
+            }
+        } break;
+        case FmtType::Unsigned: {
+            char buf[128];
+            Span<const char> str = FormatUnsignedToDecimal(arg.u.u, buf);
 
-                    if (mantissa) {
-                        out = "NaN";
-                    } else {
-                        out = (u.u32 & SignMask) ? "-Inf" : "Inf";
-                    }
-                } else {
-                    if (u.u32 & SignMask) {
-                        if (arg.pad_len < 0 && arg.pad_char == '0') {
-                            append('-');
-                        } else {
-                            out_buf.Append('-');
-                        }
+            AppendPad((Size)arg.pad - str.len, arg.padding, append);
+            append(str);
+        } break;
 
-                        out_buf.Append(FormatFloatingPoint(-u.f, true, arg.u.f.min_prec, arg.u.f.max_prec, num_buf));
-                        out = out_buf;
-                    } else {
-                        out = FormatFloatingPoint(u.f, u.u32, arg.u.f.min_prec, arg.u.f.max_prec, num_buf);
-                    }
-                }
-            } break;
-            case FmtType::Double: {
-                static const uint64_t ExponentMask = 0x7FF0000000000000ull;
-                static const uint64_t MantissaMask = 0x000FFFFFFFFFFFFFull;
-                static const uint64_t SignMask = 0x8000000000000000ull;
+        case FmtType::Float: {
+            static const uint32_t ExponentMask = 0x7f800000u;
+            static const uint32_t MantissaMask = 0x007fffffu;
+            static const uint32_t SignMask = 0x80000000u;
 
-                union { double d; uint64_t u64; } u;
-                u.d = arg.u.d.value;
+            union { float f; uint32_t u32; } u;
+            u.f = arg.u.f.value;
 
-                if ((u.u64 & ExponentMask) == ExponentMask) {
-                    uint64_t mantissa = u.u64 & MantissaMask;
+            if ((u.u32 & ExponentMask) == ExponentMask) {
+                uint32_t mantissa = u.u32 & MantissaMask;
 
-                    if (mantissa) {
-                        out = "NaN";
-                    } else {
-                        out = (u.u64 & SignMask) ? "-Inf" : "Inf";
-                    }
+                if (mantissa) {
+                    append("NaN");
                 } else {
-                    if (u.u64 & SignMask) {
-                        if (arg.pad_len < 0 && arg.pad_char == '0') {
-                            append('-');
-                        } else {
-                            out_buf.Append('-');
-                        }
-
-                        out_buf.Append(FormatFloatingPoint(-u.d, true, arg.u.d.min_prec, arg.u.d.max_prec, num_buf));
-                        out = out_buf;
-                    } else {
-                        out = FormatFloatingPoint(u.d, u.u64, arg.u.d.min_prec, arg.u.d.max_prec, num_buf);
-                    }
+                    append((u.u32 & SignMask) ? "-Inf" : "Inf");
                 }
-            } break;
-            case FmtType::Binary: {
-                out = FormatUnsignedToBinary(arg.u.u, num_buf);
-            } break;
-            case FmtType::Octal: {
-                out = FormatUnsignedToOctal(arg.u.u, num_buf);
-            } break;
-            case FmtType::BigHex: {
-                out = FormatUnsignedToBigHex(arg.u.u, num_buf);
-            } break;
-            case FmtType::SmallHex: {
-                out = FormatUnsignedToSmallHex(arg.u.u, num_buf);
-            } break;
+            } else {
+                char buf[128];
 
-            case FmtType::MemorySize: {
-                double size;
-                if (arg.u.i < 0) {
-                    size = (double)-arg.u.i;
-                    if (arg.pad_len < 0 && arg.pad_char == '0') {
-                        append('-');
-                    } else {
-                        out_buf.Append('-');
-                    }
+                if (u.u32 & SignMask) {
+                    append('-');
+                    append(FormatFloatingPoint(-u.f, true, arg.u.f.min_prec, arg.u.f.max_prec, buf));
                 } else {
-                    size = (double)arg.u.i;
+                    append(FormatFloatingPoint(u.f, u.u32, arg.u.f.min_prec, arg.u.f.max_prec, buf));
                 }
+            }
+        } break;
+        case FmtType::Double: {
+            static const uint64_t ExponentMask = 0x7FF0000000000000ull;
+            static const uint64_t MantissaMask = 0x000FFFFFFFFFFFFFull;
+            static const uint64_t SignMask = 0x8000000000000000ull;
 
-                if (size >= 1073688137.0) {
-                    size /= 1073741824.0;
-
-                    int prec = 1 + (size < 9.9995) + (size < 99.995);
-                    out_buf.Append(FormatFloatingPoint(size, true, prec, prec, num_buf));
-                    out_buf.Append(" GiB");
-                } else if (size >= 1048524.0) {
-                    size /= 1048576.0;
+            union { double d; uint64_t u64; } u;
+            u.d = arg.u.d.value;
 
-                    int prec = 1 + (size < 9.9995) + (size < 99.995);
-                    out_buf.Append(FormatFloatingPoint(size, true, prec, prec, num_buf));
-                    out_buf.Append(" MiB");
-                } else if (size >= 1023.95) {
-                    size /= 1024.0;
+            if ((u.u64 & ExponentMask) == ExponentMask) {
+                uint64_t mantissa = u.u64 & MantissaMask;
 
-                    int prec = 1 + (size < 9.9995) + (size < 99.995);
-                    out_buf.Append(FormatFloatingPoint(size, true, prec, prec, num_buf));
-                    out_buf.Append(" kiB");
+                if (mantissa) {
+                    append("NaN");
                 } else {
-                    out_buf.Append(FormatFloatingPoint(size, arg.u.i, 0, 0, num_buf));
-                    out_buf.Append(" B");
+                    append((u.u64 & SignMask) ? "-Inf" : "Inf");
                 }
+            } else {
+                char buf[128];
 
-                out = out_buf;
-            } break;
-            case FmtType::DiskSize: {
-                double size;
-                if (arg.u.i < 0) {
-                    size = (double)-arg.u.i;
-                    if (arg.pad_len < 0 && arg.pad_char == '0') {
-                        append('-');
-                    } else {
-                        out_buf.Append('-');
-                    }
+                if (u.u64 & SignMask) {
+                    append('-');
+                    append(FormatFloatingPoint(-u.d, true, arg.u.d.min_prec, arg.u.d.max_prec, buf));
                 } else {
-                    size = (double)arg.u.i;
+                    append(FormatFloatingPoint(u.d, u.u64, arg.u.d.min_prec, arg.u.d.max_prec, buf));
                 }
+            }
+        } break;
 
-                if (size >= 999950000.0) {
-                    size /= 1000000000.0;
+        case FmtType::Binary: {
+            char buf[128];
+            Span<const char> str = FormatUnsignedToBinary(arg.u.u, buf);
 
-                    int prec = 1 + (size < 9.9995) + (size < 99.995);
-                    out_buf.Append(FormatFloatingPoint(size, true, prec, prec, num_buf));
-                    out_buf.Append(" GB");
-                } else if (size >= 999950.0) {
-                    size /= 1000000.0;
+            AppendPad((Size)arg.pad - str.len, arg.padding, append);
+            append(str);
+        } break;
+        case FmtType::Octal: {
+            char buf[128];
+            Span<const char> str = FormatUnsignedToOctal(arg.u.u, buf);
 
-                    int prec = 1 + (size < 9.9995) + (size < 99.995);
-                    out_buf.Append(FormatFloatingPoint(size, true, prec, prec, num_buf));
-                    out_buf.Append(" MB");
-                } else if (size >= 999.95) {
-                    size /= 1000.0;
+            AppendPad((Size)arg.pad - str.len, arg.padding, append);
+            append(str);
+        } break;
+        case FmtType::BigHex: {
+            char buf[128];
+            Span<const char> str = FormatUnsignedToBigHex(arg.u.u, buf);
 
-                    int prec = 1 + (size < 9.9995) + (size < 99.995);
-                    out_buf.Append(FormatFloatingPoint(size, true, prec, prec, num_buf));
-                    out_buf.Append(" kB");
-                } else {
-                    out_buf.Append(FormatFloatingPoint(size, arg.u.i, 0, 0, num_buf));
-                    out_buf.Append(" B");
-                }
+            AppendPad((Size)arg.pad - str.len, arg.padding, append);
+            append(str);
+        } break;
+        case FmtType::SmallHex: {
+            char buf[128];
+            Span<const char> str = FormatUnsignedToSmallHex(arg.u.u, buf);
 
-                out = out_buf;
-            } break;
+            AppendPad((Size)arg.pad - str.len, arg.padding, append);
+            append(str);
+        } break;
 
-            case FmtType::Date: {
-                K_ASSERT(!arg.u.date.value || arg.u.date.IsValid());
+        case FmtType::BigBytes: {
+            for (uint8_t c: arg.u.hex) {
+                char encoded[2];
 
-                int year = arg.u.date.st.year;
-                if (year < 0) {
-                    out_buf.Append('-');
-                    year = -year;
-                }
-                if (year < 10) {
-                    out_buf.Append("000");
-                } else if (year < 100) {
-                    out_buf.Append("00");
-                } else if (year < 1000) {
-                    out_buf.Append('0');
-                }
-                out_buf.Append(FormatUnsignedToDecimal((uint64_t)year, num_buf));
-                out_buf.Append('-');
-                if (arg.u.date.st.month < 10) {
-                    out_buf.Append('0');
-                }
-                out_buf.Append(FormatUnsignedToDecimal((uint64_t)arg.u.date.st.month, num_buf));
-                out_buf.Append('-');
-                if (arg.u.date.st.day < 10) {
-                    out_buf.Append('0');
-                }
-                out_buf.Append(FormatUnsignedToDecimal((uint64_t)arg.u.date.st.day, num_buf));
-                out = out_buf;
-            } break;
+                encoded[0] = BigHexLiterals[((uint8_t)c >> 4) & 0xF];
+                encoded[1] = BigHexLiterals[((uint8_t)c >> 0) & 0xF];
 
-            case FmtType::TimeISO: {
-                const TimeSpec &spec = arg.u.time.spec;
-
-                if (spec.offset && arg.u.time.ms) {
-                    int offset_h = spec.offset / 60;
-                    int offset_m = spec.offset % 60;
-
-                    out_buf.len = Fmt(out_buf.data, "%1%2%3T%4%5%6.%7%8%9%10",
-                                      FmtArg(spec.year).Pad0(-2), FmtArg(spec.month).Pad0(-2),
-                                      FmtArg(spec.day).Pad0(-2), FmtArg(spec.hour).Pad0(-2),
-                                      FmtArg(spec.min).Pad0(-2), FmtArg(spec.sec).Pad0(-2), FmtArg(spec.msec).Pad0(-3),
-                                      offset_h >= 0 ? "+" : "", FmtArg(offset_h).Pad0(-2), FmtArg(offset_m).Pad0(-2)).len;
-                } else if (spec.offset) {
-                    int offset_h = spec.offset / 60;
-                    int offset_m = spec.offset % 60;
-
-                    out_buf.len = Fmt(out_buf.data, "%1%2%3T%4%5%6%7%8%9",
-                                      FmtArg(spec.year).Pad0(-2), FmtArg(spec.month).Pad0(-2),
-                                      FmtArg(spec.day).Pad0(-2), FmtArg(spec.hour).Pad0(-2),
-                                      FmtArg(spec.min).Pad0(-2), FmtArg(spec.sec).Pad0(-2),
-                                      offset_h >= 0 ? "+" : "", FmtArg(offset_h).Pad0(-2), FmtArg(offset_m).Pad0(-2)).len;
-                } else if (arg.u.time.ms) {
-                    out_buf.len = Fmt(out_buf.data, "%1%2%3T%4%5%6.%7Z",
-                                      FmtArg(spec.year).Pad0(-2), FmtArg(spec.month).Pad0(-2),
-                                      FmtArg(spec.day).Pad0(-2), FmtArg(spec.hour).Pad0(-2),
-                                      FmtArg(spec.min).Pad0(-2), FmtArg(spec.sec).Pad0(-2), FmtArg(spec.msec).Pad0(-3)).len;
-                } else {
-                    out_buf.len = Fmt(out_buf.data, "%1%2%3T%4%5%6Z",
-                                      FmtArg(spec.year).Pad0(-2), FmtArg(spec.month).Pad0(-2),
-                                      FmtArg(spec.day).Pad0(-2), FmtArg(spec.hour).Pad0(-2),
-                                      FmtArg(spec.min).Pad0(-2), FmtArg(spec.sec).Pad0(-2)).len;
-                }
-                out = out_buf;
-            } break;
-            case FmtType::TimeNice: {
-                const TimeSpec &spec = arg.u.time.spec;
+                Span<const char> buf = MakeSpan(encoded, 2);
+                append(buf);
+            }
+        } break;
+        case FmtType::SmallBytes: {
+            for (uint8_t c: arg.u.hex) {
+                char encoded[2];
+
+                encoded[0] = SmallHexLiterals[((uint8_t)c >> 4) & 0xF];
+                encoded[1] = SmallHexLiterals[((uint8_t)c >> 0) & 0xF];
+
+                Span<const char> buf = MakeSpan(encoded, 2);
+                append(buf);
+            }
+        } break;
+
+        case FmtType::MemorySize: {
+            char buf[128];
+
+            double size;
+            if (arg.u.i < 0) {
+                append('-');
+                size = (double)-arg.u.i;
+            } else {
+                size = (double)arg.u.i;
+            }
+
+            if (size >= 1073688137.0) {
+                size /= 1073741824.0;
+
+                int prec = 1 + (size < 9.9995) + (size < 99.995);
+                append(FormatFloatingPoint(size, true, prec, prec, buf));
+                append(" GiB");
+            } else if (size >= 1048524.0) {
+                size /= 1048576.0;
+
+                int prec = 1 + (size < 9.9995) + (size < 99.995);
+                append(FormatFloatingPoint(size, true, prec, prec, buf));
+                append(" MiB");
+            } else if (size >= 1023.95) {
+                size /= 1024.0;
+
+                int prec = 1 + (size < 9.9995) + (size < 99.995);
+                append(FormatFloatingPoint(size, true, prec, prec, buf));
+                append(" kiB");
+            } else {
+                append(FormatFloatingPoint(size, arg.u.i, 0, 0, buf));
+                append(" B");
+            }
+        } break;
+        case FmtType::DiskSize: {
+            char buf[128];
+
+            double size;
+            if (arg.u.i < 0) {
+                append('-');
+                size = (double)-arg.u.i;
+            } else {
+                size = (double)arg.u.i;
+            }
+
+            if (size >= 999950000.0) {
+                size /= 1000000000.0;
+
+                int prec = 1 + (size < 9.9995) + (size < 99.995);
+                append(FormatFloatingPoint(size, true, prec, prec, buf));
+                append(" GB");
+            } else if (size >= 999950.0) {
+                size /= 1000000.0;
+
+                int prec = 1 + (size < 9.9995) + (size < 99.995);
+                append(FormatFloatingPoint(size, true, prec, prec, buf));
+                append(" MB");
+            } else if (size >= 999.95) {
+                size /= 1000.0;
+
+                int prec = 1 + (size < 9.9995) + (size < 99.995);
+                append(FormatFloatingPoint(size, true, prec, prec, buf));
+                append(" kB");
+            } else {
+                append(FormatFloatingPoint(size, arg.u.i, 0, 0, buf));
+                append(" B");
+            }
+        } break;
+
+        case FmtType::Date: {
+            K_ASSERT(!arg.u.date.value || arg.u.date.IsValid());
 
+            char buf[128];
+
+            int year = arg.u.date.st.year;
+            if (year < 0) {
+                append('-');
+                year = -year;
+            }
+            if (year < 10) {
+                append("000");
+            } else if (year < 100) {
+                append("00");
+            } else if (year < 1000) {
+                append('0');
+            }
+            append(FormatUnsignedToDecimal((uint64_t)year, buf));
+            append('-');
+            if (arg.u.date.st.month < 10) {
+                append('0');
+            }
+            append(FormatUnsignedToDecimal((uint64_t)arg.u.date.st.month, buf));
+            append('-');
+            if (arg.u.date.st.day < 10) {
+                append('0');
+            }
+            append(FormatUnsignedToDecimal((uint64_t)arg.u.date.st.day, buf));
+        } break;
+
+        case FmtType::TimeISO: {
+            const TimeSpec &spec = arg.u.time.spec;
+
+            LocalArray<char, 128> buf;
+
+            if (spec.offset && arg.u.time.ms) {
                 int offset_h = spec.offset / 60;
                 int offset_m = spec.offset % 60;
 
-                if (arg.u.time.ms) {
-                    out_buf.len = Fmt(out_buf.data, "%1-%2-%3 %4:%5:%6.%7 %8%9%10",
-                                      FmtArg(spec.year).Pad0(-2), FmtArg(spec.month).Pad0(-2),
-                                      FmtArg(spec.day).Pad0(-2), FmtArg(spec.hour).Pad0(-2),
-                                      FmtArg(spec.min).Pad0(-2), FmtArg(spec.sec).Pad0(-2), FmtArg(spec.msec).Pad0(-3),
-                                      offset_h >= 0 ? "+" : "", FmtArg(offset_h).Pad0(-2), FmtArg(offset_m).Pad0(-2)).len;
-                } else {
-                    out_buf.len = Fmt(out_buf.data, "%1-%2-%3 %4:%5:%6 %7%8%9",
-                                      FmtArg(spec.year).Pad0(-2), FmtArg(spec.month).Pad0(-2),
-                                      FmtArg(spec.day).Pad0(-2), FmtArg(spec.hour).Pad0(-2),
-                                      FmtArg(spec.min).Pad0(-2), FmtArg(spec.sec).Pad0(-2),
-                                      offset_h >= 0 ? "+" : "", FmtArg(offset_h).Pad0(-2), FmtArg(offset_m).Pad0(-2)).len;
-                }
-                out = out_buf;
-            } break;
+                buf.len = Fmt(buf.data, "%1%2%3T%4%5%6.%7%8%9%10",
+                              FmtInt(spec.year, 2), FmtInt(spec.month, 2),
+                              FmtInt(spec.day, 2), FmtInt(spec.hour, 2),
+                              FmtInt(spec.min, 2), FmtInt(spec.sec, 2), FmtInt(spec.msec, 3),
+                              offset_h >= 0 ? "+" : "", FmtInt(offset_h, 2), FmtInt(offset_m, 2)).len;
+            } else if (spec.offset) {
+                int offset_h = spec.offset / 60;
+                int offset_m = spec.offset % 60;
 
-            case FmtType::Random: {
-                static const char *const DefaultChars = "abcdefghijklmnopqrstuvwxyz0123456789";
-                Span<const char> chars = arg.u.random.chars ? arg.u.random.chars : DefaultChars;
+                buf.len = Fmt(buf.data, "%1%2%3T%4%5%6%7%8%9",
+                              FmtInt(spec.year, 2), FmtInt(spec.month, 2),
+                              FmtInt(spec.day, 2), FmtInt(spec.hour, 2),
+                              FmtInt(spec.min, 2), FmtInt(spec.sec, 2),
+                              offset_h >= 0 ? "+" : "", FmtInt(offset_h, 2), FmtInt(offset_m, 2)).len;
+            } else if (arg.u.time.ms) {
+                buf.len = Fmt(buf.data, "%1%2%3T%4%5%6.%7Z",
+                              FmtInt(spec.year, 2), FmtInt(spec.month, 2),
+                              FmtInt(spec.day, 2), FmtInt(spec.hour, 2),
+                              FmtInt(spec.min, 2), FmtInt(spec.sec, 2), FmtInt(spec.msec, 3)).len;
+            } else {
+                buf.len = Fmt(buf.data, "%1%2%3T%4%5%6Z",
+                              FmtInt(spec.year, 2), FmtInt(spec.month, 2),
+                              FmtInt(spec.day, 2), FmtInt(spec.hour, 2),
+                              FmtInt(spec.min, 2), FmtInt(spec.sec, 2)).len;
+            }
 
-                K_ASSERT(arg.u.random.len <= K_SIZE(out_buf.data));
+            append(buf);
+        } break;
+        case FmtType::TimeNice: {
+            const TimeSpec &spec = arg.u.time.spec;
 
-                for (Size j = 0; j < arg.u.random.len; j++) {
-                    int rnd = GetRandomInt(0, (int)chars.len);
-                    out_buf.Append(chars[rnd]);
-                }
+            LocalArray<char, 128> buf;
 
-                out = out_buf;
-            } break;
+            if (arg.u.time.ms) {
+                int offset_h = spec.offset / 60;
+                int offset_m = spec.offset % 60;
 
-            case FmtType::FlagNames: {
-                if (arg.u.flags.flags) {
-                    Span<const char> sep = arg.u.flags.separator;
-                    for (Size j = 0; j < arg.u.flags.u.names.len; j++) {
-                        if (arg.u.flags.flags & (1ull << j)) {
-                            out_buf.Append(arg.u.flags.u.names[j]);
-                            out_buf.Append(sep);
-                        }
-                    }
-                    out = out_buf.Take(0, out_buf.len - sep.len);
-                } else {
-                    out = "None";
+                buf.len = Fmt(buf.data, "%1-%2-%3 %4:%5:%6.%7 %8%9%10",
+                              FmtInt(spec.year, 2), FmtInt(spec.month, 2),
+                              FmtInt(spec.day, 2), FmtInt(spec.hour, 2),
+                              FmtInt(spec.min, 2), FmtInt(spec.sec, 2), FmtInt(spec.msec, 3),
+                              offset_h >= 0 ? "+" : "", FmtInt(offset_h, 2), FmtInt(offset_m, 2)).len;
+            } else {
+                int offset_h = spec.offset / 60;
+                int offset_m = spec.offset % 60;
+
+                buf.len = Fmt(buf.data, "%1-%2-%3 %4:%5:%6 %7%8%9",
+                              FmtInt(spec.year, 2), FmtInt(spec.month, 2),
+                              FmtInt(spec.day, 2), FmtInt(spec.hour, 2),
+                              FmtInt(spec.min, 2), FmtInt(spec.sec, 2),
+                              offset_h >= 0 ? "+" : "", FmtInt(offset_h, 2), FmtInt(offset_m, 2)).len;
+            }
+
+            append(buf);
+        } break;
+
+        case FmtType::List: {
+            Span<const char> separator = arg.u.list.separator;
+
+            if (arg.u.list.u.names.len) {
+                append(arg.u.list.u.names[0]);
+
+                for (Size i = 1; i < arg.u.list.u.names.len; i++) {
+                    append(separator);
+                    append(arg.u.list.u.names[i]);
                 }
-            } break;
-            case FmtType::FlagOptions: {
-                if (arg.u.flags.flags) {
-                    Span<const char> sep = arg.u.flags.separator;
-                    for (Size j = 0; j < arg.u.flags.u.options.len; j++) {
-                        if (arg.u.flags.flags & (1ull << j)) {
-                            out_buf.Append(arg.u.flags.u.options[j].name);
-                            out_buf.Append(sep);
-                        }
-                    }
-                    out = out_buf.Take(0, out_buf.len - sep.len);
-                } else {
-                    out = "None";
+            } else {
+                append(T("None"));
+            }
+        } break;
+        case FmtType::FlagNames: {
+            uint64_t flags = arg.u.list.flags;
+            Span<const char> separator = arg.u.list.separator;
+
+            if (flags) {
+                for (;;) {
+                    int idx = CountTrailingZeros(flags);
+                    flags &= ~(1ull << idx);
+
+                    append(arg.u.list.u.names[idx]);
+                    if (!flags)
+                        break;
+                    append(separator);
                 }
-            } break;
+            } else {
+                append(T("None"));
+            }
+        } break;
+        case FmtType::FlagOptions: {
+            uint64_t flags = arg.u.list.flags;
+            Span<const char> separator = arg.u.list.separator;
 
-            case FmtType::Span: {
-                FmtArg arg2;
-                arg2.type = arg.u.span.type;
-                arg2.repeat = arg.repeat;
-                arg2.pad_len = arg.pad_len;
-                arg2.pad_char = arg.pad_char;
-
-                const uint8_t *ptr = (const uint8_t *)arg.u.span.ptr;
-                for (Size j = 0; j < arg.u.span.len; j++) {
-                    switch (arg.u.span.type) {
-                        case FmtType::Str1: { arg2.u.str1 = *(const char **)ptr; } break;
-                        case FmtType::Str2: { arg2.u.str2 = *(const Span<const char> *)ptr; } break;
-                        case FmtType::Buffer: { K_UNREACHABLE(); } break;
-                        case FmtType::Char: { arg2.u.ch = *(const char *)ptr; } break;
-                        case FmtType::Custom: { K_UNREACHABLE(); } break;
-                        case FmtType::Bool: { arg2.u.b = *(const bool *)ptr; } break;
-                        case FmtType::Integer:
-                        case FmtType::Unsigned:
-                        case FmtType::Binary:
-                        case FmtType::Octal:
-                        case FmtType::BigHex:
-                        case FmtType::SmallHex: {
-                            switch (arg.u.span.type_len) {
-                                case 8: { arg2.u.u = *(const uint64_t *)ptr; } break;
-                                case 4: { arg2.u.u = *(const uint32_t *)ptr; } break;
-                                case 2: { arg2.u.u = *(const uint16_t *)ptr; } break;
-                                case 1: { arg2.u.u = *(const uint8_t *)ptr; } break;
-                                default: { K_UNREACHABLE(); } break;
-                            }
-                        } break;
-                        case FmtType::Float: {
-                            arg2.u.f.value = *(const float *)ptr;
-                            arg2.u.d.min_prec = 0;
-                            arg2.u.d.max_prec = INT_MAX;
-                        } break;
-                        case FmtType::Double: {
-                            arg2.u.d.value = *(const double *)ptr;
-                            arg2.u.d.min_prec = 0;
-                            arg2.u.d.max_prec = INT_MAX;
-                        } break;
-                        case FmtType::MemorySize:
-                        case FmtType::DiskSize: { arg2.u.i = *(const int64_t *)ptr; } break;
-                        case FmtType::Date: { arg2.u.date = *(const LocalDate *)ptr; } break;
-                        case FmtType::TimeISO:
-                        case FmtType::TimeNice: { arg2.u.time = *(decltype(FmtArg::u.time) *)ptr; } break;
-                        case FmtType::Random: { K_UNREACHABLE(); } break;
-                        case FmtType::FlagNames: { K_UNREACHABLE(); } break;
-                        case FmtType::FlagOptions: { K_UNREACHABLE(); } break;
-                        case FmtType::Span: { K_UNREACHABLE(); } break;
-                    }
-                    ptr += arg.u.span.type_len;
+            if (arg.u.list.flags) {
+                for (;;) {
+                    int idx = CountTrailingZeros(flags);
+                    flags &= ~(1ull << idx);
 
-                    if (j) {
-                        append(arg.u.span.separator);
-                    }
-                    ProcessArg(arg2, append);
+                    append(arg.u.list.u.options[idx].name);
+                    if (!flags)
+                        break;
+                    append(separator);
                 }
+            } else {
+                append(T("None"));
+            }
+        } break;
 
-                continue;
-            } break;
-        }
+        case FmtType::Random: {
+            LocalArray<char, 512> buf;
+
+            static const char *const DefaultChars = "abcdefghijklmnopqrstuvwxyz0123456789";
+            Span<const char> chars = arg.u.random.chars ? arg.u.random.chars : DefaultChars;
 
-        if (pad_len < 0) {
-            pad_len = (-pad_len) - out.len;
-            for (Size j = 0; j < pad_len; j++) {
-                append(arg.pad_char);
+            K_ASSERT(arg.u.random.len <= K_SIZE(buf.data));
+            buf.len = arg.u.random.len;
+
+            for (Size j = 0; j < arg.u.random.len; j++) {
+                int rnd = GetRandomInt(0, (int)chars.len);
+                buf[j] = chars[rnd];
             }
-            append(out);
-        } else if (pad_len > 0) {
-            append(out);
-            pad_len -= out.len;
-            for (Size j = 0; j < pad_len; j++) {
-                append(arg.pad_char);
+
+            append(buf);
+        } break;
+
+        case FmtType::SafeStr: {
+            for (char c: arg.u.str) {
+                AppendSafe(c, append);
             }
-        } else {
-            append(out);
-        }
+        } break;
+        case FmtType::SafeChar: { AppendSafe(arg.u.ch, append); } break;
     }
 }
 
@@ -1864,17 +1949,48 @@ void FmtLowerAscii::Format(FunctionRef<void(Span<const char>)> append) const
     }
 }
 
+void FmtUrlSafe::Format(FunctionRef<void(Span<const char>)> append) const
+{
+    for (char c: str) {
+        if (IsAsciiAlphaOrDigit(c) || strchr(passthrough, c)) {
+            append((char)c);
+        } else {
+            char encoded[3];
+
+            encoded[0] = '%';
+            encoded[1] = BigHexLiterals[((uint8_t)c >> 4) & 0xF];
+            encoded[2] = BigHexLiterals[((uint8_t)c >> 0) & 0xF];
+
+            Span<const char> buf = MakeSpan(encoded, 3);
+            append(buf);
+        }
+    }
+}
+
+void FmtHtmlSafe::Format(FunctionRef<void(Span<const char>)> append) const
+{
+    for (char c: str) {
+        switch (c) {
+            case '<': { append("&lt;"); } break;
+            case '>':  { append("&gt;"); } break;
+            case '"':  { append("&quot;"); } break;
+            case '\'': { append("&apos;"); } break;
+            case '&':  { append("&amp;"); } break;
+
+            default: { append(c); } break;
+        }
+    }
+}
+
 void FmtEscape::Format(FunctionRef<void(Span<const char>)> append) const
 {
     for (char c: str) {
-        if (c == '"') {
-            append("\\\"");
-        } else if (c == '\'') {
-            append("\\'");
-        } else if (c == '\r') {
+        if (c == '\r') {
             append("\\r");
         } else if (c == '\n') {
             append("\\n");
+        } else if (c == '\\') {
+            append("\\\\");
         } else if ((unsigned int)c < 32) {
             char encoded[4];
 
@@ -1885,32 +2001,15 @@ void FmtEscape::Format(FunctionRef<void(Span<const char>)> append) const
 
             Span<const char> buf = MakeSpan(encoded, 4);
             append(buf);
+        } else if (c == quote) {
+            append('\\');
+            append(quote);
         } else {
             append(c);
         }
     }
 }
 
-void FmtUrlSafe::Format(FunctionRef<void(Span<const char>)> append) const
-{
-    static const char literals[] = "0123456789ABCDEF";
-
-    for (char c: str) {
-        if (IsAsciiAlphaOrDigit(c) || strchr(passthrough, c)) {
-            append((char)c);
-        } else {
-            char encoded[3];
-
-            encoded[0] = '%';
-            encoded[1] = literals[((uint8_t)c >> 4) & 0xF];
-            encoded[2] = literals[((uint8_t)c >> 0) & 0xF];
-
-            Span<const char> buf = MakeSpan(encoded, 3);
-            append(buf);
-        }
-    }
-}
-
 FmtArg FmtVersion(int64_t version, int parts, int by)
 {
     K_ASSERT(version >= 0);
@@ -1946,7 +2045,7 @@ FmtArg FmtVersion(int64_t version, int parts, int by)
 // Debug and errors
 // ------------------------------------------------------------------------
 
-static int64_t start_time = GetMonotonicTime();
+static int64_t start_clock = GetMonotonicClock();
 
 static std::function<LogFunc> log_handler = DefaultLogHandler;
 static bool log_vt100 = FileIsVt100(STDERR_FILENO);
@@ -1963,7 +2062,7 @@ const char *GetEnv(const char *name)
     static HashMap<const char *, const char *> values;
 
     bool inserted;
-    auto bucket = values.TrySetDefault(name, &inserted);
+    auto bucket = values.InsertOrGetDefault(name, &inserted);
 
     if (inserted) {
         const char *str = (const char *)EM_ASM_INT({
@@ -2045,8 +2144,8 @@ void LogFmt(LogLevel level, const char *ctx, const char *fmt, Span<const FmtArg>
 
     char ctx_buf[512];
     if (log_times) {
-        double time = (double)(GetMonotonicTime() - start_time) / 1000;
-        Fmt(ctx_buf, "[%1] %2", FmtDouble(time, 3).Pad(-8), ctx ? ctx : "");
+        double time = (double)(GetMonotonicClock() - start_clock) / 1000;
+        Fmt(ctx_buf, "[%1] %2", FmtDouble(time, 3, 8), ctx ? ctx : "");
 
         ctx = ctx_buf;
     }
@@ -2383,13 +2482,13 @@ void DefaultProgressHandler(Span<const ProgressInfo> bars)
                 int progress = (int)(100 * delta / range);
                 int size = progress / 4;
 
-                buf.len += Fmt(buf.TakeAvailable(), true, "%!..+[%1%2]%!0  %3\n", FmtArg('=').Repeat(size), FmtArg(' ').Repeat(25 - size), bar.text).len;
+                buf.len += Fmt(buf.TakeAvailable(), true, "%!..+[%1%2]%!0  %3\n", FmtRepeat("=", size), FmtRepeat(" ", 25 - size), bar.text).len;
             } else {
                 int progress = (int)(frame % 44);
                 int before = (progress > 22) ? (44 - progress) : progress;
                 int after = std::max(22 - before, 0);
 
-                buf.len += Fmt(buf.TakeAvailable(), true, "%!..+[%1===%2]%!0  %3\n", FmtArg(' ').Repeat(before), FmtArg(' ').Repeat(after), bar.text).len;
+                buf.len += Fmt(buf.TakeAvailable(), true, "%!..+[%1===%2]%!0  %3\n", FmtRepeat(" ", before), FmtRepeat(" ", after), bar.text).len;
             }
         }
 
@@ -2668,7 +2767,7 @@ bool ResizeFile(int fd, const char *filename, int64_t len)
     return true;
 }
 
-bool SetFileMetaData(int fd, const char *filename, int64_t mtime, int64_t btime, uint32_t)
+bool SetFileTimes(int fd, const char *filename, int64_t mtime, int64_t btime)
 {
     HANDLE h = (HANDLE)_get_osfhandle(fd);
 
@@ -3117,25 +3216,61 @@ bool ResizeFile(int fd, const char *filename, int64_t len)
     return true;
 }
 
-bool SetFileMetaData(int fd, const char *filename, int64_t mtime, int64_t, uint32_t mode)
+bool SetFileMode(int fd, const char *filename, uint32_t mode)
+{
+    if (fd >= 0) {
+        if (fchmod(fd, (mode_t)mode) < 0) {
+            LogError("Failed to set permissions of '%1': %2", filename, strerror(errno));
+            return false;
+        }
+    } else {
+        if (fchmodat(AT_FDCWD, filename, (mode_t)mode, AT_SYMLINK_NOFOLLOW) < 0) {
+            LogError("Failed to set permissions of '%1': %2", filename, strerror(errno));
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool SetFileOwner(int fd, const char *filename, uint32_t uid, uint32_t gid)
+{
+    if (fd >= 0) {
+        if (fchown(fd, (uid_t)uid, (gid_t)gid) < 0) {
+            LogError("Failed to change owner of '%1': %2", filename, strerror(errno));
+            return false;
+        }
+    } else {
+        if (lchown(filename, (uid_t)uid, (gid_t)gid) < 0) {
+            LogError("Failed to change owner of '%1': %2", filename, strerror(errno));
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool SetFileTimes(int fd, const char *filename, int64_t mtime, int64_t)
 {
     struct timespec times[2] = {};
-    bool valid = true;
 
     times[0].tv_nsec = UTIME_OMIT;
     times[1].tv_sec = mtime / 1000;
     times[1].tv_nsec = (mtime % 1000) * 1000000;
 
-    if (futimens(fd, times) < 0) {
-        LogError("Failed to set modification time of '%1': %2", filename, filename);
-        valid = false;
-    }
-    if (fchmod(fd, (mode_t)mode) < 0) {
-        LogError("Failed to set permissions of '%1'", filename);
-        valid = false;
+    if (fd >= 0) {
+        if (futimens(fd, times) < 0) {
+            LogError("Failed to set modification time of '%1': %2", filename, strerror(errno));
+            return false;
+        }
+    } else {
+        if (utimensat(AT_FDCWD, filename, times, AT_SYMLINK_NOFOLLOW) < 0) {
+            LogError("Failed to set modification time of '%1': %2", filename, strerror(errno));
+            return false;
+        }
     }
 
-    return valid;
+    return true;
 }
 
 #if !defined(__wasm__)
@@ -3748,7 +3883,7 @@ const char *GetApplicationExecutable()
 
         size_t argc;
         {
-            int ret = sysctl(name, K_LEN(name), nullptr, &argc, NULL, 0);
+            int ret = sysctl(name, K_LEN(name), nullptr, &argc, nullptr, 0);
             K_ASSERT(ret >= 0);
             K_ASSERT(argc >= 1);
         }
@@ -3783,7 +3918,7 @@ const char *GetApplicationExecutable()
         int name[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
         size_t len = sizeof(executable_path);
 
-        int ret = sysctl(name, K_LEN(name), executable_path, &len, NULL, 0);
+        int ret = sysctl(name, K_LEN(name), executable_path, &len, nullptr, 0);
         K_ASSERT(ret >= 0);
         K_ASSERT(len < K_SIZE(executable_path));
     }
@@ -3852,13 +3987,6 @@ Span<const char> GetPathExtension(Span<const char> filename, CompressionType *ou
     return extension;
 }
 
-CompressionType GetPathCompression(Span<const char> filename)
-{
-    CompressionType compression_type;
-    GetPathExtension(filename, &compression_type);
-    return compression_type;
-}
-
 Span<char> NormalizePath(Span<const char> path, Span<const char> root_directory, unsigned int flags, Allocator *alloc)
 {
     K_ASSERT(alloc);
@@ -3866,6 +3994,21 @@ Span<char> NormalizePath(Span<const char> path, Span<const char> root_directory,
     if (!path.len && !root_directory.len)
         return Fmt(alloc, "");
 
+#if !defined(_WIN32)
+    if (!(flags & (int)NormalizeFlag::NoExpansion)) {
+        Span<const char> prefix = SplitStrAny(path, K_PATH_SEPARATORS);
+
+        if (prefix == "~") {
+            const char *home = GetEnv("HOME");
+
+            if (home) {
+                root_directory = home;
+                path = TrimStrLeft(path.Take(1, path.len - 1), K_PATH_SEPARATORS);
+            }
+        }
+    }
+#endif
+
     HeapArray<char> buf(alloc);
     Size parts_count = 0;
 
@@ -3906,15 +4049,17 @@ Span<char> NormalizePath(Span<const char> path, Span<const char> root_directory,
 
     if (!buf.len) {
         buf.Append('.');
+
+        if (flags & (int)NormalizeFlag::EndWithSeparator) {
+            buf.Append(separator);
+        }
     } else if (buf.len == 1 && IsPathSeparator(buf[0])) {
-        // Root '/', keep as-is
-    } else {
+        // Root '/', keep as-is or almost
+        buf[0] = separator;
+    } else if (!(flags & (int)NormalizeFlag::EndWithSeparator)) {
         // Strip last separator
         buf.len--;
     }
-    if (flags & (int)NormalizeFlag::EndWithSeparator) {
-        buf.Append(separator);
-    }
 
 #if defined(_WIN32)
     if (buf.len >= 2 && IsAsciiAlpha(buf[0]) && buf[1] == ':') {
@@ -3961,6 +4106,20 @@ bool PathContainsDotDot(const char *path)
     return false;
 }
 
+bool PathContainsDotDot(Span<const char> path)
+{
+    const char *ptr = path.ptr;
+    const char *end = path.end();
+
+    while ((ptr = (const char *)MemMem(ptr, end - ptr, "..", 2))) {
+        if ((ptr == path.ptr || IsPathSeparator(ptr[-1])) && (ptr + 2 == end || IsPathSeparator(ptr[2])))
+            return true;
+        ptr += 2;
+    }
+
+    return false;
+}
+
 static bool CheckForDumbTerm()
 {
     static bool dumb = ([]() {
@@ -4777,6 +4936,7 @@ bool EnsureDirectoryExists(const char *filename)
 
 #if defined(_WIN32)
 
+static const DWORD main_thread = GetCurrentThreadId();
 static HANDLE console_ctrl_event = CreateEvent(nullptr, TRUE, FALSE, nullptr);
 static bool ignore_ctrl_event = false;
 
@@ -4811,7 +4971,7 @@ bool CreateOverlappedPipe(bool overlap0, bool overlap1, PipeMode mode, HANDLE ou
 
     char pipe_name[128];
     do {
-        Fmt(pipe_name, "\\\\.\\Pipe\\libcc.%1.%2",
+        Fmt(pipe_name, "\\\\.\\pipe\\kcc.%1.%2",
             GetCurrentProcessId(), InterlockedIncrement(&pipe_idx));
 
         DWORD open_mode = PIPE_ACCESS_INBOUND | FILE_FLAG_FIRST_PIPE_INSTANCE | (overlap0 ? FILE_FLAG_OVERLAPPED : 0);
@@ -5138,12 +5298,11 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
 
 #else
 
-#if defined(__OpenBSD__) || defined(__FreeBSD__)
 static const pthread_t main_thread = pthread_self();
-#endif
+
 static std::atomic_bool flag_signal { false };
 static std::atomic_int explicit_signal { 0 };
-static int interrupt_pfd[2] = {-1, -1};
+static std::atomic_int interrupt_pfd[2] { -1, -1 };
 
 void SetSignalHandler(int signal, void (*func)(int), struct sigaction *prev)
 {
@@ -5158,19 +5317,17 @@ void SetSignalHandler(int signal, void (*func)(int), struct sigaction *prev)
 
 static void DefaultSignalHandler(int signal)
 {
-#if defined(__OpenBSD__) || defined(__FreeBSD__)
-    if (!pthread_main_np()) {
+    if (pthread_self() != main_thread) {
         pthread_kill(main_thread, signal);
         return;
     }
-#endif
 
     pid_t pid = getpid();
     K_ASSERT(pid > 1);
 
-    if (interrupt_pfd[1] >= 0) {
+    if (int fd = interrupt_pfd[1].load(); fd >= 0) {
         char dummy = 0;
-        K_IGNORE write(interrupt_pfd[1], &dummy, 1);
+        K_IGNORE write(fd, &dummy, 1);
     }
 
     if (flag_signal) {
@@ -5181,26 +5338,30 @@ static void DefaultSignalHandler(int signal)
     }
 }
 
-bool CreatePipe(int pfd[2])
+bool CreatePipe(bool block, int out_pfd[2])
 {
 #if defined(__APPLE__)
-    if (pipe(pfd) < 0) {
+    if (pipe(out_pfd) < 0) {
         LogError("Failed to create pipe: %1", strerror(errno));
         return false;
     }
 
-    if (fcntl(pfd[0], F_SETFD, FD_CLOEXEC) < 0 || fcntl(pfd[1], F_SETFD, FD_CLOEXEC) < 0) {
+    if (fcntl(out_pfd[0], F_SETFD, FD_CLOEXEC) < 0 || fcntl(out_pfd[1], F_SETFD, FD_CLOEXEC) < 0) {
         LogError("Failed to set FD_CLOEXEC on pipe: %1", strerror(errno));
         return false;
     }
-    if (fcntl(pfd[0], F_SETFL, O_NONBLOCK) < 0 || fcntl(pfd[1], F_SETFL, O_NONBLOCK) < 0) {
-        LogError("Failed to set O_NONBLOCK on pipe: %1", strerror(errno));
-        return false;
+    if (!block) {
+        if (fcntl(out_pfd[0], F_SETFL, O_NONBLOCK) < 0 || fcntl(out_pfd[1], F_SETFL, O_NONBLOCK) < 0) {
+            LogError("Failed to set O_NONBLOCK on pipe: %1", strerror(errno));
+            return false;
+        }
     }
 
     return true;
 #else
-    if (pipe2(pfd, O_CLOEXEC | O_NONBLOCK) < 0)  {
+    int flags = O_CLOEXEC | (block ? 0 : O_NONBLOCK);
+
+    if (pipe2(out_pfd, flags) < 0)  {
         LogError("Failed to create pipe: %1", strerror(errno));
         return false;
     }
@@ -5218,6 +5379,28 @@ void CloseDescriptorSafe(int *fd_ptr)
     *fd_ptr = -1;
 }
 
+static void InitInterruptPipe()
+{
+    static bool success = ([]() {
+        static int pfd[2];
+
+        if (!CreatePipe(false, pfd))
+            return false;
+
+        atexit([]() {
+            CloseDescriptor(pfd[0]);
+            CloseDescriptor(pfd[1]);
+        });
+
+        interrupt_pfd[0] = pfd[0];
+        interrupt_pfd[1] = pfd[1];
+
+        return true;
+    })();
+
+    K_CRITICAL(success, "Failed to create interrupt pipe");
+}
+
 bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                         FunctionRef<Span<const uint8_t>()> in_func,
                         FunctionRef<void(Span<uint8_t> buf)> out_func, int *out_code)
@@ -5231,12 +5414,8 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
         CloseDescriptorSafe(&in_pfd[1]);
     };
     if (in_func.IsValid()) {
-        if (!CreatePipe(in_pfd))
-            return false;
-        if (fcntl(in_pfd[1], F_SETFL, O_NONBLOCK) < 0) {
-            LogError("Failed to set O_NONBLOCK on pipe: %1", strerror(errno));
+        if (!CreatePipe(false, in_pfd))
             return false;
-        }
     }
 
     // Create write pipes
@@ -5246,33 +5425,11 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
         CloseDescriptorSafe(&out_pfd[1]);
     };
     if (out_func.IsValid()) {
-        if (!CreatePipe(out_pfd))
-            return false;
-        if (fcntl(out_pfd[0], F_SETFL, O_NONBLOCK) < 0) {
-            LogError("Failed to set O_NONBLOCK on pipe: %1", strerror(errno));
+        if (!CreatePipe(false, out_pfd))
             return false;
-        }
     }
 
-    // Create child termination pipe
-    {
-        static bool success = ([]() {
-            if (!CreatePipe(interrupt_pfd))
-                return false;
-
-            atexit([]() {
-                CloseDescriptorSafe(&interrupt_pfd[0]);
-                CloseDescriptorSafe(&interrupt_pfd[1]);
-            });
-
-            return true;
-        })();
-
-        if (!success) {
-            LogError("Failed to create termination pipe");
-            return false;
-        }
-    }
+    InitInterruptPipe();
 
     // Prepare new environment (if needed)
     HeapArray<char *> new_env;
@@ -5345,9 +5502,9 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
             out_idx = pfds.len;
             pfds.Append({ out_pfd[0], POLLIN, 0 });
         }
-        if (interrupt_pfd[0] >= 0) {
+        if (int fd = interrupt_pfd[0].load(); fd >= 0) {
             term_idx = pfds.len;
-            pfds.Append({ interrupt_pfd[0], POLLIN, 0 });
+            pfds.Append({ fd, POLLIN, 0 });
         }
 
         if (K_RESTART_EINTR(poll(pfds.data, (nfds_t)pfds.len, -1), < 0) < 0) {
@@ -5422,7 +5579,7 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
     // Wait for process exit
     int status;
     {
-        int64_t start = GetMonotonicTime();
+        int64_t start = GetMonotonicClock();
 
         for (;;) {
             int ret = K_RESTART_EINTR(waitpid(pid, &status, terminate ? WNOHANG : 0), < 0);
@@ -5431,7 +5588,7 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                 LogError("Failed to wait for process exit: %1", strerror(errno));
                 return false;
             } else if (!ret) {
-                int64_t delay = GetMonotonicTime() - start;
+                int64_t delay = GetMonotonicClock() - start;
 
                 if (delay < 2000) {
                     // A timeout on waitpid would be better, but... sigh
@@ -5575,9 +5732,9 @@ WaitResult WaitEvents(Span<const WaitSource> sources, int64_t timeout, uint64_t
 
     LocalArray<HANDLE, 64> events;
     DWORD wake = 0;
+    DWORD wait_ret = 0;
 
     events.Append(console_ctrl_event);
-    events.Append(wait_msg_event);
 
     // There is no way to get a waitable HANDLE for the Win32 GUI message pump.
     // Instead, waitable sources (such as the system tray code) return NULL to indicate that
@@ -5592,6 +5749,11 @@ WaitResult WaitEvents(Span<const WaitSource> sources, int64_t timeout, uint64_t
         timeout = (int64_t)std::min((uint64_t)timeout, (uint64_t)src.timeout);
     }
 
+    if (main_thread == GetCurrentThreadId()) {
+        wait_ret = WAIT_OBJECT_0 + (DWORD)events.len;
+        events.Append(wait_msg_event);
+    }
+
     DWORD ret;
     if (timeout >= 0) {
         do {
@@ -5604,34 +5766,31 @@ WaitResult WaitEvents(Span<const WaitSource> sources, int64_t timeout, uint64_t
         ret = MsgWaitForMultipleObjects((DWORD)events.len, events.data, FALSE, INFINITE, wake);
     }
 
-    switch (ret) {
-        case WAIT_OBJECT_0: return WaitResult::Interrupt;
-        case WAIT_OBJECT_0 + 1: {
-            ResetEvent(wait_msg_event);
-            return WaitResult::Message;
-        } break;
-        default: {
-            if (ret == WAIT_OBJECT_0 + events.len) {
-                // Mark all sources with an interest in the message pump as ready
-                if (out_ready) {
-                    uint64_t flags = 0;
-                    for (Size i = 0; i < sources.len; i++) {
-                        flags |= !sources[i].handle ? (1ull << i) : 0;
-                    }
-                    *out_ready = flags;
-                }
-                return WaitResult::Ready;
+    if (ret == WAIT_TIMEOUT) {
+        return WaitResult::Timeout;
+    } else if (ret == WAIT_OBJECT_0) {
+        return WaitResult::Interrupt;
+    } else if (ret == wait_ret) {
+        ResetEvent(wait_msg_event);
+        return WaitResult::Message;
+    } else if (ret == WAIT_OBJECT_0 + events.len) {
+        // Mark all sources with an interest in the message pump as ready
+        if (out_ready) {
+            uint64_t flags = 0;
+            for (Size i = 0; i < sources.len; i++) {
+                flags |= !sources[i].handle ? (1ull << i) : 0;
             }
+            *out_ready = flags;
+        }
+        return WaitResult::Ready;
+    } else {
+        Size idx = (Size)ret - WAIT_OBJECT_0 - 1;
+        K_ASSERT(idx >= 0 && idx < sources.len);
 
-            Size idx = (Size)ret - WAIT_OBJECT_0 - 2;
-            K_ASSERT(idx >= 0 && idx < sources.len);
-
-            if (out_ready) {
-                *out_ready |= 1ull << idx;
-            }
-            return WaitResult::Ready;
-        } break;
-        case WAIT_TIMEOUT: return WaitResult::Timeout;
+        if (out_ready) {
+            *out_ready |= 1ull << idx;
+        }
+        return WaitResult::Ready;
     }
 }
 
@@ -5641,11 +5800,16 @@ WaitResult WaitEvents(int64_t timeout)
     return WaitEvents(sources, timeout);
 }
 
-void InterruptWait()
+void PostWaitMessage()
 {
     SetEvent(wait_msg_event);
 }
 
+void PostTerminate()
+{
+    SetEvent(console_ctrl_event);
+}
+
 #else
 
 void WaitDelay(int64_t delay)
@@ -5669,19 +5833,25 @@ void WaitDelay(int64_t delay)
 WaitResult WaitEvents(Span<const WaitSource> sources, int64_t timeout, uint64_t *out_ready)
 {
     LocalArray<struct pollfd, 64> pfds;
-    K_ASSERT(sources.len <= K_LEN(pfds.data));
-
-    static std::atomic_bool message { false };
+    K_ASSERT(sources.len <= K_LEN(pfds.data) - 1);
 
+    // Don't exit after SIGINT/SIGTERM, just signal us
     flag_signal = true;
+
+    static std::atomic_bool message { false };
     SetSignalHandler(SIGUSR1, [](int) { message = true; });
 
     for (const WaitSource &src: sources) {
-        pfds.Append({ src.fd, (short)src.events, 0 });
+        short events = src.events ? (short)src.events : POLLIN;
+        pfds.Append({ src.fd, events, 0 });
+
         timeout = (int64_t)std::min((uint64_t)timeout, (uint64_t)src.timeout);
     }
 
-    int64_t start = (timeout >= 0) ? GetMonotonicTime() : 0;
+    InitInterruptPipe();
+    pfds.Append({ interrupt_pfd[0], POLLIN, 0 });
+
+    int64_t start = (timeout >= 0) ? GetMonotonicClock() : 0;
     int64_t until = start + timeout;
     int timeout32 = (int)std::min(until - start, (int64_t)INT_MAX);
 
@@ -5690,7 +5860,7 @@ WaitResult WaitEvents(Span<const WaitSource> sources, int64_t timeout, uint64_t
             return WaitResult::Exit;
         } else if (explicit_signal) {
             return WaitResult::Interrupt;
-        } else if (message) {
+        } else if (message && pthread_self() == main_thread) {
             message = false;
             return WaitResult::Message;
         }
@@ -5702,23 +5872,26 @@ WaitResult WaitEvents(Span<const WaitSource> sources, int64_t timeout, uint64_t
                 continue;
 
             LogError("Failed to poll for events: %1", strerror(errno));
-            return WaitResult::Error;
+            abort();
         } else if (ready > 0) {
-            if (out_ready) {
-                uint64_t flags = 0;
-                for (Size i = 0; i < pfds.len; i++) {
-                    flags |= pfds[i].revents ? (1ull << i) : 0;
+            uint64_t flags = 0;
+            for (Size i = 0; i < pfds.len - 1; i++) {
+                flags |= pfds[i].revents ? (1ull << i) : 0;
+            }
+
+            if (flags) {
+                if (out_ready) {
+                    *out_ready = flags;
                 }
-                *out_ready = flags;
+                return WaitResult::Ready;
             }
-            return WaitResult::Ready;
         }
 
         if (timeout >= 0) {
-            int64_t now = GetMonotonicTime();
-            if (now >= until)
+            int64_t clock = GetMonotonicClock();
+            if (clock >= until)
                 break;
-            timeout32 = (int)std::min(until - now, (int64_t)INT_MAX);
+            timeout32 = (int)std::min(until - clock, (int64_t)INT_MAX);
         }
     }
 
@@ -5731,12 +5904,20 @@ WaitResult WaitEvents(int64_t timeout)
     return WaitEvents(sources, timeout);
 }
 
-void InterruptWait()
+void PostWaitMessage()
 {
     pid_t pid = getpid();
     kill(pid, SIGUSR1);
 }
 
+void PostTerminate()
+{
+    InitInterruptPipe();
+
+    char dummy = 0;
+    K_IGNORE write(interrupt_pfd[1], &dummy, 1);
+}
+
 #endif
 
 #endif
@@ -5837,30 +6018,30 @@ error:
 
 bool NotifySystemd()
 {
-    const char *addr_str = GetEnv("NOTIFY_SOCKET");
-    if (!addr_str)
+    const char *addr = GetEnv("NOTIFY_SOCKET");
+    if (!addr)
         return true;
 
-    struct sockaddr_un addr;
-    if (addr_str[0] == '@') {
-        addr_str++;
+    struct sockaddr_un sa;
+    if (addr[0] == '@') {
+        addr++;
 
-        if (strlen(addr_str) >= sizeof(addr.sun_path) - 1) {
+        if (strlen(addr) >= sizeof(sa.sun_path) - 1) {
             LogError("Abstract socket address in NOTIFY_SOCKET is too long");
             return false;
         }
 
-        addr.sun_family = AF_UNIX;
-        addr.sun_path[0] = 0;
-        CopyString(addr_str, MakeSpan(addr.sun_path + 1, K_SIZE(addr.sun_path) - 1));
-    } else if (addr_str[0] == '/') {
-        if (strlen(addr_str) >= sizeof(addr.sun_path)) {
+        sa.sun_family = AF_UNIX;
+        sa.sun_path[0] = 0;
+        CopyString(addr, MakeSpan(sa.sun_path + 1, K_SIZE(sa.sun_path) - 1));
+    } else if (addr[0] == '/') {
+        if (strlen(addr) >= sizeof(sa.sun_path)) {
             LogError("Socket pathname in NOTIFY_SOCKET is too long");
             return false;
         }
 
-        addr.sun_family = AF_UNIX;
-        CopyString(addr_str, addr.sun_path);
+        sa.sun_family = AF_UNIX;
+        CopyString(addr, sa.sun_path);
     } else {
         LogError("Invalid socket address in NOTIFY_SOCKET");
         return false;
@@ -5877,8 +6058,8 @@ bool NotifySystemd()
     struct msghdr msg = {};
     iov.iov_base = (void *)"READY=1";
     iov.iov_len = strlen("READY=1");
-    msg.msg_name = &addr;
-    msg.msg_namelen = offsetof(struct sockaddr_un, sun_path) + strlen(addr_str);
+    msg.msg_name = &sa;
+    msg.msg_namelen = offsetof(struct sockaddr_un, sun_path) + strlen(addr);
     msg.msg_iov = &iov;
     msg.msg_iovlen = 1;
 
@@ -5927,25 +6108,13 @@ void InitApp()
 #endif
 
 #if !defined(_WIN32) && !defined(__wasi__)
-    // Best effort
-    setpgid(0, 0);
-
     // Setup default signal handlers
     SetSignalHandler(SIGINT, DefaultSignalHandler);
     SetSignalHandler(SIGTERM, DefaultSignalHandler);
     SetSignalHandler(SIGHUP, DefaultSignalHandler);
     SetSignalHandler(SIGPIPE, [](int) {});
 
-    // Kill children on exit
-    atexit([]() {
-        if (interrupt_pfd[1] >= 0) {
-            pid_t pid = getpid();
-            K_ASSERT(pid > 1);
-
-            SetSignalHandler(SIGTERM, [](int) {});
-            kill(-pid, SIGTERM);
-        }
-    });
+    InitInterruptPipe();
 
     // Make sure timezone information is in place, which is useful if some kind of sandbox runs later and
     // the timezone information is not available (seccomp, namespace, landlock, whatever).
@@ -6586,7 +6755,7 @@ bool ParseVersion(Span<const char> str, int parts, int multiplier,
 // ------------------------------------------------------------------------
 
 static thread_local Size rnd_remain;
-static thread_local int64_t rnd_time;
+static thread_local int64_t rnd_clock;
 #if !defined(_WIN32)
 static thread_local pid_t rnd_pid;
 #endif
@@ -6699,7 +6868,7 @@ void FillRandomSafe(void *out_buf, Size len)
 
     // Reseed every 4 megabytes, or every hour, or after a fork
     reseed |= (rnd_remain <= 0);
-    reseed |= (GetMonotonicTime() - rnd_time > 3600 * 1000);
+    reseed |= (GetMonotonicClock() - rnd_clock > 3600 * 1000);
 #if !defined(_WIN32)
     reseed |= (getpid() != rnd_pid);
 #endif
@@ -6727,7 +6896,7 @@ restart:
         ZeroSafe(&buf, K_SIZE(buf));
 
         rnd_remain = Mebibytes(4);
-        rnd_time = GetMonotonicTime();
+        rnd_clock = GetMonotonicClock();
 #if !defined(_WIN32)
         rnd_pid = getpid();
 #endif
@@ -6981,39 +7150,65 @@ int CreateSocket(SocketType type, int flags)
 
 #endif
 
-bool BindIPSocket(int sock, SocketType type, int port)
+bool BindIPSocket(int sock, SocketType type, const char *addr, int port)
 {
     K_ASSERT(type == SocketType::Dual || type == SocketType::IPv4 || type == SocketType::IPv6);
 
     if (type == SocketType::IPv4) {
-        struct sockaddr_in addr = {};
+        struct sockaddr_in sa = {};
+
+        sa.sin_family = AF_INET;
+        sa.sin_port = htons((uint16_t)port);
 
-        addr.sin_family = AF_INET;
-        addr.sin_port = htons((uint16_t)port);
-        addr.sin_addr.s_addr = htonl(INADDR_ANY);
+        if (addr) {
+            if (inet_pton(AF_INET, addr, &sa.sin_addr) <= 0) {
+                LogError("Invalid IPv4 address '%1'", addr);
+                return false;
+            }
+        } else {
+            sa.sin_addr.s_addr = htonl(INADDR_ANY);
+        }
 
-        if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+        if (bind(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
 #if defined(_WIN32)
-            LogError("Failed to bind to port %1: %2", port, GetWin32ErrorString());
+            LogError("Failed to bind to '%1:%2': %3", addr ? addr : "*", port, GetWin32ErrorString());
             return false;
 #else
-            LogError("Failed to bind to port %1: %2", port, strerror(errno));
+            LogError("Failed to bind to '%1:%2': %3", addr ? addr : "*", port, strerror(errno));
             return false;
 #endif
         }
     } else {
-        struct sockaddr_in6 addr = {};
+        struct sockaddr_in6 sa = {};
 
-        addr.sin6_family = AF_INET6;
-        addr.sin6_port = htons((uint16_t)port);
-        addr.sin6_addr = IN6ADDR_ANY_INIT;
+        sa.sin6_family = AF_INET6;
+        sa.sin6_port = htons((uint16_t)port);
+
+        if (addr) {
+            if (!strchr(addr, ':')) {
+                char buf[512];
+                Fmt(buf, "::FFFF:%1", addr);
+
+                if (inet_pton(AF_INET6, buf, &sa.sin6_addr) <= 0) {
+                    LogError("Invalid IPv4 or IPv6 address '%1'", addr);
+                    return false;
+                }
+            } else {
+                if (inet_pton(AF_INET6, addr, &sa.sin6_addr) <= 0) {
+                    LogError("Invalid IPv6 address '%1'", addr);
+                    return false;
+                }
+            }
+        } else {
+            sa.sin6_addr = IN6ADDR_ANY_INIT;
+        }
 
-        if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+        if (bind(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
 #if defined(_WIN32)
-            LogError("Failed to bind to port %1: %2", port, GetWin32ErrorString());
+            LogError("Failed to bind to '%1:%2': %3", addr ? addr : "*", port, GetWin32ErrorString());
             return false;
 #else
-            LogError("Failed to bind to port %1: %2", port, strerror(errno));
+            LogError("Failed to bind to '%1:%2': %3", addr ? addr : "*", port, strerror(errno));
             return false;
 #endif
         }
@@ -7024,16 +7219,32 @@ bool BindIPSocket(int sock, SocketType type, int port)
 
 bool BindUnixSocket(int sock, const char *path)
 {
-    struct sockaddr_un addr = {};
+    struct sockaddr_un sa = {};
+
+    // Protect against abtract Unix sockets on Linux
+    if (!path[0]) {
+        LogError("Cannot open empty UNIX socket");
+        return false;
+    }
 
-    addr.sun_family = AF_UNIX;
-    if (!CopyString(path, addr.sun_path)) {
+    sa.sun_family = AF_UNIX;
+    if (!CopyString(path, sa.sun_path)) {
         LogError("Excessive UNIX socket path length");
         return false;
     }
 
-    unlink(path);
-    if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+#if !defined(_WIN32)
+    // Remove existing socket (if any)
+    {
+        struct stat sb;
+        if (!stat(path, &sb) && S_ISSOCK(sb.st_mode)) {
+            LogDebug("Removing existing socket '%1'", path);
+            unlink(path);
+        }
+    }
+#endif
+
+    if (bind(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
 #if defined(_WIN32)
         LogError("Failed to bind socket to '%1': %2", path, GetWin32ErrorString());
         return false;
@@ -7042,68 +7253,82 @@ bool BindUnixSocket(int sock, const char *path)
         return false;
 #endif
     }
+
+#if !defined(_WIN32)
     chmod(path, 0666);
+#endif
 
     return true;
 }
 
-int OpenIPSocket(SocketType type, int port, int flags)
+bool ConnectIPSocket(int sock, const char *addr, int port)
 {
-    K_ASSERT(type == SocketType::Dual || type == SocketType::IPv4 || type == SocketType::IPv6);
+    if (strchr(addr, ':')) {
+        struct sockaddr_in6 sa = {};
 
-    int sock = CreateSocket(type, flags);
-    if (sock < 0)
-        return -1;
-    K_DEFER_N(err_guard) { CloseSocket(sock); };
+        sa.sin6_family = AF_INET6;
+        sa.sin6_port = htons((unsigned short)port);
 
-    if (!BindIPSocket(sock, type, port))
-        return -1;
+        if (inet_pton(AF_INET6, addr, &sa.sin6_addr) <= 0) {
+            LogError("Invalid IPv6 address '%1'", addr);
+            return false;
+        }
 
-    err_guard.Disable();
-    return sock;
-}
+        if (connect(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
+#if defined(_WIN32)
+            LogError("Failed to connect to '%1' (%2): %3", addr, port, GetWin32ErrorString());
+            return false;
+#else
+            LogError("Failed to connect to '%1' (%2): %3", addr, port, strerror(errno));
+            return false;
+#endif
+        }
+    } else {
+        struct sockaddr_in sa = {};
 
-int OpenUnixSocket(const char *path, int flags)
-{
-    int sock = CreateSocket(SocketType::Unix, flags);
-    if (sock < 0)
-        return -1;
-    K_DEFER_N(err_guard) { CloseSocket(sock); };
+        sa.sin_family = AF_INET;
+        sa.sin_port = htons((unsigned short)port);
 
-    if (!BindUnixSocket(sock, path))
-        return -1;
+        if (inet_pton(AF_INET, addr, &sa.sin_addr) <= 0) {
+            LogError("Invalid IPv4 address '%1'", addr);
+            return false;
+        }
 
-    err_guard.Disable();
-    return sock;
+        if (connect(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
+#if defined(_WIN32)
+            LogError("Failed to connect to '%1' (%2): %3", addr, port, GetWin32ErrorString());
+            return false;
+#else
+            LogError("Failed to connect to '%1' (%2): %3", addr, port, strerror(errno));
+            return false;
+#endif
+        }
+    }
+
+    return true;
 }
 
-int ConnectToUnixSocket(const char *path, int flags)
+bool ConnectUnixSocket(int sock, const char *path)
 {
-    struct sockaddr_un addr = {};
+    struct sockaddr_un sa = {};
 
-    addr.sun_family = AF_UNIX;
-    if (!CopyString(path, addr.sun_path)) {
+    sa.sun_family = AF_UNIX;
+    if (!CopyString(path, sa.sun_path)) {
         LogError("Excessive UNIX socket path length");
-        return -1;
+        return false;
     }
 
-    int sock = CreateSocket(SocketType::Unix, flags);
-    if (sock < 0)
-        return -1;
-    K_DEFER_N(err_guard) { CloseSocket(sock); };
-
-    if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+    if (connect(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
 #if defined(_WIN32)
-        LogError("Failed to connect to '%1': %2", path, GetWin32ErrorString());
-        return -1;
+        LogError("Failed to connect to UNIX socket '%1': %2", path, GetWin32ErrorString());
+        return false;
 #else
-        LogError("Failed to connect to '%1': %2", path, strerror(errno));
-        return -1;
+        LogError("Failed to connect to UNIX socket '%1': %2", path, strerror(errno));
+        return false;
 #endif
     }
 
-    err_guard.Disable();
-    return sock;
+    return true;
 }
 
 void SetDescriptorNonBlock(int fd, bool enable)
@@ -7613,14 +7838,12 @@ void StreamReader::SetDecoder(StreamDecoder *decoder)
     this->decoder = decoder;
 }
 
-bool StreamReader::Open(Span<const uint8_t> buf, const char *filename, unsigned int flags,
-                        CompressionType compression_type)
+bool StreamReader::Open(Span<const uint8_t> buf, const char *filename, CompressionType compression_type)
 {
     Close(true);
 
     K_DEFER_N(err_guard) { error = true; };
 
-    lazy = flags & (int)StreamReaderFlag::LazyFill;
     error = false;
     raw_read = 0;
     read_total = 0;
@@ -7640,13 +7863,12 @@ bool StreamReader::Open(Span<const uint8_t> buf, const char *filename, unsigned
     return true;
 }
 
-bool StreamReader::Open(int fd, const char *filename, unsigned int flags, CompressionType compression_type)
+bool StreamReader::Open(int fd, const char *filename, CompressionType compression_type)
 {
     Close(true);
 
     K_DEFER_N(err_guard) { error = true; };
 
-    lazy = flags & (int)StreamReaderFlag::LazyFill;
     error = false;
     raw_read = 0;
     read_total = 0;
@@ -7667,13 +7889,12 @@ bool StreamReader::Open(int fd, const char *filename, unsigned int flags, Compre
     return true;
 }
 
-OpenResult StreamReader::Open(const char *filename, unsigned int flags, CompressionType compression_type)
+OpenResult StreamReader::Open(const char *filename, CompressionType compression_type)
 {
     Close(true);
 
     K_DEFER_N(err_guard) { error = true; };
 
-    lazy = flags & (int)StreamReaderFlag::LazyFill;
     error = false;
     raw_read = 0;
     read_total = 0;
@@ -7697,14 +7918,12 @@ OpenResult StreamReader::Open(const char *filename, unsigned int flags, Compress
     return OpenResult::Success;
 }
 
-bool StreamReader::Open(const std::function<Size(Span<uint8_t>)> &func, const char *filename, unsigned int flags,
-                        CompressionType compression_type)
+bool StreamReader::Open(const std::function<Size(Span<uint8_t>)> &func, const char *filename, CompressionType compression_type)
 {
     Close(true);
 
     K_DEFER_N(err_guard) { error = true; };
 
-    lazy = flags & (int)StreamReaderFlag::LazyFill;
     error = false;
     raw_read = 0;
     read_total = 0;
@@ -7748,7 +7967,6 @@ bool StreamReader::Close(bool implicit)
     bool ret = !filename || !error;
 
     filename = nullptr;
-    lazy = false;
     error = true;
     source.type = SourceType::Memory;
     source.eof = false;
@@ -7807,6 +8025,40 @@ void StreamReader::SetDescriptorOwned(bool owned)
 
 Size StreamReader::Read(Span<uint8_t> out_buf)
 {
+#if !defined(__wasm__)
+    std::lock_guard<std::mutex> lock(mutex);
+#endif
+
+    if (error) [[unlikely]]
+        return -1;
+
+    Size len = 0;
+
+    if (decoder) {
+        len = decoder->Read(out_buf.len, out_buf.ptr);
+        if (len < 0) [[unlikely]] {
+            error = true;
+            return -1;
+        }
+    } else {
+        len = ReadRaw(out_buf.len, out_buf.ptr);
+        if (len < 0) [[unlikely]]
+            return -1;
+        eof = source.eof;
+    }
+
+    if (!error && read_max >= 0 && len > read_max - read_total) [[unlikely]] {
+        LogError("Exceeded max stream size of %1", FmtDiskSize(read_max));
+        error = true;
+        return -1;
+    }
+
+    read_total += len;
+    return len;
+}
+
+Size StreamReader::ReadFill(Span<uint8_t> out_buf)
+{
 #if !defined(__wasm__)
     std::lock_guard<std::mutex> lock(mutex);
 #endif
@@ -7842,7 +8094,7 @@ Size StreamReader::Read(Span<uint8_t> out_buf)
             return -1;
         }
 
-        if (lazy || eof)
+        if (eof)
             break;
     }
 
@@ -7883,10 +8135,10 @@ Size StreamReader::ReadAll(Size max_len, HeapArray<uint8_t> *out_buf)
         // who need/want to append a NUL character.
         out_buf->Grow((Size)raw_len + 1);
 
-        Size read_len = Read((Size)raw_len, out_buf->end());
+        Size read_len = ReadFill(out_buf->TakeAvailable());
         if (read_len < 0)
             return -1;
-        out_buf->len += read_len;
+        out_buf->len += (Size)std::min(raw_len, (int64_t)read_len);
 
         buf_guard.Disable();
         return read_len;
@@ -7897,7 +8149,7 @@ Size StreamReader::ReadAll(Size max_len, HeapArray<uint8_t> *out_buf)
             Size grow = std::min(total_len ? Megabytes(1) : Kibibytes(64), K_SIZE_MAX - out_buf->len);
             out_buf->Grow(grow);
 
-            Size read_len = Read(out_buf->Available(), out_buf->end());
+            Size read_len = Read(out_buf->TakeAvailable());
             if (read_len < 0)
                 return -1;
 
@@ -8032,7 +8284,9 @@ bool LineReader::Next(Span<char> *out_line)
         if (!view.len) {
             buf.Grow(K_LINE_READER_STEP_SIZE + 1);
 
-            Size read_len = st->Read(K_LINE_READER_STEP_SIZE, buf.end());
+            Span<char> available = MakeSpan(buf.end(), K_LINE_READER_STEP_SIZE);
+
+            Size read_len = st->Read(available);
             if (read_len < 0) {
                 error = true;
                 return false;
@@ -8960,7 +9214,7 @@ bool PatchFile(Span<const uint8_t> data, StreamWriter *writer,
 bool PatchFile(const AssetInfo &asset, StreamWriter *writer,
                FunctionRef<void(Span<const char>, StreamWriter *)> func)
 {
-    StreamReader reader(asset.data, "<asset>", 0, asset.compression_type);
+    StreamReader reader(asset.data, "<asset>", asset.compression_type);
 
     if (!PatchFile(&reader, writer, func)) {
         K_ASSERT(reader.IsValid());
@@ -9025,12 +9279,14 @@ static HeapArray<TranslationTable> i18n_tables;
 static NoDestroy<HeapArray<TranslationMap>> i18n_maps;
 static HashMap<Span<const char> , const TranslationTable *> i18n_locales;
 
-static const TranslationMap *i18n_default;
-static thread_local const TranslationMap *i18n_thread = i18n_default;
+static const TranslationTable *i18n_default_table;
+static const TranslationMap *i18n_default_map;
+static thread_local const TranslationTable *i18n_thread_table = i18n_default_table;
+static thread_local const TranslationMap *i18n_thread_map = i18n_default_map;
 
-static void SetDefaultLocale()
+static void SetDefaultLocale(const char *default_lang)
 {
-    if (i18n_default)
+    if (i18n_default_table)
         return;
 
     // Obey environment settings, even on Windows, for easy override
@@ -9043,9 +9299,11 @@ static void SetDefaultLocale()
 
             if (env) {
                 ChangeThreadLocale(env);
-                i18n_default = i18n_thread;
 
-                if (i18n_default)
+                i18n_default_table = i18n_thread_table;
+                i18n_default_map = i18n_thread_map;
+
+                if (i18n_default_table)
                     return;
             }
         }
@@ -9063,9 +9321,11 @@ static void SetDefaultLocale()
                 ConvertWin32WideToUtf8(buffer, lang);
 
                 ChangeThreadLocale(lang);
-                i18n_default = i18n_thread;
 
-                if (i18n_default)
+                i18n_default_table = i18n_thread_table;
+                i18n_default_map = i18n_thread_map;
+
+                if (i18n_default_table)
                     return;
             }
         } else {
@@ -9073,9 +9333,15 @@ static void SetDefaultLocale()
         }
     }
 #endif
+
+    ChangeThreadLocale(default_lang);
+    K_CRITICAL(i18n_thread_table, "Missing default locale");
+
+    i18n_default_table = i18n_thread_table;
+    i18n_default_map = i18n_thread_map;
 }
 
-void InitLocales(Span<const TranslationTable> tables)
+void InitLocales(Span<const TranslationTable> tables, const char *default_lang)
 {
     K_ASSERT(!i18n_tables.len);
 
@@ -9092,7 +9358,7 @@ void InitLocales(Span<const TranslationTable> tables)
         i18n_locales.Set(table.language, &table);
     }
 
-    SetDefaultLocale();
+    SetDefaultLocale(default_lang);
 }
 
 void ChangeThreadLocale(const char *name)
@@ -9102,18 +9368,27 @@ void ChangeThreadLocale(const char *name)
 
     if (table) {
         Size idx = table - i18n_tables.ptr;
-        i18n_thread = &(*i18n_maps)[idx];
+
+        i18n_thread_table = table;
+        i18n_thread_map = &(*i18n_maps)[idx];
     } else {
-        i18n_thread = i18n_default;
+        i18n_thread_table = i18n_default_table;
+        i18n_thread_map = i18n_default_map;
     }
 }
 
+const char *GetThreadLocale()
+{
+    K_ASSERT(i18n_thread_table);
+    return i18n_thread_table->language;
+}
+
 const char *T(const char *key)
 {
-    if (!i18n_thread)
+    if (!i18n_thread_map)
         return key;
 
-    return i18n_thread->FindValue(key, key);
+    return i18n_thread_map->FindValue(key, key);
 }
 
 // ------------------------------------------------------------------------
@@ -9509,6 +9784,10 @@ bool ConsolePrompter::ReadRaw(Span<const char> *out_str)
                         Delete(str_offset, SkipForward(str_offset, 1));
                         RenderRaw();
                     }
+                } else if (match_escape("\x1B")) { // Double escape
+                    StdErr->Write("\r\n");
+                    StdErr->Flush();
+                    return false;
                 } else if (match_escape("\x7F")) { // Alt-Backspace
                     Delete(FindBackward(str_offset, " \t\r\n"), str_offset);
                     RenderRaw();
@@ -9651,11 +9930,54 @@ bool ConsolePrompter::ReadRaw(Span<const char> *out_str)
                 return true;
             } break;
 
+            case '\t': {
+                if (complete) {
+                    BlockAllocator temp_alloc;
+                    HeapArray<CompleteChoice> choices;
+
+                    PushLogFilter([](LogLevel, const char *, const char *, FunctionRef<LogFunc>) {});
+                    K_DEFER_N(log_guard) { PopLogFilter(); };
+
+                    CompleteResult ret = complete(str, &temp_alloc, &choices);
+
+                    switch (ret) {
+                        case CompleteResult::Success: {
+                            if (choices.len == 1) {
+                                const CompleteChoice &choice = choices[0];
+
+                                str.RemoveFrom(0);
+                                str.Append(choice.value);
+                                str_offset = str.len;
+                                RenderRaw();
+                            } else if (choices.len) {
+                                for (const CompleteChoice &choice: choices) {
+                                    Print(StdErr, "\r\n  %!0%!Y..%1%!0", choice.name);
+                                }
+                                StdErr->Write("\r\n");
+
+                                RenderRaw();
+                            }
+                        } break;
+
+                        case CompleteResult::TooMany: {
+                            Print(StdErr, "\r\n  %!0%!Y..%1%!0\r\n", T("Too many possibilities to show"));
+                            RenderRaw();
+                        } break;
+                        case CompleteResult::Error: {
+                            Print(StdErr, "\r\n  %!0%!Y..%1%!0\r\n", T("Autocompletion error"));
+                            RenderRaw();
+                        } break;
+                    }
+
+                    break;
+                }
+            } [[fallthrough]];
+
             default: {
                 LocalArray<char, 16> frag;
                 if (uc == '\t') {
                     frag.Append("    ");
-                } else if (uc >= 32) {
+                } else if (!IsAsciiControl(uc)) {
                     frag.len = EncodeUtf8(uc, frag.data);
                 } else {
                     continue;
@@ -9731,6 +10053,14 @@ Size ConsolePrompter::ReadRawEnum(Span<const PromptChoice> choices, Size value)
                     fake_input = "\x10";
                 } else if (match_escape("[B")) { // Down
                     fake_input = "\x0E";
+                } else if (match_escape("\x1B")) { // Double escape
+                    if (rows > y) {
+                        Print(StdErr, "\x1B[%1B", rows - y);
+                    }
+                    StdErr->Write("\r");
+                    StdErr->Flush();
+
+                    return -1;
                 }
             } break;
 
@@ -9792,7 +10122,7 @@ bool ConsolePrompter::ReadBuffered(Span<const char> *out_str)
 
     do {
         uint8_t c = 0;
-        if (StdIn->Read(1, &c) < 0)
+        if (StdIn->Read(MakeSpan(&c, 1)) < 0)
             return false;
 
         if (c == '\n') {
@@ -9801,7 +10131,7 @@ bool ConsolePrompter::ReadBuffered(Span<const char> *out_str)
                 *out_str = str;
             }
             return true;
-        } else if (c >= 32 || c == '\t') {
+        } else if (!IsAsciiControl(c)) {
             str.Append((char)c);
         }
     } while (!StdIn->IsEOF());
@@ -9823,7 +10153,7 @@ Size ConsolePrompter::ReadBufferedEnum(Span<const PromptChoice> choices)
 
     do {
         uint8_t c = 0;
-        if (StdIn->Read(1, &c) < 0)
+        if (StdIn->Read(MakeSpan(&c, 1)) < 0)
             return -1;
 
         if (c == '\n') {
@@ -9840,7 +10170,7 @@ Size ConsolePrompter::ReadBufferedEnum(Span<const PromptChoice> choices)
 
             StdErr->Write(prefix);
             StdErr->Flush();
-        } else if (c >= 32 || c == '\t') {
+        } else if (!IsAsciiControl(c)) {
             str.Append((char)c);
         }
     } while (!StdIn->IsEOF());
@@ -9944,7 +10274,11 @@ void ConsolePrompter::FormatChoices(Span<const PromptChoice> choices, Size value
         const PromptChoice &choice = choices[i];
         int pad = align - ComputeUnicodeWidth(choice.str);
 
-        Fmt(&str, "  [%1] %2%3  ", choice.c, choice.str, FmtArg(' ').Repeat(pad));
+        if (choice.c) {
+            Fmt(&str, "  [%1] %2%3  ", choice.c, choice.str, FmtRepeat(" ", pad));
+        } else {
+            Fmt(&str, "      %1%2  ", choice.str, FmtRepeat(" ", pad));
+        }
         if (i == value) {
             str_offset = str.len;
         }
@@ -9984,7 +10318,7 @@ void ConsolePrompter::RenderRaw()
             int width = mask ? mask_columns : ComputeUnicodeWidth(str.Take(i, bytes));
 
             if (x2 + width >= columns || str[i] == '\n') {
-                FmtArg prefix = FmtArg(' ').Repeat(prompt_columns - 1);
+                FmtArg prefix = FmtRepeat(" ", prompt_columns - 1);
                 Print(StdErr, "\x1B[0K\r\n%!D.+%1%!0 %!..+", prefix);
 
                 x2 = prompt_columns;
@@ -10028,7 +10362,7 @@ void ConsolePrompter::RenderBuffered()
     Print(StdErr, "%1 %2", prompt, line);
     while (remain.len) {
         line = SplitStr(remain, '\n', &remain);
-        Print(StdErr, "\n%1%2", FmtArg(' ').Repeat(prompt_columns), line);
+        Print(StdErr, "\n%1%2", FmtRepeat(" ", prompt_columns), line);
     }
 
     StdErr->Flush();
@@ -10206,6 +10540,7 @@ const char *Prompt(const char *prompt, const char *default_value, const char *ma
 
     prompter.prompt = prompt;
     prompter.mask = mask;
+
     prompter.str.allocator = alloc;
     if (default_value) {
         prompter.str.Append(default_value);
@@ -10225,11 +10560,12 @@ Size PromptEnum(const char *prompt, Span<const PromptChoice> choices, Size value
         HashSet<char> keys;
 
         for (const PromptChoice &choice: choices) {
-            keys.Set(choice.c);
-        }
+            if (!choice.c)
+                continue;
 
-        bool duplicates = (keys.table.count < choices.len);
-        K_ASSERT(!duplicates);
+            bool duplicates = !keys.InsertOrFail(choice.c);
+            K_ASSERT(!duplicates);
+        }
     }
 #endif
 
@@ -10242,13 +10578,12 @@ Size PromptEnum(const char *prompt, Span<const PromptChoice> choices, Size value
 Size PromptEnum(const char *prompt, Span<const char *const> strings, Size value)
 {
     static const char literals[] = "123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-    K_ASSERT(strings.len <= K_LEN(literals));
 
     HeapArray<PromptChoice> choices;
 
     for (Size i = 0; i < strings.len; i++) {
         const char *str = strings[i];
-        PromptChoice choice = { literals[i], str };
+        PromptChoice choice = { str, i < K_LEN(literals) ? literals[i] : (char)0 };
 
         choices.Append(choice);
     }
@@ -10256,6 +10591,134 @@ Size PromptEnum(const char *prompt, Span<const char *const> strings, Size value)
     return PromptEnum(prompt, choices, value);
 }
 
+int PromptYN(const char *prompt)
+{
+    const char *yes = T("Yes");
+    const char *no = T("No");
+
+    const char *shortcuts = T("yn");
+    K_ASSERT(strlen(shortcuts) == 2);
+
+    Size ret = PromptEnum(prompt, {{ yes, shortcuts[0] }, { no, shortcuts[1] }});
+    if (ret < 0)
+        return -1;
+
+    return !ret;
+}
+
+const char *PromptPath(const char *prompt, const char *default_path, Span<const char> root_directory, Allocator *alloc)
+{
+    K_ASSERT(alloc);
+
+    ConsolePrompter prompter;
+
+    prompter.prompt = prompt;
+    prompter.complete = [&](Span<const char> str, Allocator *alloc, HeapArray<CompleteChoice> *out_choices) {
+        Size start_len = out_choices->len;
+        K_DEFER_N(err_guard) { out_choices->RemoveFrom(start_len); };
+
+        Span<const char> path = TrimStrRight(str, K_PATH_SEPARATORS);
+        bool separator = (path.len < str.len);
+
+        // If the value points to a directory, append separator and return
+        if (str.len && !separator) {
+            const char *filename = NormalizePath(path, root_directory, alloc).ptr;
+
+            FileInfo file_info;
+            StatResult ret = StatFile(filename, (int)StatFlag::SilentMissing | (int)StatFlag::FollowSymlink, &file_info);
+
+            if (ret == StatResult::Success && file_info.type == FileType::Directory) {
+                const char *value = Fmt(alloc, "%1%/", path).ptr;
+                out_choices->Append({ value, value });
+
+                err_guard.Disable();
+                return CompleteResult::Success;
+            }
+        }
+
+        Span<const char> directory = path;
+        Span<const char> prefix = separator ? "" : SplitStrReverseAny(path, K_PATH_SEPARATORS, &directory);
+
+        // EnumerateDirectory takes a C string, so we need the NUL terminator,
+        // and we also need to take root_dir into account.
+        const char *dirname = nullptr;
+
+        if (PathIsAbsolute(directory)) {
+            dirname = DuplicateString(directory, alloc).ptr;
+        } else {
+            if (!root_directory.len)
+                return CompleteResult::Success;
+
+            dirname = NormalizePath(directory, root_directory, alloc).ptr;
+            dirname = dirname[0] ? dirname : ".";
+        }
+
+        EnumResult ret = EnumerateDirectory(dirname, nullptr, -1, [&](const char *basename, FileType file_type) {
+#if defined(_WIN32)
+            if (!StartsWithI(basename, prefix))
+                return true;
+#else
+            if (!StartsWith(basename, prefix))
+                return true;
+#endif
+
+            if (out_choices->len - start_len >= K_COMPLETE_PATH_LIMIT)
+                return false;
+
+            CompleteChoice choice;
+            {
+                HeapArray<char> buf(alloc);
+
+                // Make directory part
+                buf.Append(directory);
+                if (directory.len && !IsPathSeparator(directory[directory.len - 1])) {
+                    buf.Append(*K_PATH_SEPARATORS);
+                }
+
+                Size name_offset = buf.len;
+
+                // Append name
+                buf.Append(basename);
+                if (file_type == FileType::Directory) {
+                    buf.Append(*K_PATH_SEPARATORS);
+                }
+                buf.Append(0);
+                buf.Trim();
+
+                choice.value = buf.Leak().ptr;
+                choice.name = choice.value + name_offset;
+            }
+
+            out_choices->Append(choice);
+            return true;
+        });
+
+        if (ret == EnumResult::CallbackFail) {
+            return CompleteResult::TooMany;
+        } else if (ret != EnumResult::Success) {
+            // Just ignore it and don't print anything
+            return CompleteResult::Success;
+        }
+
+        std::sort(out_choices->ptr + start_len, out_choices->end(),
+                  [](const CompleteChoice &choice1, const CompleteChoice &choice2) { return CmpNaturalI(choice1.name, choice2.name) < 0; });
+
+        err_guard.Disable();
+        return CompleteResult::Success;
+    };
+
+    prompter.str.allocator = alloc;
+    if (default_path) {
+        prompter.str.Append(default_path);
+    }
+
+    if (!prompter.Read())
+        return nullptr;
+
+    const char *str = NormalizePath(prompter.str, alloc).ptr;
+    return str;
+}
+
 // ------------------------------------------------------------------------
 // Mime types
 // ------------------------------------------------------------------------
@@ -10373,7 +10836,7 @@ static inline int ComputeCharacterWidth(int32_t uc)
 {
     // Fast path
     if (uc < 128)
-        return (uc >= 32) ? 1 : 0;
+        return IsAsciiControl(uc) ? 0 : 1;
 
     if (TestUnicodeTable(WcWidthNull, uc))
         return 0;