cleanup: namespace Montauk (capital M) => montauk::abi

programs/include/Api/Syscall.hpp

@@ -8,7 +8,7 @@
 #include <cstdint>
 #include <cstddef>
 
-namespace Montauk {
+namespace montauk::abi {
 
     // Syscall numbers
     static constexpr uint64_t SYS_EXIT            = 0;

programs/include/engine/engine.h

@@ -56,7 +56,7 @@ struct Engine {
         }
 
         // Create window
-        Montauk::WinCreateResult wres;
+        montauk::abi::WinCreateResult wres;
         if (montauk::win_create(title, w, h, &wres) < 0 || wres.id < 0)
             return false;
 
@@ -77,7 +77,7 @@ struct Engine {
     }
 
     // Poll one window event. Returns true if an event was received.
-    bool poll(Montauk::WinEvent* ev) {
+    bool poll(montauk::abi::WinEvent* ev) {
         int r = montauk::win_poll(win_id, ev);
         if (r < 0) { running = false; return false; }
         if (r == 0) return false;

programs/include/engine/input.h

@@ -55,7 +55,7 @@ struct InputState {
     }
 
     // Process a window event
-    void handle_event(const Montauk::WinEvent& ev) {
+    void handle_event(const montauk::abi::WinEvent& ev) {
         if (ev.type == 0) { // keyboard
             // PS/2 scan code set 1: release codes have bit 7 set.
             // Mask to base scancode so press and release map to the same index.

programs/include/gui/clipboard.hpp

@@ -22,13 +22,13 @@ namespace gui {
         return clipboard_set_text(text, text ? montauk::slen(text) : 0);
     }
 
-    inline bool clipboard_get_info(Montauk::ClipboardInfo* out) {
+    inline bool clipboard_get_info(montauk::abi::ClipboardInfo* out) {
         if (out == nullptr) return false;
         return montauk::clipboard_get_info(out) == 0;
     }
 
     inline bool clipboard_has_text() {
-        Montauk::ClipboardInfo info = {};
+        montauk::abi::ClipboardInfo info = {};
         return clipboard_get_info(&info) && info.textBytes > 0;
     }
 
@@ -36,7 +36,7 @@ namespace gui {
         if (out_len) *out_len = 0;
         if (out_serial) *out_serial = 0;
 
-        Montauk::ClipboardInfo info = {};
+        montauk::abi::ClipboardInfo info = {};
         if (!clipboard_get_info(&info) || info.textBytes == 0)
             return nullptr;
 

programs/include/gui/desktop.hpp

@@ -88,7 +88,7 @@ struct DesktopState {
     char user_config_dir[128];  // "0:/users/<username>/config"
     bool is_admin;
 
-    Montauk::MouseState mouse;
+    montauk::abi::MouseState mouse;
     uint8_t prev_buttons;
 
     bool app_menu_open;
@@ -160,7 +160,7 @@ struct DesktopState {
     int ctx_menu_x, ctx_menu_y;
 
     bool net_popup_open;
-    Montauk::NetCfg cached_net_cfg;
+    montauk::abi::NetCfg cached_net_cfg;
     uint64_t net_cfg_last_poll;
     Rect net_icon_rect;
 
@@ -175,7 +175,7 @@ struct DesktopState {
 
     // Temperature monitoring
     static constexpr int MAX_THERMAL_ZONES = 8;
-    Montauk::ThermalInfo thermal_zones[MAX_THERMAL_ZONES];
+    montauk::abi::ThermalInfo thermal_zones[MAX_THERMAL_ZONES];
     int thermal_zone_count;
     uint64_t thermal_last_poll;
     Rect temp_icon_rect;
@@ -214,6 +214,6 @@ void desktop_raise_window(DesktopState* ds, int idx);
 void desktop_draw_panel(DesktopState* ds);
 void desktop_draw_window(DesktopState* ds, int idx);
 void desktop_handle_mouse(DesktopState* ds);
-void desktop_handle_keyboard(DesktopState* ds, const Montauk::KeyEvent& key);
+void desktop_handle_keyboard(DesktopState* ds, const montauk::abi::KeyEvent& key);
 
 } // namespace gui

programs/include/gui/framebuffer.hpp

@@ -61,7 +61,7 @@ class Framebuffer {
 
 public:
     Framebuffer() : hw_fb(nullptr), back_buf(nullptr), fb_width(0), fb_height(0), fb_pitch(0) {
-        Montauk::FbInfo info;
+        montauk::abi::FbInfo info;
         montauk::fb_info(&info);
 
         fb_width  = (int)info.width;

programs/include/gui/mtk/widgets.hpp

@@ -552,7 +552,7 @@ inline int text_input_handle_mouse(TextInputState& state,
 inline int text_input_key(TextInputState& state,
                           char* text,
                           int cap,
-                          const Montauk::KeyEvent& key,
+                          const montauk::abi::KeyEvent& key,
                           TextInputCharFilter filter = nullptr,
                           void* userdata = nullptr,
                           bool masked = false) {

programs/include/gui/standalone.hpp

@@ -24,7 +24,7 @@ struct WsWindow {
         : id(-1), pixels(nullptr), width(0), height(0), scale_factor(1), closed(false) {}
 
     bool create(const char* title, int w, int h) {
-        Montauk::WinCreateResult wres;
+        montauk::abi::WinCreateResult wres;
         if (montauk::win_create(title, w, h, &wres) < 0 || wres.id < 0)
             return false;
 
@@ -37,7 +37,7 @@ struct WsWindow {
         return true;
     }
 
-    int poll(Montauk::WinEvent* ev) {
+    int poll(montauk::abi::WinEvent* ev) {
         if (id < 0 || closed) return -1;
 
         int r = montauk::win_poll(id, ev);

programs/include/gui/terminal.hpp

@@ -831,7 +831,7 @@ static inline void terminal_resize(TerminalState* t, int new_cols, int new_rows)
     }
 }
 
-static inline void terminal_handle_key(TerminalState* t, const Montauk::KeyEvent& key) {
+static inline void terminal_handle_key(TerminalState* t, const montauk::abi::KeyEvent& key) {
     // Snap to live on any keyboard input
     if (t->view_offset > 0) {
         t->view_offset = 0;

programs/include/gui/widgets.hpp

@@ -227,7 +227,7 @@ struct TextBox {
         }
     }
 
-    void handle_key(const Montauk::KeyEvent& key) {
+    void handle_key(const montauk::abi::KeyEvent& key) {
         if (!focused || !key.pressed) return;
 
         if (key.ascii == '\b' || key.scancode == 0x0E) {

programs/include/gui/window.hpp

@@ -32,7 +32,7 @@ static constexpr int MIN_WINDOW_H = 80;
 struct Window;
 using WindowDrawCallback  = void (*)(Window* win, Framebuffer& fb);
 using WindowMouseCallback = void (*)(Window* win, MouseEvent& ev);
-using WindowKeyCallback   = void (*)(Window* win, const Montauk::KeyEvent& key);
+using WindowKeyCallback   = void (*)(Window* win, const montauk::abi::KeyEvent& key);
 using WindowCloseCallback = void (*)(Window* win);
 using WindowPollCallback  = void (*)(Window* win);
 

programs/include/http/http.hpp

@@ -350,7 +350,7 @@ inline Response get_plain(const char* host, const char* path,
     int reqLen = build_request(req, sizeof(req), "GET", host, path,
                                nullptr, nullptr, 0, extra_headers);
 
-    int sock = montauk::socket(Montauk::SOCK_TCP);
+    int sock = montauk::socket(montauk::abi::SOCK_TCP);
     if (sock < 0) return resp;
     if (montauk::connect(sock, ip, 80) < 0) { montauk::closesocket(sock); return resp; }
 

programs/include/montauk/heap.h

@@ -46,7 +46,7 @@ namespace heap_detail {
 
     static inline void heap_lock_acquire() {
         while (__atomic_exchange_n(&g_heap_lock, 1, __ATOMIC_ACQUIRE) != 0) {
-            syscall0(Montauk::SYS_YIELD);
+            syscall0(montauk::abi::SYS_YIELD);
         }
     }
     static inline void heap_lock_release() {

programs/include/montauk/syscall.h

@@ -110,519 +110,519 @@ namespace montauk {
 
     // Process
     [[noreturn]] inline void exit(int code = 0) {
-        syscall1(Montauk::SYS_EXIT, (uint64_t)code);
+        syscall1(montauk::abi::SYS_EXIT, (uint64_t)code);
         __builtin_unreachable();
     }
 
-    inline void yield() { syscall0(Montauk::SYS_YIELD); }
-    inline void sleep_ms(uint64_t ms) { syscall1(Montauk::SYS_SLEEP_MS, ms); }
-    inline int getpid() { return (int)syscall0(Montauk::SYS_GETPID); }
+    inline void yield() { syscall0(montauk::abi::SYS_YIELD); }
+    inline void sleep_ms(uint64_t ms) { syscall1(montauk::abi::SYS_SLEEP_MS, ms); }
+    inline int getpid() { return (int)syscall0(montauk::abi::SYS_GETPID); }
     inline int spawn(const char* path, const char* args = nullptr) {
-        return (int)syscall2(Montauk::SYS_SPAWN, (uint64_t)path, (uint64_t)args);
+        return (int)syscall2(montauk::abi::SYS_SPAWN, (uint64_t)path, (uint64_t)args);
     }
     inline int chdir(const char* path) {
-        return (int)syscall1(Montauk::SYS_CHDIR, (uint64_t)path);
+        return (int)syscall1(montauk::abi::SYS_CHDIR, (uint64_t)path);
     }
     inline int getcwd(char* buf, uint64_t maxLen) {
-        return (int)syscall2(Montauk::SYS_GETCWD, (uint64_t)buf, maxLen);
+        return (int)syscall2(montauk::abi::SYS_GETCWD, (uint64_t)buf, maxLen);
     }
 
     // Console
-    inline void print(const char* text) { syscall1(Montauk::SYS_PRINT, (uint64_t)text); }
-    inline void putchar(char c) { syscall1(Montauk::SYS_PUTCHAR, (uint64_t)c); }
+    inline void print(const char* text) { syscall1(montauk::abi::SYS_PRINT, (uint64_t)text); }
+    inline void putchar(char c) { syscall1(montauk::abi::SYS_PUTCHAR, (uint64_t)c); }
 
     // File I/O
-    inline int open(const char* path) { return (int)syscall1(Montauk::SYS_OPEN, (uint64_t)path); }
+    inline int open(const char* path) { return (int)syscall1(montauk::abi::SYS_OPEN, (uint64_t)path); }
     inline int read(int handle, uint8_t* buf, uint64_t off, uint64_t size) {
-        return (int)syscall4(Montauk::SYS_READ, (uint64_t)handle, (uint64_t)buf, off, size);
+        return (int)syscall4(montauk::abi::SYS_READ, (uint64_t)handle, (uint64_t)buf, off, size);
     }
-    inline uint64_t getsize(int handle) { return (uint64_t)syscall1(Montauk::SYS_GETSIZE, (uint64_t)handle); }
-    inline void close(int handle) { syscall1(Montauk::SYS_CLOSE, (uint64_t)handle); }
+    inline uint64_t getsize(int handle) { return (uint64_t)syscall1(montauk::abi::SYS_GETSIZE, (uint64_t)handle); }
+    inline void close(int handle) { syscall1(montauk::abi::SYS_CLOSE, (uint64_t)handle); }
     inline int readdir(const char* path, const char** names, int max) {
-        return (int)syscall3(Montauk::SYS_READDIR, (uint64_t)path, (uint64_t)names, (uint64_t)max);
+        return (int)syscall3(montauk::abi::SYS_READDIR, (uint64_t)path, (uint64_t)names, (uint64_t)max);
     }
     // Paginated directory read: returns entries [startIndex, startIndex+max).
     // Call repeatedly with increasing startIndex (advancing by the returned
     // count) until it returns 0 to enumerate directories of any size.
     inline int readdir_at(const char* path, const char** names, int max, int startIndex) {
-        return (int)syscall4(Montauk::SYS_READDIR_AT, (uint64_t)path, (uint64_t)names,
+        return (int)syscall4(montauk::abi::SYS_READDIR_AT, (uint64_t)path, (uint64_t)names,
                              (uint64_t)max, (uint64_t)startIndex);
     }
 
     // File write/create
     inline int fwrite(int handle, const uint8_t* buf, uint64_t off, uint64_t size) {
-        return (int)syscall4(Montauk::SYS_FWRITE, (uint64_t)handle, (uint64_t)buf, off, size);
+        return (int)syscall4(montauk::abi::SYS_FWRITE, (uint64_t)handle, (uint64_t)buf, off, size);
     }
     inline int fcreate(const char* path) {
-        return (int)syscall1(Montauk::SYS_FCREATE, (uint64_t)path);
+        return (int)syscall1(montauk::abi::SYS_FCREATE, (uint64_t)path);
     }
     inline int fdelete(const char* path) {
-        return (int)syscall1(Montauk::SYS_FDELETE, (uint64_t)path);
+        return (int)syscall1(montauk::abi::SYS_FDELETE, (uint64_t)path);
     }
     inline int fmkdir(const char* path) {
-        return (int)syscall1(Montauk::SYS_FMKDIR, (uint64_t)path);
+        return (int)syscall1(montauk::abi::SYS_FMKDIR, (uint64_t)path);
     }
     inline int frename(const char* oldPath, const char* newPath) {
-        return (int)syscall2(Montauk::SYS_FRENAME, (uint64_t)oldPath, (uint64_t)newPath);
+        return (int)syscall2(montauk::abi::SYS_FRENAME, (uint64_t)oldPath, (uint64_t)newPath);
     }
     inline int drivelist(int* outDrives, int max) {
-        return (int)syscall2(Montauk::SYS_DRIVELIST, (uint64_t)outDrives, (uint64_t)max);
+        return (int)syscall2(montauk::abi::SYS_DRIVELIST, (uint64_t)outDrives, (uint64_t)max);
     }
     inline int drivelabel(int drive, char* outLabel, int maxLen) {
-        return (int)syscall3(Montauk::SYS_DRIVELABEL, (uint64_t)drive, (uint64_t)outLabel, (uint64_t)maxLen);
+        return (int)syscall3(montauk::abi::SYS_DRIVELABEL, (uint64_t)drive, (uint64_t)outLabel, (uint64_t)maxLen);
     }
     // Returns the kernel BlockDeviceKind backing the drive: 0=unknown/ramdisk,
     // 1=SATA, 2=SATAPI, 3=NVMe, 4=USB MSC.
     inline int drivekind(int drive) {
-        return (int)syscall1(Montauk::SYS_DRIVEKIND, (uint64_t)drive);
+        return (int)syscall1(montauk::abi::SYS_DRIVEKIND, (uint64_t)drive);
     }
 
     // Memory
-    inline void* alloc(uint64_t size) { return (void*)syscall1(Montauk::SYS_ALLOC, size); }
-    inline void free(void* ptr) { syscall1(Montauk::SYS_FREE, (uint64_t)ptr); }
+    inline void* alloc(uint64_t size) { return (void*)syscall1(montauk::abi::SYS_ALLOC, size); }
+    inline void free(void* ptr) { syscall1(montauk::abi::SYS_FREE, (uint64_t)ptr); }
 
     // Timekeeping
-    inline uint64_t get_ticks() { return (uint64_t)syscall0(Montauk::SYS_GETTICKS); }
-    inline uint64_t get_milliseconds() { return (uint64_t)syscall0(Montauk::SYS_GETMILLISECONDS); }
+    inline uint64_t get_ticks() { return (uint64_t)syscall0(montauk::abi::SYS_GETTICKS); }
+    inline uint64_t get_milliseconds() { return (uint64_t)syscall0(montauk::abi::SYS_GETMILLISECONDS); }
 
     // System
-    inline void get_info(Montauk::SysInfo* info) { syscall1(Montauk::SYS_GETINFO, (uint64_t)info); }
+    inline void get_info(montauk::abi::SysInfo* info) { syscall1(montauk::abi::SYS_GETINFO, (uint64_t)info); }
 
     // Keyboard
-    inline bool is_key_available() { return (bool)syscall0(Montauk::SYS_ISKEYAVAILABLE); }
-    inline void getkey(Montauk::KeyEvent* out) { syscall1(Montauk::SYS_GETKEY, (uint64_t)out); }
-    inline char getchar() { return (char)syscall0(Montauk::SYS_GETCHAR); }
+    inline bool is_key_available() { return (bool)syscall0(montauk::abi::SYS_ISKEYAVAILABLE); }
+    inline void getkey(montauk::abi::KeyEvent* out) { syscall1(montauk::abi::SYS_GETKEY, (uint64_t)out); }
+    inline char getchar() { return (char)syscall0(montauk::abi::SYS_GETCHAR); }
     inline uint64_t input_wait(uint64_t observedSerial, uint64_t timeoutMs) {
-        return (uint64_t)syscall2(Montauk::SYS_INPUT_WAIT, observedSerial, timeoutMs);
+        return (uint64_t)syscall2(montauk::abi::SYS_INPUT_WAIT, observedSerial, timeoutMs);
     }
 
     // Networking
     inline int32_t ping(uint32_t ip, uint32_t timeoutMs = 3000) {
-        return (int32_t)syscall2(Montauk::SYS_PING, (uint64_t)ip, (uint64_t)timeoutMs);
+        return (int32_t)syscall2(montauk::abi::SYS_PING, (uint64_t)ip, (uint64_t)timeoutMs);
     }
 
     // DNS resolve: returns IP in network byte order, or 0 on failure
     inline uint32_t resolve(const char* hostname) {
-        return (uint32_t)syscall1(Montauk::SYS_RESOLVE, (uint64_t)hostname);
+        return (uint32_t)syscall1(montauk::abi::SYS_RESOLVE, (uint64_t)hostname);
     }
 
     // Network configuration
-    inline void get_netcfg(Montauk::NetCfg* out) { syscall1(Montauk::SYS_GETNETCFG, (uint64_t)out); }
-    inline int set_netcfg(const Montauk::NetCfg* cfg) { return (int)syscall1(Montauk::SYS_SETNETCFG, (uint64_t)cfg); }
-    inline int net_status(Montauk::NetStatus* out) { return (int)syscall1(Montauk::SYS_NETSTATUS, (uint64_t)out); }
+    inline void get_netcfg(montauk::abi::NetCfg* out) { syscall1(montauk::abi::SYS_GETNETCFG, (uint64_t)out); }
+    inline int set_netcfg(const montauk::abi::NetCfg* cfg) { return (int)syscall1(montauk::abi::SYS_SETNETCFG, (uint64_t)cfg); }
+    inline int net_status(montauk::abi::NetStatus* out) { return (int)syscall1(montauk::abi::SYS_NETSTATUS, (uint64_t)out); }
 
     // Sockets
     inline int socket(int type) {
-        return (int)syscall1(Montauk::SYS_SOCKET, (uint64_t)type);
+        return (int)syscall1(montauk::abi::SYS_SOCKET, (uint64_t)type);
     }
     inline int connect(int fd, uint32_t ip, uint16_t port) {
-        return (int)syscall3(Montauk::SYS_CONNECT, (uint64_t)fd, (uint64_t)ip, (uint64_t)port);
+        return (int)syscall3(montauk::abi::SYS_CONNECT, (uint64_t)fd, (uint64_t)ip, (uint64_t)port);
     }
     inline int bind(int fd, uint16_t port) {
-        return (int)syscall2(Montauk::SYS_BIND, (uint64_t)fd, (uint64_t)port);
+        return (int)syscall2(montauk::abi::SYS_BIND, (uint64_t)fd, (uint64_t)port);
     }
     inline int listen(int fd) {
-        return (int)syscall1(Montauk::SYS_LISTEN, (uint64_t)fd);
+        return (int)syscall1(montauk::abi::SYS_LISTEN, (uint64_t)fd);
     }
     inline int accept(int fd) {
-        return (int)syscall1(Montauk::SYS_ACCEPT, (uint64_t)fd);
+        return (int)syscall1(montauk::abi::SYS_ACCEPT, (uint64_t)fd);
     }
     inline int send(int fd, const void* data, uint32_t len) {
-        return (int)syscall3(Montauk::SYS_SEND, (uint64_t)fd, (uint64_t)data, (uint64_t)len);
+        return (int)syscall3(montauk::abi::SYS_SEND, (uint64_t)fd, (uint64_t)data, (uint64_t)len);
     }
     inline int recv(int fd, void* buf, uint32_t maxLen) {
-        return (int)syscall3(Montauk::SYS_RECV, (uint64_t)fd, (uint64_t)buf, (uint64_t)maxLen);
+        return (int)syscall3(montauk::abi::SYS_RECV, (uint64_t)fd, (uint64_t)buf, (uint64_t)maxLen);
     }
     inline int closesocket(int fd) {
-        return (int)syscall1(Montauk::SYS_CLOSESOCK, (uint64_t)fd);
+        return (int)syscall1(montauk::abi::SYS_CLOSESOCK, (uint64_t)fd);
     }
     inline int sendto(int fd, const void* data, uint32_t len, uint32_t destIp, uint16_t destPort) {
-        return (int)syscall5(Montauk::SYS_SENDTO, (uint64_t)fd, (uint64_t)data,
+        return (int)syscall5(montauk::abi::SYS_SENDTO, (uint64_t)fd, (uint64_t)data,
                              (uint64_t)len, (uint64_t)destIp, (uint64_t)destPort);
     }
     inline int recvfrom(int fd, void* buf, uint32_t maxLen, uint32_t* srcIp, uint16_t* srcPort) {
-        return (int)syscall5(Montauk::SYS_RECVFROM, (uint64_t)fd, (uint64_t)buf,
+        return (int)syscall5(montauk::abi::SYS_RECVFROM, (uint64_t)fd, (uint64_t)buf,
                              (uint64_t)maxLen, (uint64_t)srcIp, (uint64_t)srcPort);
     }
 
     // Generic IPC
     inline int dup_handle(int handle) {
-        return (int)syscall1(Montauk::SYS_DUPHANDLE, (uint64_t)handle);
+        return (int)syscall1(montauk::abi::SYS_DUPHANDLE, (uint64_t)handle);
     }
     inline uint32_t wait_handle(int handle, uint32_t wantedSignals, uint64_t timeoutMs = ~0ULL) {
-        return (uint32_t)syscall3(Montauk::SYS_WAIT_HANDLE, (uint64_t)handle,
+        return (uint32_t)syscall3(montauk::abi::SYS_WAIT_HANDLE, (uint64_t)handle,
                                   (uint64_t)wantedSignals, timeoutMs);
     }
     inline int stream_create(int* outReadHandle, int* outWriteHandle, uint32_t capacity = 0) {
-        return (int)syscall3(Montauk::SYS_STREAM_CREATE, (uint64_t)outReadHandle,
+        return (int)syscall3(montauk::abi::SYS_STREAM_CREATE, (uint64_t)outReadHandle,
                              (uint64_t)outWriteHandle, (uint64_t)capacity);
     }
     inline int stream_read(int handle, void* buf, int maxLen) {
-        return (int)syscall3(Montauk::SYS_STREAM_READ, (uint64_t)handle, (uint64_t)buf, (uint64_t)maxLen);
+        return (int)syscall3(montauk::abi::SYS_STREAM_READ, (uint64_t)handle, (uint64_t)buf, (uint64_t)maxLen);
     }
     inline int stream_write(int handle, const void* data, int len) {
-        return (int)syscall3(Montauk::SYS_STREAM_WRITE, (uint64_t)handle, (uint64_t)data, (uint64_t)len);
+        return (int)syscall3(montauk::abi::SYS_STREAM_WRITE, (uint64_t)handle, (uint64_t)data, (uint64_t)len);
     }
     inline int mailbox_create(int* outSendHandle, int* outRecvHandle) {
-        return (int)syscall2(Montauk::SYS_MAILBOX_CREATE, (uint64_t)outSendHandle, (uint64_t)outRecvHandle);
+        return (int)syscall2(montauk::abi::SYS_MAILBOX_CREATE, (uint64_t)outSendHandle, (uint64_t)outRecvHandle);
     }
     inline int mailbox_send(int handle, uint32_t msgType, const void* data, uint16_t len, int attachHandle = -1) {
-        return (int)syscall5(Montauk::SYS_MAILBOX_SEND, (uint64_t)handle, (uint64_t)msgType,
+        return (int)syscall5(montauk::abi::SYS_MAILBOX_SEND, (uint64_t)handle, (uint64_t)msgType,
                              (uint64_t)data, (uint64_t)len, (uint64_t)(int64_t)attachHandle);
     }
     inline int mailbox_recv(int handle, uint32_t* outMsgType, void* data,
                             uint16_t* inOutLen, int* outAttachHandle = nullptr) {
-        return (int)syscall5(Montauk::SYS_MAILBOX_RECV, (uint64_t)handle, (uint64_t)outMsgType,
+        return (int)syscall5(montauk::abi::SYS_MAILBOX_RECV, (uint64_t)handle, (uint64_t)outMsgType,
                              (uint64_t)data, (uint64_t)inOutLen, (uint64_t)outAttachHandle);
     }
     inline int waitset_create() {
-        return (int)syscall0(Montauk::SYS_WAITSET_CREATE);
+        return (int)syscall0(montauk::abi::SYS_WAITSET_CREATE);
     }
     inline int waitset_add(int waitsetHandle, int targetHandle, uint32_t signals) {
-        return (int)syscall3(Montauk::SYS_WAITSET_ADD, (uint64_t)waitsetHandle,
+        return (int)syscall3(montauk::abi::SYS_WAITSET_ADD, (uint64_t)waitsetHandle,
                              (uint64_t)targetHandle, (uint64_t)signals);
     }
     inline int waitset_remove(int waitsetHandle, int index) {
-        return (int)syscall2(Montauk::SYS_WAITSET_REMOVE, (uint64_t)waitsetHandle, (uint64_t)index);
+        return (int)syscall2(montauk::abi::SYS_WAITSET_REMOVE, (uint64_t)waitsetHandle, (uint64_t)index);
     }
-    inline int waitset_wait(int waitsetHandle, Montauk::IpcWaitResult* outReady, uint64_t timeoutMs = ~0ULL) {
-        return (int)syscall3(Montauk::SYS_WAITSET_WAIT, (uint64_t)waitsetHandle, (uint64_t)outReady, timeoutMs);
+    inline int waitset_wait(int waitsetHandle, montauk::abi::IpcWaitResult* outReady, uint64_t timeoutMs = ~0ULL) {
+        return (int)syscall3(montauk::abi::SYS_WAITSET_WAIT, (uint64_t)waitsetHandle, (uint64_t)outReady, timeoutMs);
     }
     inline int proc_open(int pid) {
-        return (int)syscall1(Montauk::SYS_PROC_OPEN, (uint64_t)pid);
+        return (int)syscall1(montauk::abi::SYS_PROC_OPEN, (uint64_t)pid);
     }
     inline int surface_create(uint64_t byteSize) {
-        return (int)syscall1(Montauk::SYS_SURFACE_CREATE, byteSize);
+        return (int)syscall1(montauk::abi::SYS_SURFACE_CREATE, byteSize);
     }
     inline void* surface_map(int handle) {
-        return (void*)syscall1(Montauk::SYS_SURFACE_MAP, (uint64_t)handle);
+        return (void*)syscall1(montauk::abi::SYS_SURFACE_MAP, (uint64_t)handle);
     }
     inline int surface_resize(int handle, uint64_t newSize) {
-        return (int)syscall2(Montauk::SYS_SURFACE_RESIZE, (uint64_t)handle, newSize);
+        return (int)syscall2(montauk::abi::SYS_SURFACE_RESIZE, (uint64_t)handle, newSize);
     }
 
     // Shared library support
     inline int load_lib(const char* path) {
-        return (int)syscall1(Montauk::SYS_LOAD_LIB, (uint64_t)path);
+        return (int)syscall1(montauk::abi::SYS_LOAD_LIB, (uint64_t)path);
     }
     inline int unload_lib(int handle) {
-        return (int)syscall1(Montauk::SYS_UNLOAD_LIB, (uint64_t)handle);
+        return (int)syscall1(montauk::abi::SYS_UNLOAD_LIB, (uint64_t)handle);
     }
     inline void* dlsym(int handle, uint64_t symbolOffset) {
-        return (void*)syscall2(Montauk::SYS_DLSYM, (uint64_t)handle, symbolOffset);
+        return (void*)syscall2(montauk::abi::SYS_DLSYM, (uint64_t)handle, symbolOffset);
     }
     inline uint64_t get_libbase(int handle) {
-        return (uint64_t)syscall1(Montauk::SYS_GETLIBBASE, (uint64_t)handle);
+        return (uint64_t)syscall1(montauk::abi::SYS_GETLIBBASE, (uint64_t)handle);
     }
 
     // Crash report retrieval
-    inline int crash_report(Montauk::CrashReportInfo* out) {
-        return (int)syscall1(Montauk::SYS_CRASH_REPORT, (uint64_t)out);
+    inline int crash_report(montauk::abi::CrashReportInfo* out) {
+        return (int)syscall1(montauk::abi::SYS_CRASH_REPORT, (uint64_t)out);
     }
 
     // Process management
-    inline void waitpid(int pid) { syscall1(Montauk::SYS_WAITPID, (uint64_t)pid); }
+    inline void waitpid(int pid) { syscall1(montauk::abi::SYS_WAITPID, (uint64_t)pid); }
 
     // Framebuffer
-    inline void fb_info(Montauk::FbInfo* info) { syscall1(Montauk::SYS_FBINFO, (uint64_t)info); }
-    inline void* fb_map() { return (void*)syscall0(Montauk::SYS_FBMAP); }
+    inline void fb_info(montauk::abi::FbInfo* info) { syscall1(montauk::abi::SYS_FBINFO, (uint64_t)info); }
+    inline void* fb_map() { return (void*)syscall0(montauk::abi::SYS_FBMAP); }
 
     // Arguments
     inline int getargs(char* buf, uint64_t maxLen) {
-        return (int)syscall2(Montauk::SYS_GETARGS, (uint64_t)buf, maxLen);
+        return (int)syscall2(montauk::abi::SYS_GETARGS, (uint64_t)buf, maxLen);
     }
 
     // Terminal
     inline void termsize(int* cols, int* rows) {
-        uint64_t r = (uint64_t)syscall0(Montauk::SYS_TERMSIZE);
+        uint64_t r = (uint64_t)syscall0(montauk::abi::SYS_TERMSIZE);
         if (cols) *cols = (int)(r & 0xFFFFFFFF);
         if (rows) *rows = (int)(r >> 32);
     }
 
     inline void termscale(int scale_x, int scale_y) {
-        syscall2(Montauk::SYS_TERMSCALE, (uint64_t)scale_x, (uint64_t)scale_y);
+        syscall2(montauk::abi::SYS_TERMSCALE, (uint64_t)scale_x, (uint64_t)scale_y);
     }
 
     inline void get_termscale(int* scale_x, int* scale_y) {
-        uint64_t r = (uint64_t)syscall2(Montauk::SYS_TERMSCALE, 0, 0);
+        uint64_t r = (uint64_t)syscall2(montauk::abi::SYS_TERMSCALE, 0, 0);
         if (scale_x) *scale_x = (int)(r & 0xFFFFFFFF);
         if (scale_y) *scale_y = (int)(r >> 32);
     }
 
     // Timekeeping (wall-clock)
-    inline void gettime(Montauk::DateTime* out) { syscall1(Montauk::SYS_GETTIME, (uint64_t)out); }
+    inline void gettime(montauk::abi::DateTime* out) { syscall1(montauk::abi::SYS_GETTIME, (uint64_t)out); }
 
     // Timezone offset (total minutes from UTC)
-    inline void settz(int offset_minutes) { syscall1(Montauk::SYS_SETTZ, (uint64_t)(int64_t)offset_minutes); }
-    inline int gettz() { return (int)syscall0(Montauk::SYS_GETTZ); }
+    inline void settz(int offset_minutes) { syscall1(montauk::abi::SYS_SETTZ, (uint64_t)(int64_t)offset_minutes); }
+    inline int gettz() { return (int)syscall0(montauk::abi::SYS_GETTZ); }
 
     // Random number generation
     inline int64_t getrandom(void* buf, uint32_t len) {
-        return syscall2(Montauk::SYS_GETRANDOM, (uint64_t)buf, (uint64_t)len);
+        return syscall2(montauk::abi::SYS_GETRANDOM, (uint64_t)buf, (uint64_t)len);
     }
 
     // Power management
     [[noreturn]] inline void reset() {
-        syscall0(Montauk::SYS_RESET);
+        syscall0(montauk::abi::SYS_RESET);
         __builtin_unreachable();
     }
 
     [[noreturn]] inline void shutdown() {
-        syscall0(Montauk::SYS_SHUTDOWN);
+        syscall0(montauk::abi::SYS_SHUTDOWN);
         __builtin_unreachable();
     }
 
     inline int suspend() {
-        return (int)syscall0(Montauk::SYS_SUSPEND);
+        return (int)syscall0(montauk::abi::SYS_SUSPEND);
     }
 
     // Graceful power-off request channel. The desktop posts a pending action
-    // (Montauk::POWER_REQ_SHUTDOWN / POWER_REQ_REBOOT) then exits; login.elf
+    // (montauk::abi::POWER_REQ_SHUTDOWN / POWER_REQ_REBOOT) then exits; login.elf
     // reads it with POWER_REQ_QUERY (read-and-clear), runs the shutdown stages,
     // and finally calls shutdown()/reset(). Returns the pending action for a
     // query, or 0 when posting one.
     inline int power_request(int action) {
-        return (int)syscall1(Montauk::SYS_POWER_REQUEST, (uint64_t)(int64_t)action);
+        return (int)syscall1(montauk::abi::SYS_POWER_REQUEST, (uint64_t)(int64_t)action);
     }
 
     // Mouse
-    inline void mouse_state(Montauk::MouseState* out) { syscall1(Montauk::SYS_MOUSESTATE, (uint64_t)out); }
+    inline void mouse_state(montauk::abi::MouseState* out) { syscall1(montauk::abi::SYS_MOUSESTATE, (uint64_t)out); }
     inline void set_mouse_bounds(int32_t maxX, int32_t maxY) {
-        syscall2(Montauk::SYS_SETMOUSEBOUNDS, (uint64_t)maxX, (uint64_t)maxY);
+        syscall2(montauk::abi::SYS_SETMOUSEBOUNDS, (uint64_t)maxX, (uint64_t)maxY);
     }
 
     // Kernel log
     inline int64_t read_klog(char* buf, uint64_t size) {
-        return syscall2(Montauk::SYS_KLOG, (uint64_t)buf, size);
+        return syscall2(montauk::abi::SYS_KLOG, (uint64_t)buf, size);
     }
 
     // I/O redirection
     inline int spawn_redir(const char* path, const char* args = nullptr) {
-        return (int)syscall2(Montauk::SYS_SPAWN_REDIR, (uint64_t)path, (uint64_t)args);
+        return (int)syscall2(montauk::abi::SYS_SPAWN_REDIR, (uint64_t)path, (uint64_t)args);
     }
     inline int childio_read(int childPid, char* buf, int maxLen) {
-        return (int)syscall3(Montauk::SYS_CHILDIO_READ, (uint64_t)childPid, (uint64_t)buf, (uint64_t)maxLen);
+        return (int)syscall3(montauk::abi::SYS_CHILDIO_READ, (uint64_t)childPid, (uint64_t)buf, (uint64_t)maxLen);
     }
     inline int childio_write(int childPid, const char* data, int len) {
-        return (int)syscall3(Montauk::SYS_CHILDIO_WRITE, (uint64_t)childPid, (uint64_t)data, (uint64_t)len);
+        return (int)syscall3(montauk::abi::SYS_CHILDIO_WRITE, (uint64_t)childPid, (uint64_t)data, (uint64_t)len);
     }
-    inline int childio_writekey(int childPid, const Montauk::KeyEvent* key) {
-        return (int)syscall2(Montauk::SYS_CHILDIO_WRITEKEY, (uint64_t)childPid, (uint64_t)key);
+    inline int childio_writekey(int childPid, const montauk::abi::KeyEvent* key) {
+        return (int)syscall2(montauk::abi::SYS_CHILDIO_WRITEKEY, (uint64_t)childPid, (uint64_t)key);
     }
     inline int childio_settermsz(int childPid, int cols, int rows) {
-        return (int)syscall3(Montauk::SYS_CHILDIO_SETTERMSZ, (uint64_t)childPid, (uint64_t)cols, (uint64_t)rows);
+        return (int)syscall3(montauk::abi::SYS_CHILDIO_SETTERMSZ, (uint64_t)childPid, (uint64_t)cols, (uint64_t)rows);
     }
 
     // Process listing / kill
-    inline int proclist(Montauk::ProcInfo* buf, int max) {
-        return (int)syscall2(Montauk::SYS_PROCLIST, (uint64_t)buf, (uint64_t)max);
+    inline int proclist(montauk::abi::ProcInfo* buf, int max) {
+        return (int)syscall2(montauk::abi::SYS_PROCLIST, (uint64_t)buf, (uint64_t)max);
     }
     inline int kill(int pid) {
-        return (int)syscall1(Montauk::SYS_KILL, (uint64_t)pid);
+        return (int)syscall1(montauk::abi::SYS_KILL, (uint64_t)pid);
     }
-    inline int devlist(Montauk::DevInfo* buf, int max) {
-        return (int)syscall2(Montauk::SYS_DEVLIST, (uint64_t)buf, (uint64_t)max);
+    inline int devlist(montauk::abi::DevInfo* buf, int max) {
+        return (int)syscall2(montauk::abi::SYS_DEVLIST, (uint64_t)buf, (uint64_t)max);
     }
-    inline int diskinfo(Montauk::DiskInfo* buf, int port) {
-        return (int)syscall2(Montauk::SYS_DISKINFO, (uint64_t)buf, (uint64_t)port);
+    inline int diskinfo(montauk::abi::DiskInfo* buf, int port) {
+        return (int)syscall2(montauk::abi::SYS_DISKINFO, (uint64_t)buf, (uint64_t)port);
     }
 
     // Partition table
-    inline int partlist(Montauk::PartInfo* buf, int max) {
-        return (int)syscall2(Montauk::SYS_PARTLIST, (uint64_t)buf, (uint64_t)max);
+    inline int partlist(montauk::abi::PartInfo* buf, int max) {
+        return (int)syscall2(montauk::abi::SYS_PARTLIST, (uint64_t)buf, (uint64_t)max);
     }
 
     // Raw block device I/O (driver-agnostic)
     inline int64_t disk_read(int blockDev, uint64_t lba, uint32_t sectorCount, void* buf) {
-        return syscall4(Montauk::SYS_DISKREAD, (uint64_t)blockDev, lba,
+        return syscall4(montauk::abi::SYS_DISKREAD, (uint64_t)blockDev, lba,
                         (uint64_t)sectorCount, (uint64_t)buf);
     }
     inline int64_t disk_write(int blockDev, uint64_t lba, uint32_t sectorCount, const void* buf) {
-        return syscall4(Montauk::SYS_DISKWRITE, (uint64_t)blockDev, lba,
+        return syscall4(montauk::abi::SYS_DISKWRITE, (uint64_t)blockDev, lba,
                         (uint64_t)sectorCount, (uint64_t)buf);
     }
 
     // GPT management
     inline int gpt_init(int blockDev) {
-        return (int)syscall1(Montauk::SYS_GPTINIT, (uint64_t)blockDev);
+        return (int)syscall1(montauk::abi::SYS_GPTINIT, (uint64_t)blockDev);
     }
-    inline int gpt_add(const Montauk::GptAddParams* params) {
-        return (int)syscall1(Montauk::SYS_GPTADD, (uint64_t)params);
+    inline int gpt_add(const montauk::abi::GptAddParams* params) {
+        return (int)syscall1(montauk::abi::SYS_GPTADD, (uint64_t)params);
     }
     inline int fs_mount(int partIndex, int driveNum) {
-        return (int)syscall2(Montauk::SYS_FSMOUNT, (uint64_t)partIndex, (uint64_t)driveNum);
+        return (int)syscall2(montauk::abi::SYS_FSMOUNT, (uint64_t)partIndex, (uint64_t)driveNum);
     }
     // Flush all block-device write caches and cleanly unmount disk-backed
     // volumes ahead of power-off. Returns the number of volumes unmounted.
     inline int fs_sync() {
-        return (int)syscall0(Montauk::SYS_FS_SYNC);
+        return (int)syscall0(montauk::abi::SYS_FS_SYNC);
     }
-    inline int fs_format(const Montauk::FsFormatParams* params) {
-        return (int)syscall1(Montauk::SYS_FSFORMAT, (uint64_t)params);
+    inline int fs_format(const montauk::abi::FsFormatParams* params) {
+        return (int)syscall1(montauk::abi::SYS_FSFORMAT, (uint64_t)params);
     }
 
     // Audio
     inline int audio_open(uint32_t sampleRate, uint8_t channels, uint8_t bitsPerSample) {
-        return (int)syscall3(Montauk::SYS_AUDIOOPEN, (uint64_t)sampleRate,
+        return (int)syscall3(montauk::abi::SYS_AUDIOOPEN, (uint64_t)sampleRate,
                              (uint64_t)channels, (uint64_t)bitsPerSample);
     }
     inline void audio_close(int handle) {
-        syscall1(Montauk::SYS_AUDIOCLOSE, (uint64_t)handle);
+        syscall1(montauk::abi::SYS_AUDIOCLOSE, (uint64_t)handle);
     }
     inline int audio_write(int handle, const void* data, uint32_t size) {
-        return (int)syscall3(Montauk::SYS_AUDIOWRITE, (uint64_t)handle,
+        return (int)syscall3(montauk::abi::SYS_AUDIOWRITE, (uint64_t)handle,
                              (uint64_t)data, (uint64_t)size);
     }
     inline int audio_ctl(int handle, int cmd, int value) {
-        return (int)syscall3(Montauk::SYS_AUDIOCTL, (uint64_t)handle,
+        return (int)syscall3(montauk::abi::SYS_AUDIOCTL, (uint64_t)handle,
                              (uint64_t)cmd, (uint64_t)value);
     }
     inline int audio_set_volume(int handle, int percent) {
-        return audio_ctl(handle, Montauk::AUDIO_CTL_SET_VOLUME, percent);
+        return audio_ctl(handle, montauk::abi::AUDIO_CTL_SET_VOLUME, percent);
     }
     inline int audio_get_volume(int handle) {
-        return audio_ctl(handle, Montauk::AUDIO_CTL_GET_VOLUME, 0);
+        return audio_ctl(handle, montauk::abi::AUDIO_CTL_GET_VOLUME, 0);
     }
     inline int audio_get_pos(int handle) {
-        return audio_ctl(handle, Montauk::AUDIO_CTL_GET_POS, 0);
+        return audio_ctl(handle, montauk::abi::AUDIO_CTL_GET_POS, 0);
     }
     inline int audio_pause(int handle) {
-        return audio_ctl(handle, Montauk::AUDIO_CTL_PAUSE, 1);
+        return audio_ctl(handle, montauk::abi::AUDIO_CTL_PAUSE, 1);
     }
     inline int audio_resume(int handle) {
-        return audio_ctl(handle, Montauk::AUDIO_CTL_PAUSE, 0);
+        return audio_ctl(handle, montauk::abi::AUDIO_CTL_PAUSE, 0);
     }
     inline int audio_get_output(int handle) {
-        return audio_ctl(handle, Montauk::AUDIO_CTL_GET_OUTPUT, 0);
+        return audio_ctl(handle, montauk::abi::AUDIO_CTL_GET_OUTPUT, 0);
     }
     inline int audio_bt_status(int handle) {
-        return audio_ctl(handle, Montauk::AUDIO_CTL_BT_STATUS, 0);
+        return audio_ctl(handle, montauk::abi::AUDIO_CTL_BT_STATUS, 0);
     }
     inline int audio_set_master_volume(int percent) {
-        return audio_ctl(-1, Montauk::AUDIO_CTL_SET_MASTER_VOLUME, percent);
+        return audio_ctl(-1, montauk::abi::AUDIO_CTL_SET_MASTER_VOLUME, percent);
     }
     inline int audio_get_master_volume() {
-        return audio_ctl(-1, Montauk::AUDIO_CTL_GET_MASTER_VOLUME, 0);
+        return audio_ctl(-1, montauk::abi::AUDIO_CTL_GET_MASTER_VOLUME, 0);
     }
     inline int audio_set_master_mute(bool muted) {
-        return audio_ctl(-1, Montauk::AUDIO_CTL_SET_MASTER_MUTE, muted ? 1 : 0);
+        return audio_ctl(-1, montauk::abi::AUDIO_CTL_SET_MASTER_MUTE, muted ? 1 : 0);
     }
     inline int audio_get_master_mute() {
-        return audio_ctl(-1, Montauk::AUDIO_CTL_GET_MASTER_MUTE, 0);
+        return audio_ctl(-1, montauk::abi::AUDIO_CTL_GET_MASTER_MUTE, 0);
     }
     inline int audio_set_mute(int handle, bool muted) {
-        return audio_ctl(handle, Montauk::AUDIO_CTL_SET_MUTE, muted ? 1 : 0);
+        return audio_ctl(handle, montauk::abi::AUDIO_CTL_SET_MUTE, muted ? 1 : 0);
     }
     inline int audio_get_mute(int handle) {
-        return audio_ctl(handle, Montauk::AUDIO_CTL_GET_MUTE, 0);
+        return audio_ctl(handle, montauk::abi::AUDIO_CTL_GET_MUTE, 0);
     }
-    inline int audio_list(Montauk::AudioStreamInfo* buf, int maxCount) {
-        return (int)syscall2(Montauk::SYS_AUDIOLIST, (uint64_t)buf, (uint64_t)maxCount);
+    inline int audio_list(montauk::abi::AudioStreamInfo* buf, int maxCount) {
+        return (int)syscall2(montauk::abi::SYS_AUDIOLIST, (uint64_t)buf, (uint64_t)maxCount);
     }
     // Returns the current mixer state serial. With timeoutMs > 0 the call
     // blocks until the serial differs from `prevSerial` or the timeout
     // elapses. With timeoutMs == 0 it returns immediately (cheap snapshot).
     inline uint64_t audio_wait(uint64_t prevSerial, uint64_t timeoutMs) {
-        return syscall2(Montauk::SYS_AUDIOWAIT, prevSerial, timeoutMs);
+        return syscall2(montauk::abi::SYS_AUDIOWAIT, prevSerial, timeoutMs);
     }
 
     // Bluetooth
-    inline int bt_scan(Montauk::BtScanResult* buf, int maxCount, uint32_t timeoutMs) {
-        return (int)syscall3(Montauk::SYS_BTSCAN, (uint64_t)buf, (uint64_t)maxCount, (uint64_t)timeoutMs);
+    inline int bt_scan(montauk::abi::BtScanResult* buf, int maxCount, uint32_t timeoutMs) {
+        return (int)syscall3(montauk::abi::SYS_BTSCAN, (uint64_t)buf, (uint64_t)maxCount, (uint64_t)timeoutMs);
     }
     inline int bt_connect(const uint8_t* bdAddr) {
-        return (int)syscall1(Montauk::SYS_BTCONNECT, (uint64_t)bdAddr);
+        return (int)syscall1(montauk::abi::SYS_BTCONNECT, (uint64_t)bdAddr);
     }
     inline int bt_disconnect(const uint8_t* bdAddr) {
-        return (int)syscall1(Montauk::SYS_BTDISCONNECT, (uint64_t)bdAddr);
+        return (int)syscall1(montauk::abi::SYS_BTDISCONNECT, (uint64_t)bdAddr);
     }
     // Change the adapter's BD_ADDR. bdAddr is a 6-byte buffer with bdAddr[0] as
     // the least-significant octet (same order as BtAdapterInfo::bdAddr). Returns
     // 0 on success, negative on failure. Persist separately to bluetooth.toml.
     inline int bt_set_addr(const uint8_t* bdAddr) {
-        return (int)syscall1(Montauk::SYS_BTSETADDR, (uint64_t)bdAddr);
+        return (int)syscall1(montauk::abi::SYS_BTSETADDR, (uint64_t)bdAddr);
     }
     // List bonded (paired) devices. Returns count written to buf (may be 0).
-    inline int bt_bonds(Montauk::BtBondInfo* buf, int maxCount) {
-        return (int)syscall2(Montauk::SYS_BTBONDS, (uint64_t)buf, (uint64_t)maxCount);
+    inline int bt_bonds(montauk::abi::BtBondInfo* buf, int maxCount) {
+        return (int)syscall2(montauk::abi::SYS_BTBONDS, (uint64_t)buf, (uint64_t)maxCount);
     }
     // Forget a paired device (removes the bond; it must re-pair next time).
     inline int bt_forget(const uint8_t* bdAddr) {
-        return (int)syscall1(Montauk::SYS_BTFORGET, (uint64_t)bdAddr);
+        return (int)syscall1(montauk::abi::SYS_BTFORGET, (uint64_t)bdAddr);
     }
-    inline int bt_list(Montauk::BtDevInfo* buf, int maxCount) {
-        return (int)syscall2(Montauk::SYS_BTLIST, (uint64_t)buf, (uint64_t)maxCount);
+    inline int bt_list(montauk::abi::BtDevInfo* buf, int maxCount) {
+        return (int)syscall2(montauk::abi::SYS_BTLIST, (uint64_t)buf, (uint64_t)maxCount);
     }
-    inline int bt_info(Montauk::BtAdapterInfo* buf) {
-        return (int)syscall1(Montauk::SYS_BTINFO, (uint64_t)buf);
+    inline int bt_info(montauk::abi::BtAdapterInfo* buf) {
+        return (int)syscall1(montauk::abi::SYS_BTINFO, (uint64_t)buf);
     }
 
     // Kernel introspection
-    inline void memstats(Montauk::MemStats* out) { syscall1(Montauk::SYS_MEMSTATS, (uint64_t)out); }
+    inline void memstats(montauk::abi::MemStats* out) { syscall1(montauk::abi::SYS_MEMSTATS, (uint64_t)out); }
 
     // User management
     inline int setuser(int pid, const char* name) {
-        return (int)syscall2(Montauk::SYS_SETUSER, (uint64_t)pid, (uint64_t)name);
+        return (int)syscall2(montauk::abi::SYS_SETUSER, (uint64_t)pid, (uint64_t)name);
     }
     inline int getuser(char* buf, uint64_t maxLen) {
-        return (int)syscall2(Montauk::SYS_GETUSER, (uint64_t)buf, maxLen);
+        return (int)syscall2(montauk::abi::SYS_GETUSER, (uint64_t)buf, maxLen);
     }
 
     // Clipboard
     inline int clipboard_set_text(const char* data, uint32_t len) {
-        return (int)syscall2(Montauk::SYS_CLIPBOARD_SET_TEXT, (uint64_t)data, (uint64_t)len);
+        return (int)syscall2(montauk::abi::SYS_CLIPBOARD_SET_TEXT, (uint64_t)data, (uint64_t)len);
     }
-    inline int clipboard_get_info(Montauk::ClipboardInfo* out) {
-        return (int)syscall1(Montauk::SYS_CLIPBOARD_GET_INFO, (uint64_t)out);
+    inline int clipboard_get_info(montauk::abi::ClipboardInfo* out) {
+        return (int)syscall1(montauk::abi::SYS_CLIPBOARD_GET_INFO, (uint64_t)out);
     }
     inline int clipboard_get_text(char* buf, uint32_t bufLen, uint32_t* outLen,
                                   uint64_t* outSerial = nullptr) {
-        return (int)syscall4(Montauk::SYS_CLIPBOARD_GET_TEXT, (uint64_t)buf, (uint64_t)bufLen,
+        return (int)syscall4(montauk::abi::SYS_CLIPBOARD_GET_TEXT, (uint64_t)buf, (uint64_t)bufLen,
                              (uint64_t)outLen, (uint64_t)outSerial);
     }
     inline int clipboard_clear() {
-        return (int)syscall0(Montauk::SYS_CLIPBOARD_CLEAR);
+        return (int)syscall0(montauk::abi::SYS_CLIPBOARD_CLEAR);
     }
 
     // Window server
-    inline int win_create(const char* title, int w, int h, Montauk::WinCreateResult* result) {
-        return (int)syscall4(Montauk::SYS_WINCREATE, (uint64_t)title, (uint64_t)w, (uint64_t)h, (uint64_t)result);
+    inline int win_create(const char* title, int w, int h, montauk::abi::WinCreateResult* result) {
+        return (int)syscall4(montauk::abi::SYS_WINCREATE, (uint64_t)title, (uint64_t)w, (uint64_t)h, (uint64_t)result);
     }
     inline int win_destroy(int id) {
-        return (int)syscall1(Montauk::SYS_WINDESTROY, (uint64_t)id);
+        return (int)syscall1(montauk::abi::SYS_WINDESTROY, (uint64_t)id);
     }
     inline uint64_t win_present(int id) {
-        return (uint64_t)syscall1(Montauk::SYS_WINPRESENT, (uint64_t)id);
+        return (uint64_t)syscall1(montauk::abi::SYS_WINPRESENT, (uint64_t)id);
     }
-    inline int win_poll(int id, Montauk::WinEvent* event) {
-        return (int)syscall2(Montauk::SYS_WINPOLL, (uint64_t)id, (uint64_t)event);
+    inline int win_poll(int id, montauk::abi::WinEvent* event) {
+        return (int)syscall2(montauk::abi::SYS_WINPOLL, (uint64_t)id, (uint64_t)event);
     }
-    inline int win_enumerate(Montauk::WinInfo* info, int max) {
-        return (int)syscall2(Montauk::SYS_WINENUM, (uint64_t)info, (uint64_t)max);
+    inline int win_enumerate(montauk::abi::WinInfo* info, int max) {
+        return (int)syscall2(montauk::abi::SYS_WINENUM, (uint64_t)info, (uint64_t)max);
     }
     inline uint64_t win_map(int id) {
-        return (uint64_t)syscall1(Montauk::SYS_WINMAP, (uint64_t)id);
+        return (uint64_t)syscall1(montauk::abi::SYS_WINMAP, (uint64_t)id);
     }
     inline int win_unmap(int id) {
-        return (int)syscall1(Montauk::SYS_WINUNMAP, (uint64_t)id);
+        return (int)syscall1(montauk::abi::SYS_WINUNMAP, (uint64_t)id);
     }
-    inline int win_sendevent(int id, const Montauk::WinEvent* event) {
-        return (int)syscall2(Montauk::SYS_WINSENDEVENT, (uint64_t)id, (uint64_t)event);
+    inline int win_sendevent(int id, const montauk::abi::WinEvent* event) {
+        return (int)syscall2(montauk::abi::SYS_WINSENDEVENT, (uint64_t)id, (uint64_t)event);
     }
     inline uint64_t win_resize(int id, int w, int h) {
-        return (uint64_t)syscall3(Montauk::SYS_WINRESIZE, (uint64_t)id, (uint64_t)w, (uint64_t)h);
+        return (uint64_t)syscall3(montauk::abi::SYS_WINRESIZE, (uint64_t)id, (uint64_t)w, (uint64_t)h);
     }
     inline int win_setscale(int scale) {
-        return (int)syscall1(Montauk::SYS_WINSETSCALE, (uint64_t)scale);
+        return (int)syscall1(montauk::abi::SYS_WINSETSCALE, (uint64_t)scale);
     }
     inline int win_getscale() {
-        return (int)syscall0(Montauk::SYS_WINGETSCALE);
+        return (int)syscall0(montauk::abi::SYS_WINGETSCALE);
     }
     inline int win_setcursor(int id, int cursor) {
-        return (int)syscall2(Montauk::SYS_WINSETCURSOR, (uint64_t)id, (uint64_t)cursor);
+        return (int)syscall2(montauk::abi::SYS_WINSETCURSOR, (uint64_t)id, (uint64_t)cursor);
     }
     inline int win_setflags(int id, uint32_t flags) {
-        return (int)syscall2(Montauk::SYS_WINSETFLAGS, (uint64_t)id, (uint64_t)flags);
+        return (int)syscall2(montauk::abi::SYS_WINSETFLAGS, (uint64_t)id, (uint64_t)flags);
     }
 
 }

programs/include/montauk/thread.h

@@ -35,7 +35,7 @@ namespace montauk {
     // Terminate the calling thread. Never returns. If called by the main
     // thread this is equivalent to exit() (the whole process exits).
     [[noreturn]] inline void thread_exit(int code = 0) {
-        syscall1(Montauk::SYS_THREAD_EXIT, (uint64_t)code);
+        syscall1(montauk::abi::SYS_THREAD_EXIT, (uint64_t)code);
         __builtin_unreachable();
     }
 
@@ -86,7 +86,7 @@ namespace montauk {
         ctx->stack_base = stack;
 
         uint64_t stack_top = ((uint64_t)stack + stack_bytes) & ~0xFULL;
-        int tid = (int)syscall3(Montauk::SYS_THREAD_SPAWN,
+        int tid = (int)syscall3(montauk::abi::SYS_THREAD_SPAWN,
                                 (uint64_t)&detail::thread_trampoline,
                                 (uint64_t)ctx, stack_top);
         if (tid < 0) {
@@ -101,13 +101,13 @@ namespace montauk {
     // success (with the thread's exit code in *out_code if non-null) or
     // -1 if `tid` is not a joinable sibling.
     inline int thread_join(int tid, int* out_code = nullptr) {
-        return (int)syscall2(Montauk::SYS_THREAD_JOIN,
+        return (int)syscall2(montauk::abi::SYS_THREAD_JOIN,
                              (uint64_t)tid, (uint64_t)out_code);
     }
 
     // Return the calling thread's TID (== getpid() for the main thread).
     inline int thread_self() {
-        return (int)syscall0(Montauk::SYS_THREAD_SELF);
+        return (int)syscall0(montauk::abi::SYS_THREAD_SELF);
     }
 
     // Lightweight mutex backed by a single atomic word + the kernel

programs/include/print/print.hpp

@@ -218,7 +218,7 @@ inline void parse_key_value_lines(char* text, Fn fn) {
 
 inline void now_string(char* out, int out_len) {
     if (out == nullptr || out_len <= 0) return;
-    Montauk::DateTime dt = {};
+    montauk::abi::DateTime dt = {};
     montauk::gettime(&dt);
     snprintf(out, (size_t)out_len, "%04d-%02d-%02d %02d:%02d:%02d",
              (int)dt.Year, (int)dt.Month, (int)dt.Day,
@@ -1010,11 +1010,11 @@ inline bool daemon_is_running(int* out_pid) {
 
     int handle = montauk::proc_open(pid);
     if (handle < 0) return false;
-    uint32_t sig = montauk::wait_handle(handle, Montauk::IPC_SIGNAL_EXITED, 0);
+    uint32_t sig = montauk::wait_handle(handle, montauk::abi::IPC_SIGNAL_EXITED, 0);
     montauk::close(handle);
-    if (sig & Montauk::IPC_SIGNAL_EXITED) return false;
+    if (sig & montauk::abi::IPC_SIGNAL_EXITED) return false;
 
-    Montauk::ProcInfo procs[128];
+    montauk::abi::ProcInfo procs[128];
     int proc_count = montauk::proclist(procs, (int)(sizeof(procs) / sizeof(procs[0])));
     bool matched = false;
     for (int i = 0; i < proc_count; i++) {
@@ -1289,9 +1289,9 @@ inline int send_all_plain(int fd, const uint8_t* data, int len) {
         if (n < 0) return -1;
 
         uint32_t sig = montauk::wait_handle(fd,
-            Montauk::IPC_SIGNAL_WRITABLE | Montauk::IPC_SIGNAL_PEER_CLOSED,
+            montauk::abi::IPC_SIGNAL_WRITABLE | montauk::abi::IPC_SIGNAL_PEER_CLOSED,
             1000);
-        if (sig & Montauk::IPC_SIGNAL_PEER_CLOSED) return -1;
+        if (sig & montauk::abi::IPC_SIGNAL_PEER_CLOSED) return -1;
         if (montauk::get_milliseconds() >= deadline) return -1;
         montauk::sleep_ms(1);
     }
@@ -1379,13 +1379,13 @@ inline int recv_http_plain(int fd, char* buf, int cap) {
         if (montauk::get_milliseconds() >= deadline) break;
 
         uint32_t sig = montauk::wait_handle(fd,
-            Montauk::IPC_SIGNAL_READABLE | Montauk::IPC_SIGNAL_PEER_CLOSED,
+            montauk::abi::IPC_SIGNAL_READABLE | montauk::abi::IPC_SIGNAL_PEER_CLOSED,
             1000);
         if (sig == 0) continue;
 
-        if (sig & Montauk::IPC_SIGNAL_PEER_CLOSED)
+        if (sig & montauk::abi::IPC_SIGNAL_PEER_CLOSED)
             peer_closed = true;
-        if (!(sig & Montauk::IPC_SIGNAL_READABLE)) {
+        if (!(sig & montauk::abi::IPC_SIGNAL_READABLE)) {
             if (peer_closed) break;
             continue;
         }
@@ -1525,7 +1525,7 @@ inline bool ipp_http_post(const IppUri* uri,
                                    tas, raw, HTTP_RESPONSE_MAX - 1);
         if (tas.anchors) free(tas.anchors);
     } else {
-        int fd = montauk::socket(Montauk::SOCK_TCP);
+        int fd = montauk::socket(montauk::abi::SOCK_TCP);
         if (fd < 0) {
             free(raw);
             free(req);