diff --git a/include/meson.build b/include/meson.build
index 5d870ac..5c6ea12 100644
--- a/include/meson.build
+++ b/include/meson.build
@@ -1,29 +1,4 @@
-stdplus_headers = include_directories('.')
-
-if has_dl
-  install_headers(
-    'stdplus/dl.hpp',
-    subdir: 'stdplus')
-endif
-
-if has_fd
-  install_headers(
-    'stdplus/fd/create.hpp',
-    'stdplus/fd/dupable.hpp',
-    'stdplus/fd/gmock.hpp',
-    'stdplus/fd/impl.hpp',
-    'stdplus/fd/intf.hpp',
-    'stdplus/fd/managed.hpp',
-    'stdplus/fd/mmap.hpp',
-    'stdplus/fd/ops.hpp',
-    subdir: 'stdplus/fd')
-endif
-
-if has_io_uring
-  install_headers(
-    'stdplus/io_uring.hpp',
-    subdir: 'stdplus')
-endif
+stdplus_headers = [include_directories('.')]
 
 install_headers(
   'stdplus/cancel.hpp',
diff --git a/include/stdplus/dl.hpp b/include/stdplus/dl.hpp
deleted file mode 100644
index 0526391..0000000
--- a/include/stdplus/dl.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#pragma once
-#include <dlfcn.h>
-#include <link.h>
-
-#include <stdplus/flags.hpp>
-#include <stdplus/handle/managed.hpp>
-
-namespace stdplus
-{
-
-enum class DlOpenType : int
-{
-    Lazy = RTLD_LAZY,
-    Now = RTLD_NOW,
-};
-
-enum class DlOpenFlag : int
-{
-    Global = RTLD_GLOBAL,
-    Local = RTLD_LOCAL,
-    NoDelete = RTLD_NODELETE,
-    NoLoad = RTLD_NOLOAD,
-    DeepBind = RTLD_DEEPBIND,
-};
-
-class DlOpenFlags : public stdplus::BitFlags<int, DlOpenFlag>
-{
-  public:
-    inline DlOpenFlags(DlOpenType type) :
-        BitFlags<int, DlOpenFlag>(static_cast<int>(type))
-    {
-    }
-
-    inline DlOpenFlags(BitFlags<int, DlOpenFlag> flags) :
-        BitFlags<int, DlOpenFlag>(flags)
-    {
-    }
-};
-
-class Dl
-{
-  public:
-    Dl(const char* filename, DlOpenFlags flags);
-
-    struct link_map* linkMap();
-
-  private:
-    void info(int request, void* info);
-
-    static void* open(const char* filename, int flags);
-    static void close(void*&& handle);
-    stdplus::Managed<void*>::Handle<close> handle;
-};
-
-} // namespace stdplus
diff --git a/include/stdplus/fd/create.hpp b/include/stdplus/fd/create.hpp
deleted file mode 100644
index 83aa2ba..0000000
--- a/include/stdplus/fd/create.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-#pragma once
-#include <fcntl.h>
-#include <netinet/ip.h>
-#include <stdplus/fd/dupable.hpp>
-#include <stdplus/flags.hpp>
-#include <string>
-
-namespace stdplus
-{
-namespace fd
-{
-
-enum class OpenAccess : int
-{
-    ReadOnly = O_RDONLY,
-    WriteOnly = O_WRONLY,
-    ReadWrite = O_RDWR,
-};
-
-enum class OpenFlag : int
-{
-    Append = O_APPEND,
-    Async = O_ASYNC,
-    CloseOnExec = O_CLOEXEC,
-    Create = O_CREAT,
-    Direct = O_DIRECT,
-    Directory = O_DIRECTORY,
-    Dsync = O_DSYNC,
-    EnsureCreate = O_EXCL,
-    LargeFile = O_LARGEFILE,
-    NoAtime = O_NOATIME,
-    NoCtty = O_NOCTTY,
-    NoFollow = O_NOFOLLOW,
-    NonBlock = O_NONBLOCK,
-    Path = O_PATH,
-    Sync = O_SYNC,
-    TmpFile = O_TMPFILE,
-    Trunc = O_TRUNC,
-};
-
-class OpenFlags : public BitFlags<int, OpenFlag>
-{
-  public:
-    inline OpenFlags(OpenAccess access) :
-        BitFlags<int, OpenFlag>(static_cast<int>(access))
-    {
-    }
-
-    inline OpenFlags(BitFlags<int, OpenFlag> flags) :
-        BitFlags<int, OpenFlag>(flags)
-    {
-    }
-};
-
-DupableFd open(const char* pathname, OpenFlags flags, mode_t mode = 0);
-inline DupableFd open(const std::string& pathname, OpenFlags flags,
-                      mode_t mode = 0)
-{
-    return open(pathname.c_str(), flags, mode);
-}
-
-enum class SocketDomain : int
-{
-    INet = AF_INET,
-    INet6 = AF_INET6,
-    Netlink = AF_NETLINK,
-    Packet = AF_PACKET,
-    UNIX = AF_UNIX,
-};
-
-enum class SocketType : int
-{
-    Datagram = SOCK_DGRAM,
-    Raw = SOCK_RAW,
-    Stream = SOCK_STREAM,
-};
-
-enum class SocketProto : int
-{
-    ICMP = IPPROTO_ICMP,
-    IP = IPPROTO_IP,
-    Raw = IPPROTO_RAW,
-    TCP = IPPROTO_TCP,
-    UDP = IPPROTO_UDP,
-};
-
-DupableFd socket(SocketDomain domain, SocketType type, SocketProto protocol);
-
-} // namespace fd
-} // namespace stdplus
diff --git a/include/stdplus/fd/dupable.hpp b/include/stdplus/fd/dupable.hpp
deleted file mode 100644
index 0f810cf..0000000
--- a/include/stdplus/fd/dupable.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-#pragma once
-#include <stdplus/fd/impl.hpp>
-#include <stdplus/fd/managed.hpp>
-#include <stdplus/handle/copyable.hpp>
-
-namespace stdplus
-{
-namespace fd
-{
-namespace detail
-{
-
-int ref(const int& fd);
-
-using DupableFdHandle = Copyable<int>::Handle<drop, ref>;
-
-} // namespace detail
-
-/** @class DupableFd
- *  @brief Holds references to file descriptors which can be dup'd
- *  @details Provides RAII semantics for file descriptors
- */
-class DupableFd : public FdImpl
-{
-  public:
-    /** @brief Constructs an empty file descriptor */
-    DupableFd() noexcept;
-
-    /** @brief Duplicates and holds a file descriptor
-     *         Does not automatically close the input descriptor
-     *
-     *  @param[in] fd  - File descriptor being duplicated
-     *  @throws std::system_error for underlying syscall failures
-     */
-    explicit DupableFd(const int& fd);
-
-    /** @brief Holds the input file descriptor
-     *         Becomes the sole owner of the file descriptor
-     *
-     *  @param[in] fd  - File descriptor to hold
-     */
-    explicit DupableFd(int&& fd);
-
-    /** @brief Unmanages the file descriptor and returns the value with
-     *         ownership to the caller.
-     *
-     *  @return The file descriptor number
-     */
-    [[nodiscard]] int release();
-
-    int get() const override;
-
-  private:
-    friend class ManagedFd;
-    detail::DupableFdHandle handle;
-};
-
-} // namespace fd
-
-using fd::DupableFd;
-
-} // namespace stdplus
diff --git a/include/stdplus/fd/gmock.hpp b/include/stdplus/fd/gmock.hpp
deleted file mode 100644
index ca3b2af..0000000
--- a/include/stdplus/fd/gmock.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#pragma once
-#include <gmock/gmock.h>
-#include <stdplus/fd/intf.hpp>
-
-namespace stdplus
-{
-namespace fd
-{
-
-class FdMock : public Fd
-{
-  public:
-    MOCK_METHOD(std::span<std::byte>, read, (std::span<std::byte> buf),
-                (override));
-    MOCK_METHOD(std::span<std::byte>, recv,
-                (std::span<std::byte> buf, RecvFlags flags), (override));
-    MOCK_METHOD(std::span<const std::byte>, write,
-                (std::span<const std::byte> data), (override));
-    MOCK_METHOD(std::span<const std::byte>, send,
-                (std::span<const std::byte> data, SendFlags flags), (override));
-    MOCK_METHOD(size_t, lseek, (off_t offset, Whence whence), (override));
-    MOCK_METHOD(void, truncate, (off_t size), (override));
-    MOCK_METHOD(void, bind, (std::span<const std::byte> sockaddr), (override));
-    MOCK_METHOD(void, listen, (int backlog), (override));
-    MOCK_METHOD((std::tuple<std::optional<int>, std::span<std::byte>>), accept,
-                (std::span<std::byte> sockaddr), (override));
-    MOCK_METHOD(void, setsockopt,
-                (SockLevel level, SockOpt optname,
-                 std::span<const std::byte> opt),
-                (override));
-    MOCK_METHOD(int, ioctl, (unsigned long id, void* data), (override));
-    MOCK_METHOD(int, constIoctl, (unsigned long id, void* data),
-                (const, override));
-    MOCK_METHOD(void, fcntlSetfd, (FdFlags flags), (override));
-    MOCK_METHOD(FdFlags, fcntlGetfd, (), (const, override));
-    MOCK_METHOD(void, fcntlSetfl, (FileFlags flags), (override));
-    MOCK_METHOD(FileFlags, fcntlGetfl, (), (const, override));
-    MOCK_METHOD(std::span<std::byte>, mmap,
-                (std::span<std::byte> window, ProtFlags prot, MMapFlags flags,
-                 off_t offset),
-                (override));
-    MOCK_METHOD(void, munmap, (std::span<std::byte> window), (override));
-};
-
-} // namespace fd
-
-using fd::FdMock;
-
-} // namespace stdplus
diff --git a/include/stdplus/fd/impl.hpp b/include/stdplus/fd/impl.hpp
deleted file mode 100644
index 9d5acaf..0000000
--- a/include/stdplus/fd/impl.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#pragma once
-#include <stdplus/fd/intf.hpp>
-
-namespace stdplus
-{
-namespace fd
-{
-
-class FdImpl : public Fd
-{
-  public:
-    virtual int get() const = 0;
-
-    std::span<std::byte> read(std::span<std::byte> buf) override;
-    std::span<std::byte> recv(std::span<std::byte> buf,
-                              RecvFlags flags) override;
-    std::span<const std::byte> write(std::span<const std::byte> data) override;
-    std::span<const std::byte> send(std::span<const std::byte> data,
-                                    SendFlags flags) override;
-    size_t lseek(off_t offset, Whence whence) override;
-    void truncate(off_t size) override;
-    void bind(std::span<const std::byte> sockaddr) override;
-    void listen(int backlog) override;
-    std::tuple<std::optional<int>, std::span<std::byte>>
-        accept(std::span<std::byte> sockaddr) override;
-    void setsockopt(SockLevel level, SockOpt optname,
-                    std::span<const std::byte> opt) override;
-    int ioctl(unsigned long id, void* data) override;
-    int constIoctl(unsigned long id, void* data) const override;
-    void fcntlSetfd(FdFlags flags) override;
-    FdFlags fcntlGetfd() const override;
-    void fcntlSetfl(FileFlags flags) override;
-    FileFlags fcntlGetfl() const override;
-
-  protected:
-    std::span<std::byte> mmap(std::span<std::byte> window, ProtFlags prot,
-                              MMapFlags flags, off_t offset) override;
-    void munmap(std::span<std::byte> window) override;
-};
-
-} // namespace fd
-
-using fd::FdImpl;
-
-} // namespace stdplus
diff --git a/include/stdplus/fd/intf.hpp b/include/stdplus/fd/intf.hpp
deleted file mode 100644
index 4d9553d..0000000
--- a/include/stdplus/fd/intf.hpp
+++ /dev/null
@@ -1,157 +0,0 @@
-#pragma once
-#include <cstddef>
-#include <fcntl.h>
-#include <optional>
-#include <span>
-#include <stdplus/flags.hpp>
-#include <sys/mman.h>
-#include <sys/socket.h>
-#include <tuple>
-
-namespace stdplus
-{
-namespace fd
-{
-
-enum class RecvFlag : int
-{
-    DontWait = MSG_DONTWAIT,
-    ErrQueue = MSG_ERRQUEUE,
-    OutOfBounds = MSG_OOB,
-    Peek = MSG_PEEK,
-    Trunc = MSG_TRUNC,
-    WaitAll = MSG_WAITALL,
-};
-using RecvFlags = BitFlags<int, RecvFlag>;
-
-enum class SendFlag : int
-{
-    Confirm = MSG_CONFIRM,
-    DontRoute = MSG_DONTROUTE,
-    DontWait = MSG_DONTWAIT,
-    EndOfRecord = MSG_EOR,
-    More = MSG_MORE,
-    NoSignal = MSG_NOSIGNAL,
-    OutOfBounds = MSG_OOB,
-};
-using SendFlags = BitFlags<int, SendFlag>;
-
-enum class Whence : int
-{
-    Set = SEEK_SET,
-    Cur = SEEK_CUR,
-    End = SEEK_END,
-};
-
-enum class SockLevel : int
-{
-    Socket = SOL_SOCKET,
-};
-
-enum class SockOpt : int
-{
-    Debug = SO_DEBUG,
-    Broadcast = SO_BROADCAST,
-    ReuseAddr = SO_REUSEADDR,
-    KeepAlive = SO_KEEPALIVE,
-    Linger = SO_LINGER,
-    OOBInline = SO_OOBINLINE,
-    SendBuf = SO_SNDBUF,
-    RecvBuf = SO_RCVBUF,
-    DontRoute = SO_DONTROUTE,
-    RecvLowWait = SO_RCVLOWAT,
-    RecvTimeout = SO_RCVTIMEO,
-    SendLowWait = SO_SNDLOWAT,
-    SendTimeout = SO_SNDTIMEO,
-};
-
-enum class FdFlag : int
-{
-    CloseOnExec = FD_CLOEXEC,
-};
-using FdFlags = BitFlags<int, FdFlag>;
-
-enum class FileFlag : int
-{
-    Append = O_APPEND,
-    Async = O_ASYNC,
-    Direct = O_DIRECT,
-    NoAtime = O_NOATIME,
-    NonBlock = O_NONBLOCK,
-};
-using FileFlags = BitFlags<int, FileFlag>;
-
-enum class ProtFlag : int
-{
-    Exec = PROT_EXEC,
-    Read = PROT_READ,
-    Write = PROT_WRITE,
-};
-using ProtFlags = BitFlags<int, ProtFlag>;
-
-enum class MMapAccess : int
-{
-    Shared = MAP_SHARED,
-    Private = MAP_PRIVATE,
-};
-
-enum class MMapFlag : int
-{
-};
-
-class MMapFlags : public BitFlags<int, MMapFlag>
-{
-  public:
-    inline MMapFlags(MMapAccess access) :
-        BitFlags<int, MMapFlag>(static_cast<int>(access))
-    {
-    }
-
-    inline MMapFlags(BitFlags<int, MMapFlag> flags) :
-        BitFlags<int, MMapFlag>(flags)
-    {
-    }
-};
-
-class MMap;
-
-class Fd
-{
-  public:
-    virtual ~Fd() = default;
-
-    virtual std::span<std::byte> read(std::span<std::byte> buf) = 0;
-    virtual std::span<std::byte> recv(std::span<std::byte> buf,
-                                      RecvFlags flags) = 0;
-    virtual std::span<const std::byte>
-        write(std::span<const std::byte> data) = 0;
-    virtual std::span<const std::byte> send(std::span<const std::byte> data,
-                                            SendFlags flags) = 0;
-    virtual size_t lseek(off_t offset, Whence whence) = 0;
-    virtual void truncate(off_t size) = 0;
-    virtual void bind(std::span<const std::byte> sockaddr) = 0;
-    virtual void listen(int backlog) = 0;
-    virtual std::tuple<std::optional<int>, std::span<std::byte>>
-        accept(std::span<std::byte> sockaddr) = 0;
-    virtual void setsockopt(SockLevel level, SockOpt optname,
-                            std::span<const std::byte> opt) = 0;
-    virtual int ioctl(unsigned long id, void* data) = 0;
-    virtual int constIoctl(unsigned long id, void* data) const = 0;
-    virtual void fcntlSetfd(FdFlags flags) = 0;
-    virtual FdFlags fcntlGetfd() const = 0;
-    virtual void fcntlSetfl(FileFlags flags) = 0;
-    virtual FileFlags fcntlGetfl() const = 0;
-
-  protected:
-    virtual std::span<std::byte> mmap(std::span<std::byte> window,
-                                      ProtFlags prot, MMapFlags flags,
-                                      off_t offset) = 0;
-    virtual void munmap(std::span<std::byte> window) = 0;
-    friend class MMap;
-};
-
-} // namespace fd
-
-using fd::Fd;
-
-} // namespace stdplus
diff --git a/include/stdplus/fd/managed.hpp b/include/stdplus/fd/managed.hpp
deleted file mode 100644
index a188421..0000000
--- a/include/stdplus/fd/managed.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-#pragma once
-#include <stdplus/fd/impl.hpp>
-#include <stdplus/handle/managed.hpp>
-
-namespace stdplus
-{
-namespace fd
-{
-namespace detail
-{
-
-/** @brief Closes the file descriptor when dropping an Fd handle
- *
- *  @param[in] fd - File descriptor to close
- */
-void drop(int&& fd);
-
-using ManagedFdHandle = Managed<int>::Handle<drop>;
-
-} // namespace detail
-
-class DupableFd;
-
-/** @class ManagedFd
- *  @brief Holds references to unique, non-dupable file descriptors
- *  @details Provides RAII semantics for file descriptors
- */
-class ManagedFd : public FdImpl
-{
-  public:
-    /** @brief Constructs an empty file descriptor */
-    ManagedFd() noexcept;
-
-    /** @brief Holds the input file descriptor
-     *         Becomes the sole owner of the file descriptor
-     *
-     *  @param[in] fd  - File descriptor to hold
-     */
-    explicit ManagedFd(int&& fd);
-
-    ManagedFd(DupableFd&& other) noexcept;
-    ManagedFd(const DupableFd& other);
-    ManagedFd& operator=(DupableFd&& other) noexcept;
-    ManagedFd& operator=(const DupableFd& other);
-
-    /** @brief Unmanages the file descriptor and returns the value with
-     *         ownership to the caller.
-     *
-     *  @return The file descriptor number
-     */
-    [[nodiscard]] int release();
-
-    int get() const override;
-
-  private:
-    detail::ManagedFdHandle handle;
-};
-
-} // namespace fd
-
-using fd::ManagedFd;
-
-} // namespace stdplus
diff --git a/include/stdplus/fd/mmap.hpp b/include/stdplus/fd/mmap.hpp
deleted file mode 100644
index 06b7944..0000000
--- a/include/stdplus/fd/mmap.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#pragma once
-#include <cstddef>
-#include <functional>
-#include <span>
-#include <stdplus/fd/intf.hpp>
-#include <stdplus/handle/managed.hpp>
-
-namespace stdplus
-{
-namespace fd
-{
-
-class MMap
-{
-  public:
-    inline MMap(Fd& fd, size_t window_size, ProtFlags prot, MMapFlags flags,
-                off_t offset) :
-        MMap(
-            fd,
-            std::span<std::byte>{static_cast<std::byte*>(nullptr), window_size},
-            prot, flags, offset)
-    {
-    }
-    MMap(Fd& fd, std::span<std::byte> window, ProtFlags prot, MMapFlags flags,
-         off_t offset);
-
-    std::span<std::byte> get() const;
-
-  private:
-    static void drop(std::span<std::byte>&&, std::reference_wrapper<Fd>&);
-    Managed<std::span<std::byte>, std::reference_wrapper<Fd>>::Handle<drop>
-        mapping;
-};
-
-} // namespace fd
-} // namespace stdplus
diff --git a/include/stdplus/fd/ops.hpp b/include/stdplus/fd/ops.hpp
deleted file mode 100644
index 8f3735b..0000000
--- a/include/stdplus/fd/ops.hpp
+++ /dev/null
@@ -1,179 +0,0 @@
-#pragma once
-#include <span>
-#include <stdexcept>
-#include <stdplus/fd/dupable.hpp>
-#include <stdplus/fd/intf.hpp>
-#include <stdplus/raw.hpp>
-#include <utility>
-
-namespace stdplus
-{
-namespace fd
-{
-namespace detail
-{
-
-void readExact(Fd& fd, std::span<std::byte> data);
-void recvExact(Fd& fd, std::span<std::byte> data, RecvFlags flags);
-void writeExact(Fd& fd, std::span<const std::byte> data);
-void sendExact(Fd& fd, std::span<const std::byte> data, SendFlags flags);
-
-std::span<std::byte> readAligned(Fd& fd, size_t align,
-                                 std::span<std::byte> buf);
-std::span<std::byte> recvAligned(Fd& fd, size_t align, std::span<std::byte> buf,
-                                 RecvFlags flags);
-std::span<const std::byte> writeAligned(Fd& fd, size_t align,
-                                        std::span<const std::byte> data);
-std::span<const std::byte> sendAligned(Fd& fd, size_t align,
-                                       std::span<const std::byte> data,
-                                       SendFlags flags);
-
-template <typename Fun, typename Container, typename... Args>
-auto alignedOp(Fun&& fun, Fd& fd, Container&& c, Args&&... args)
-{
-    using Data = raw::detail::dataType<Container>;
-    auto ret = fun(fd, sizeof(Data), raw::asSpan<std::byte>(c),
-                   std::forward<Args>(args)...);
-    return std::span<Data>(std::begin(c), ret.size() / sizeof(Data));
-}
-
-} // namespace detail
-
-template <typename Container>
-inline auto read(Fd& fd, Container&& c)
-{
-    return detail::alignedOp(detail::readAligned, fd,
-                             std::forward<Container>(c));
-}
-
-template <typename Container>
-inline auto recv(Fd& fd, Container&& c, RecvFlags flags)
-{
-    return detail::alignedOp(detail::recvAligned, fd,
-                             std::forward<Container>(c), flags);
-}
-
-template <typename Container>
-inline auto write(Fd& fd, Container&& c)
-{
-    return detail::alignedOp(detail::writeAligned, fd,
-                             std::forward<Container>(c));
-}
-
-template <typename Container>
-inline auto send(Fd& fd, Container&& c, SendFlags flags)
-{
-    return detail::alignedOp(detail::sendAligned, fd,
-                             std::forward<Container>(c), flags);
-}
-
-template <typename T>
-inline void readExact(Fd& fd, T&& t)
-{
-    detail::readExact(fd, raw::asSpan<std::byte>(t));
-}
-
-template <typename T>
-inline void recvExact(Fd& fd, T&& t, RecvFlags flags)
-{
-    detail::recvExact(fd, raw::asSpan<std::byte>(t), flags);
-}
-
-template <typename T>
-inline void writeExact(Fd& fd, T&& t)
-{
-    detail::writeExact(fd, raw::asSpan<std::byte>(t));
-}
-
-template <typename T>
-inline void sendExact(Fd& fd, T&& t, SendFlags flags)
-{
-    detail::sendExact(fd, raw::asSpan<std::byte>(t), flags);
-}
-
-inline size_t lseek(Fd& fd, off_t offset, Whence whence)
-{
-    return fd.lseek(offset, whence);
-}
-
-inline void truncate(Fd& fd, off_t size)
-{
-    return fd.truncate(size);
-}
-
-template <typename SockAddr>
-inline void bind(Fd& fd, SockAddr&& sockaddr)
-{
-    return fd.bind(raw::asSpan<std::byte>(sockaddr));
-}
-
-inline void listen(Fd& fd, int backlog)
-{
-    return fd.listen(backlog);
-}
-
-template <typename SockAddr>
-inline std::optional<stdplus::DupableFd> accept(Fd& fd, SockAddr&& sockaddr)
-{
-    auto ret = fd.accept(raw::asSpan<std::byte>(sockaddr));
-    if (!std::get<0>(ret))
-    {
-        return std::nullopt;
-    }
-    if (std::get<1>(ret).size() != sizeof(sockaddr))
-    {
-        throw std::runtime_error("Invalid sockaddr type for accept");
-    }
-    return stdplus::DupableFd(std::move(*std::get<0>(ret)));
-}
-
-inline std::optional<stdplus::DupableFd> accept(Fd& fd)
-{
-    auto ret = std::get<0>(fd.accept(std::span<std::byte>{}));
-    if (!ret)
-    {
-        return std::nullopt;
-    }
-    return stdplus::DupableFd(std::move(*ret));
-}
-
-template <typename Opt>
-inline void setsockopt(Fd& fd, SockLevel level, SockOpt optname, Opt&& opt)
-{
-    return fd.setsockopt(level, optname, raw::asSpan<std::byte>(opt));
-}
-
-template <typename Data>
-inline int constIoctl(const Fd& fd, unsigned long id, Data&& data)
-{
-    return fd.constIoctl(id, raw::asSpan<std::byte>(data).data());
-}
-
-template <typename Data>
-inline int ioctl(Fd& fd, unsigned long id, Data&& data)
-{
-    return fd.ioctl(id, raw::asSpan<std::byte>(data).data());
-}
-
-inline FdFlags getFdFlags(const Fd& fd)
-{
-    return fd.fcntlGetfd();
-}
-
-inline void setFdFlags(Fd& fd, FdFlags flags)
-{
-    return fd.fcntlSetfd(flags);
-}
-
-inline FileFlags getFileFlags(const Fd& fd)
-{
-    return fd.fcntlGetfl();
-}
-
-inline void setFileFlags(Fd& fd, FileFlags flags)
-{
-    return fd.fcntlSetfl(flags);
-}
-
-} // namespace fd
-} // namespace stdplus
diff --git a/include/stdplus/io_uring.hpp b/include/stdplus/io_uring.hpp
deleted file mode 100644
index 6572e04..0000000
--- a/include/stdplus/io_uring.hpp
+++ /dev/null
@@ -1,140 +0,0 @@
-#pragma once
-
-#include <liburing.h>
-
-#include <stdplus/fd/managed.hpp>
-#include <stdplus/handle/managed.hpp>
-
-#include <chrono>
-#include <optional>
-#include <vector>
-
-namespace stdplus
-{
-
-/** @brief Converts a chrono duration into a kernel duration */
-__kernel_timespec chronoToKTS(std::chrono::nanoseconds t) noexcept;
-
-class IoUring
-{
-  public:
-    struct CQEHandler
-    {
-        CQEHandler() = default;
-        CQEHandler(CQEHandler&&) = delete;
-        CQEHandler& operator=(CQEHandler&&) = delete;
-        CQEHandler(const CQEHandler&) = delete;
-        CQEHandler& operator=(const CQEHandler&) = delete;
-        virtual ~CQEHandler() = default;
-
-        virtual void handleCQE(io_uring_cqe&) noexcept = 0;
-    };
-
-    class FileHandle
-    {
-      public:
-        inline operator int() const
-        {
-            return *slot;
-        }
-
-      private:
-        explicit FileHandle(unsigned slot, IoUring& ring);
-
-        static void drop(unsigned&& slot, IoUring*& ring);
-
-        Managed<unsigned, IoUring*>::Handle<drop> slot;
-
-        friend class IoUring;
-    };
-
-    explicit IoUring(size_t queue_size = 10, int flags = 0);
-    explicit IoUring(size_t queue_size, io_uring_params& params);
-
-    IoUring(IoUring&&) = delete;
-    IoUring& operator=(IoUring&&) = delete;
-    IoUring(const IoUring&) = delete;
-    IoUring& operator=(const IoUring&) = delete;
-    ~IoUring();
-
-    /** @brief Reserves an additional number of file descriptor slots
-     *
-     *  @param[in] num - The number of slots to register
-     *  @throws std::system_error if the allocation fails
-     */
-    void reserveFiles(size_t num);
-
-    /** @brief Registers a file descriptor with a slot on the ring
-     *
-     *  @param[in] fd - The file descriptor to register
-     *  @throws std::system_error if the allocation fails
-     *  @return A handle to the registered file on the ring
-     */
-    [[nodiscard]] FileHandle registerFile(int fd);
-
-    /** @brief Get current list of files descriptors registered on the ring.
-     * Note this view potentially expires when registrations change. */
-    inline std::span<const int> getFiles() const noexcept
-    {
-        return files;
-    }
-
-    /** @brief Gets an unused SQE from the ring
-     *
-     *  @throws std::system_error if the allocation fails
-     *  @return An SQE on the ring
-     */
-    io_uring_sqe& getSQE();
-
-    /** @brief Associates the SQE with a user provided callback handler
-     *
-     *  @param[in] sqe - The SQE that we want to register
-     *  @param[in] h   - The handler which will be run when the CQE comes back
-     */
-    void setHandler(io_uring_sqe& sqe, CQEHandler* h) noexcept;
-
-    /** @brief Cancels the outstanding request associated with a handler
-     *
-     *  @param[in] h - The handler associated with the request
-     */
-    void cancelHandler(CQEHandler& h);
-
-    /** @brief Submits all outstanding SQEs to the kernel
-     *
-     *  @throws std::system_error if the submission fails
-     */
-    void submit();
-
-    /** @brief Non-blocking process all outstanding CQEs */
-    void process() noexcept;
-
-    /** @brief Waits for new CQEs to become available */
-    void wait();
-    void wait(std::chrono::nanoseconds timeout);
-
-    /** @brief Returns the EventFD associated with the ring
-     *         A new descriptor is created if it does not yet exist
-     *
-     *  @throws std::system_error if constructing the event fd fails
-     *  @return A reference to the descriptor
-     */
-    stdplus::ManagedFd& getEventFd();
-
-    /** @brief Non-blocking process all outstanding eventFd events
-     *         Should be used instead of process() to clear eventFd events.
-     */
-    void processEvents();
-
-  private:
-    io_uring ring;
-    std::optional<stdplus::ManagedFd> event_fd;
-    std::vector<CQEHandler*> handlers;
-    std::vector<int> files;
-    size_t filesAllocated = 0;
-
-    void dropHandler(CQEHandler* h, io_uring_cqe& cqe) noexcept;
-    void setFile(unsigned slot, int fd) noexcept;
-    void updateFile(unsigned slot, int fd);
-};
-
-} // namespace stdplus