kstd: flatten units namespace

64 files changed, 303 insertions, 313 deletions

diff --git a/arch/x86_64/arch/bus/cpu.cpp b/arch/x86_64/arch/bus/cpu.cpp
index 0a0e94ec..4b9edffc 100644
--- a/arch/x86_64/arch/bus/cpu.cpp
+++ b/arch/x86_64/arch/bus/cpu.cpp
@@ -27,7 +27,7 @@ namespace arch::bus
     constexpr auto candidate_flags = ::acpi::processor_local_apic_entry::flags::processor_enabled  //
                                      | ::acpi::processor_local_apic_entry::flags::online_capable;
 
-    constexpr auto lapic_mmio_range_size = kstd::units::bytes{0x400};
+    constexpr auto lapic_mmio_range_size = kstd::bytes{0x400};
 
     struct protocol final : kapi::devices::bus_protocol
     {
diff --git a/arch/x86_64/arch/drivers/cpu/lapic.hpp b/arch/x86_64/arch/drivers/cpu/lapic.hpp
index f2a8a4e9..678d364a 100644
--- a/arch/x86_64/arch/drivers/cpu/lapic.hpp
+++ b/arch/x86_64/arch/drivers/cpu/lapic.hpp
@@ -40,6 +40,6 @@ namespace arch::drivers::cpu
     bool m_is_mapped{};
   };
 
-}  // namespace arch::drivers
+}  // namespace arch::drivers::cpu
 
 #endif
diff --git a/arch/x86_64/arch/memory/kernel_mapper.cpp b/arch/x86_64/arch/memory/kernel_mapper.cpp
index 0ddf08dd..a15a1d9e 100644
--- a/arch/x86_64/arch/memory/kernel_mapper.cpp
+++ b/arch/x86_64/arch/memory/kernel_mapper.cpp
@@ -74,8 +74,7 @@ namespace arch::memory
   auto kernel_mapper::map_section(section_header_type const & section, std::string_view name,
                                   kapi::memory::page_mapper & mapper) -> void
   {
-    auto number_of_pages =
-        (kstd::units::bytes{section.size} + (kapi::memory::page::size - 1_B)) / kapi::memory::page::size;
+    auto number_of_pages = (kstd::bytes{section.size} + (kapi::memory::page::size - 1_B)) / kapi::memory::page::size;
     auto linear_start_address = kapi::memory::linear_address{section.virtual_load_address};
     auto physical_start_address = kapi::memory::physical_address{section.virtual_load_address & ~m_kernel_load_base};
 
diff --git a/arch/x86_64/arch/memory/page_table.hpp b/arch/x86_64/arch/memory/page_table.hpp
index 5bb4e1aa..12abacb5 100644
--- a/arch/x86_64/arch/memory/page_table.hpp
+++ b/arch/x86_64/arch/memory/page_table.hpp
@@ -117,7 +117,7 @@ namespace arch::memory
     };
 
     //! The maximum number of entries in this table.
-    constexpr auto static entry_count{kapi::memory::page::size / kstd::units::bytes{sizeof(entry)}};
+    constexpr auto static entry_count{kapi::memory::page::size / kstd::bytes{sizeof(entry)}};
 
     //! Get the entry at the given index.
     //!
diff --git a/arch/x86_64/kapi/memory.cpp b/arch/x86_64/kapi/memory.cpp
index a6f84f07..37b4c7f3 100644
--- a/arch/x86_64/kapi/memory.cpp
+++ b/arch/x86_64/kapi/memory.cpp
@@ -129,7 +129,7 @@ namespace kapi::memory
         auto module_physical_start = physical_address{module.start_address};
         auto module_virtual_start =
             linear_address{module.start_address + std::bit_cast<std::uintptr_t>(&arch::boot::TEACHOS_VMA)};
-        auto module_size = static_cast<kstd::units::bytes>(module.end_address - module.start_address);
+        auto module_size = static_cast<kstd::bytes>(module.end_address - module.start_address);
         auto module_block_count = (module_size + frame::size - 1_B) / frame::size;
 
         for (auto i = 0uz; i < module_block_count; ++i)
@@ -150,7 +150,7 @@ namespace kapi::memory
                                  }))
       {
         auto start = frame::containing(physical_address{region.base});
-        auto count = kstd::units::bytes{region.size_in_B} / page::size;
+        auto count = kstd::bytes{region.size_in_B} / page::size;
         new_allocator.release_many({start, count});
       }
 
diff --git a/kapi/kapi/devices/resource.hpp b/kapi/kapi/devices/resource.hpp
index bcad5dd5..1284ce10 100644
--- a/kapi/kapi/devices/resource.hpp
+++ b/kapi/kapi/devices/resource.hpp
@@ -78,7 +78,7 @@ namespace kapi::devices
     //! The physical start address of this range.
     kapi::memory::physical_address start;
     //! The size of this range.
-    kstd::units::bytes size;
+    kstd::bytes size;
   };
 
   //! A range of I/O ports.
diff --git a/kapi/kapi/filesystem.hpp b/kapi/kapi/filesystem.hpp
index be754748..78845a00 100644
--- a/kapi/kapi/filesystem.hpp
+++ b/kapi/kapi/filesystem.hpp
@@ -58,14 +58,14 @@ namespace kapi::filesystem
   //! @param file_descriptor The file descriptor to read from.
   //! @param buffer The buffer to store the read data.
   //! @return The number of bytes read on success, an error code otherwise.
-  auto read(size_t file_descriptor, std::span<std::byte> buffer) -> kstd::result<kstd::units::bytes>;
+  auto read(size_t file_descriptor, std::span<std::byte> buffer) -> kstd::result<kstd::bytes>;
 
   //! Write bytes from a given buffer to a file descriptor.
   //!
   //! @param file_descriptor The file descriptor to write to.
   //! @param buffer The buffer containing the data to write.
   //! @return The number of bytes written on success, an error code otherwise.
-  auto write(size_t file_descriptor, std::span<std::byte const> buffer) -> kstd::result<kstd::units::bytes>;
+  auto write(size_t file_descriptor, std::span<std::byte const> buffer) -> kstd::result<kstd::bytes>;
 
   //! Adjust the current position in the file.
   //!
@@ -74,8 +74,8 @@ namespace kapi::filesystem
   //! @param direction The direction to seek towards, relative to the origin.
   //! @param origin The origing to seek relatively to.
   //! @return The new position in the file on success, an error code otherwise.
-  auto seek(size_t file_descriptor, kstd::units::bytes offset, seek_direction direction, seek_origin origin)
-      -> kstd::result<kstd::units::bytes>;
+  auto seek(size_t file_descriptor, kstd::bytes offset, seek_direction direction, seek_origin origin)
+      -> kstd::result<kstd::bytes>;
 
   //! Create a new directory at the specified path.
   //!
diff --git a/kapi/kapi/filesystem/block_special_file.hpp b/kapi/kapi/filesystem/block_special_file.hpp
index 7b06f058..6060c5ea 100644
--- a/kapi/kapi/filesystem/block_special_file.hpp
+++ b/kapi/kapi/filesystem/block_special_file.hpp
@@ -31,7 +31,7 @@ namespace kapi::filesystem
     //! @param buffer The buffer to read into.
     //! @return The number of bytes read on success, an error otherwise.
     [[nodiscard]] auto virtual read_block(size_t block_index, std::span<std::byte> buffer)
-        -> kstd::result<kstd::units::bytes> = 0;
+        -> kstd::result<kstd::bytes> = 0;
 
     //! Write data from a buffer into a block.
     //!
@@ -44,13 +44,13 @@ namespace kapi::filesystem
     //! @param buffer The buffer to write from.
     //! @return The number of bytes written on success, an error otherwise.
     auto virtual write_block(std::size_t block_index, std::span<std::byte const> buffer)
-        -> kstd::result<kstd::units::bytes> = 0;
+        -> kstd::result<kstd::bytes> = 0;
 
     //! Get the block size in bytes.
-    [[nodiscard]] auto virtual block_size() const -> kstd::units::bytes = 0;
+    [[nodiscard]] auto virtual block_size() const -> kstd::bytes = 0;
 
     //! Get the capacity of the associated device.
-    [[nodiscard]] auto virtual capacity() const -> kstd::units::bytes = 0;
+    [[nodiscard]] auto virtual capacity() const -> kstd::bytes = 0;
   };
 
 }  // namespace kapi::filesystem
diff --git a/kapi/kapi/filesystem/character_special_file.hpp b/kapi/kapi/filesystem/character_special_file.hpp
index a2608489..c63d535b 100644
--- a/kapi/kapi/filesystem/character_special_file.hpp
+++ b/kapi/kapi/filesystem/character_special_file.hpp
@@ -25,13 +25,13 @@ namespace kapi::filesystem
     //!
     //! @param buffer The buffer to read into.
     //! @return The number of bytes read on success, an error otherwise.
-    [[nodiscard]] auto virtual read(std::span<std::byte> buffer) -> kstd::result<kstd::units::bytes> = 0;
+    [[nodiscard]] auto virtual read(std::span<std::byte> buffer) -> kstd::result<kstd::bytes> = 0;
 
     //! Write data from a buffer into the stream.
     //!
     //! @param buffer The buffer to write from.
     //! @return The number of bytes written on success, an error otherwise.
-    auto virtual write(std::span<std::byte const> buffer) -> kstd::result<kstd::units::bytes> = 0;
+    auto virtual write(std::span<std::byte const> buffer) -> kstd::result<kstd::bytes> = 0;
   };
 
 }  // namespace kapi::filesystem
diff --git a/kapi/kapi/filesystem/file_status.hpp b/kapi/kapi/filesystem/file_status.hpp
index df48f9db..bb3c776a 100644
--- a/kapi/kapi/filesystem/file_status.hpp
+++ b/kapi/kapi/filesystem/file_status.hpp
@@ -15,7 +15,7 @@ namespace kapi::filesystem
   struct file_status
   {
     std::uint32_t mode{};
-    kstd::units::bytes size{};
+    kstd::bytes size{};
     device_number raw_device{};
     std::uint64_t inode_number{};
     std::uint32_t link_count{};
diff --git a/kapi/kapi/memory/address.hpp b/kapi/kapi/memory/address.hpp
index d176d2b8..8ed6d37a 100644
--- a/kapi/kapi/memory/address.hpp
+++ b/kapi/kapi/memory/address.hpp
@@ -184,12 +184,12 @@ namespace kapi::memory
       return static_cast<MaskType>(m_value & mask);
     }
 
-    constexpr auto operator+(kstd::units::bytes n) const noexcept -> address
+    constexpr auto operator+(kstd::bytes n) const noexcept -> address
     {
       return address{m_value + n.value};
     }
 
-    constexpr auto operator+=(kstd::units::bytes n) noexcept -> address &
+    constexpr auto operator+=(kstd::bytes n) noexcept -> address &
     {
       return *this = *this + n;
     }
diff --git a/kapi/kapi/memory/chunk.hpp b/kapi/kapi/memory/chunk.hpp
index 36d83b2e..45e2ccfd 100644
--- a/kapi/kapi/memory/chunk.hpp
+++ b/kapi/kapi/memory/chunk.hpp
@@ -17,7 +17,7 @@ namespace kapi::memory
   //! @tparam ChunkType The CRTP type of the deriving class
   //! @tparam AddressType The type of addresses used to index this chunk
   //! @tparam Size The size of this chunk.
-  template<typename ChunkType, typename AddressType, kstd::units::bytes Size>
+  template<typename ChunkType, typename AddressType, kstd::bytes Size>
   struct chunk
   {
     //! The type of addresses used to index this chunk
diff --git a/kapi/kapi/memory/layout.hpp b/kapi/kapi/memory/layout.hpp
index a39997ac..bcb27fbc 100644
--- a/kapi/kapi/memory/layout.hpp
+++ b/kapi/kapi/memory/layout.hpp
@@ -13,12 +13,12 @@ namespace kapi::memory
   //! The size of a single page of virtual memory.
   //!
   //! Platforms that use different sizes of pages are expected to emulate 4 KiB pages towards the kernel.
-  constexpr auto page_size = kstd::units::KiB(4u);
+  constexpr auto page_size = kstd::KiB(4u);
 
   //! The size of a single frame of physical memory.
   //!
   //! Platforms that use different sizes of frames are expected to emulate 4 KiB pages towards the kernel.
-  constexpr auto frame_size = kstd::units::KiB(4u);
+  constexpr auto frame_size = kstd::KiB(4u);
 
   //! The linear base address of the higher-half direct map.
   //!
diff --git a/kernel/kapi/devices/device.tests.cpp b/kernel/kapi/devices/device.tests.cpp
index 138e1161..0746445c 100644
--- a/kernel/kapi/devices/device.tests.cpp
+++ b/kernel/kapi/devices/device.tests.cpp
@@ -141,7 +141,7 @@ SCENARIO("Devices allow access to their resources", "[kapi][devices]")
 
     WHEN("adding an MMIO resource")
     {
-      auto range = kapi::devices::mmio_range{{}, kstd::units::bytes{100}};
+      auto range = kapi::devices::mmio_range{{}, kstd::bytes{100}};
       device->set_resources({kapi::devices::resource{range}});
 
       AND_WHEN("trying to get the first MMIO resource via the type-safe accessor")
@@ -652,7 +652,7 @@ SCENARIO("Devices allow access to their resources", "[kapi][devices]")
   {
     auto device = kstd::make_shared<kapi::devices::device>("test_device");
 
-    auto range = kapi::devices::mmio_range{{}, kstd::units::bytes{128}};
+    auto range = kapi::devices::mmio_range{{}, kstd::bytes{128}};
     auto port_a = kapi::devices::io_port{0x40, 4};
     auto port_b = kapi::devices::io_port{0x50, 1};
 
diff --git a/kernel/kapi/filesystem.cpp b/kernel/kapi/filesystem.cpp
index d37a4cf7..419c3234 100644
--- a/kernel/kapi/filesystem.cpp
+++ b/kernel/kapi/filesystem.cpp
@@ -43,22 +43,22 @@ namespace kapi::filesystem
         .and_then([=]() { return kernel::filesystem::open_file_table::get().remove_file(file_descriptor); });
   }
 
-  auto read(size_t file_descriptor, std::span<std::byte> buffer) -> kstd::result<kstd::units::bytes>
+  auto read(size_t file_descriptor, std::span<std::byte> buffer) -> kstd::result<kstd::bytes>
   {
     return kernel::filesystem::open_file_table::get().file(file_descriptor).and_then([=](auto descriptor) {
       return descriptor->read(buffer);
     });
   }
 
-  auto write(size_t file_descriptor, std::span<std::byte const> buffer) -> kstd::result<kstd::units::bytes>
+  auto write(size_t file_descriptor, std::span<std::byte const> buffer) -> kstd::result<kstd::bytes>
   {
     return kernel::filesystem::open_file_table::get().file(file_descriptor).and_then([=](auto descriptor) {
       return descriptor->write(buffer);
     });
   }
 
-  auto seek(size_t file_descriptor, kstd::units::bytes offset, seek_direction direction, seek_origin origin)
-      -> kstd::result<kstd::units::bytes>
+  auto seek(size_t file_descriptor, kstd::bytes offset, seek_direction direction, seek_origin origin)
+      -> kstd::result<kstd::bytes>
   {
     return kernel::filesystem::open_file_table::get().file(file_descriptor).and_then([=](auto file) {
       return file->seek(offset, direction, origin);
diff --git a/kernel/kapi/memory.cpp b/kernel/kapi/memory.cpp
index 4cba7238..a0445645 100644
--- a/kernel/kapi/memory.cpp
+++ b/kernel/kapi/memory.cpp
@@ -117,7 +117,7 @@ namespace kapi::memory
   {
     using namespace kstd::units_literals;
 
-    auto const bitmap_bytes = kstd::units::bytes{(frame_count + 7uz) / 8uz};
+    auto const bitmap_bytes = kstd::bytes{(frame_count + 7uz) / 8uz};
     auto const bitmap_pages = (bitmap_bytes + page::size - 1_B) / page::size;
 
     auto const bitmap_frames = allocate_many_frames(bitmap_pages);
diff --git a/kernel/kernel/devices/block_device_utils.cpp b/kernel/kernel/devices/block_device_utils.cpp
index 0f85acd0..398e5e2a 100644
--- a/kernel/kernel/devices/block_device_utils.cpp
+++ b/kernel/kernel/devices/block_device_utils.cpp
@@ -18,15 +18,14 @@ namespace kernel::devices::block_device_utils
 
   namespace
   {
-    using block_op = kstd::result<kstd::units::bytes> (*)(size_t idx, kstd::units::bytes off, kstd::units::bytes len,
-                                                          kstd::units::bytes done,
-                                                          kapi::filesystem::block_special_file & device,
-                                                          std::span<std::byte> scratch, std::span<std::byte> buffer);
+    using block_op = kstd::result<kstd::bytes> (*)(size_t idx, kstd::bytes off, kstd::bytes len, kstd::bytes done,
+                                                   kapi::filesystem::block_special_file & device,
+                                                   std::span<std::byte> scratch, std::span<std::byte> buffer);
 
-    auto process_blocks(kapi::filesystem::block_special_file & device, kstd::units::bytes offset,
-                        std::span<std::byte> buffer, block_op op) -> kstd::result<kstd::units::bytes>
+    auto process_blocks(kapi::filesystem::block_special_file & device, kstd::bytes offset, std::span<std::byte> buffer,
+                        block_op op) -> kstd::result<kstd::bytes>
     {
-      auto requested_size = kstd::units::bytes{buffer.size()};
+      auto requested_size = kstd::bytes{buffer.size()};
 
       if (requested_size == 0_B)
       {
@@ -76,8 +75,8 @@ namespace kernel::devices::block_device_utils
     return {offset, to_transfer, device.block_size() - to_transfer};
   }
 
-  auto read(kapi::filesystem::block_special_file & device, std::span<std::byte> buffer, kstd::units::bytes offset)
-      -> kstd::result<kstd::units::bytes>
+  auto read(kapi::filesystem::block_special_file & device, std::span<std::byte> buffer, kstd::bytes offset)
+      -> kstd::result<kstd::bytes>
   {
     return process_blocks(
         device, offset, buffer, [](auto idx, auto off, auto len, auto done, auto & device, auto scratch, auto buffer) {
@@ -97,8 +96,8 @@ namespace kernel::devices::block_device_utils
         });
   }
 
-  auto write(kapi::filesystem::block_special_file & device, std::span<std::byte const> buffer,
-             kstd::units::bytes offset) -> kstd::result<kstd::units::bytes>
+  auto write(kapi::filesystem::block_special_file & device, std::span<std::byte const> buffer, kstd::bytes offset)
+      -> kstd::result<kstd::bytes>
   {
     auto non_cost_span = std::span{const_cast<std::byte *>(buffer.data()), buffer.size()};
     return process_blocks(device, offset, non_cost_span,
diff --git a/kernel/kernel/devices/block_device_utils.hpp b/kernel/kernel/devices/block_device_utils.hpp
index 02d2f0e8..c99adf67 100644
--- a/kernel/kernel/devices/block_device_utils.hpp
+++ b/kernel/kernel/devices/block_device_utils.hpp
@@ -24,9 +24,9 @@ namespace kernel::devices::block_device_utils
    */
   struct transfer_info
   {
-    kstd::units::bytes offset;
-    kstd::units::bytes to_transfer;
-    kstd::units::bytes remainder;
+    kstd::bytes offset;
+    kstd::bytes to_transfer;
+    kstd::bytes remainder;
   };
 
   [[nodiscard]] auto calculate_transfer(kapi::filesystem::block_special_file const & device, size_t block_index)
@@ -38,8 +38,8 @@ namespace kernel::devices::block_device_utils
   //! @param buffer The buffer to read data into.
   //! @param offset The offset on the block device to start reading from.
   //! @return The number of bytes actually read, which may be less than the requested size.
-  auto read(kapi::filesystem::block_special_file & device, std::span<std::byte> buffer, kstd::units::bytes offset)
-      -> kstd::result<kstd::units::bytes>;
+  auto read(kapi::filesystem::block_special_file & device, std::span<std::byte> buffer, kstd::bytes offset)
+      -> kstd::result<kstd::bytes>;
 
   //! @brief Write data from a buffer to a given block device.
   //!
@@ -47,8 +47,8 @@ namespace kernel::devices::block_device_utils
   //! @param buffer The buffer to write data from.
   //! @param offset The offset on the block device to start writing to.
   //! @return The number of bytes actually written, which may be less than the requested size.
-  auto write(kapi::filesystem::block_special_file & device, std::span<std::byte const> buffer,
-             kstd::units::bytes offset) -> kstd::result<kstd::units::bytes>;
+  auto write(kapi::filesystem::block_special_file & device, std::span<std::byte const> buffer, kstd::bytes offset)
+      -> kstd::result<kstd::bytes>;
 }  // namespace kernel::devices::block_device_utils
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel/devices/block_device_utils.tests.cpp b/kernel/kernel/devices/block_device_utils.tests.cpp
index 16a1ca87..576c9284 100644
--- a/kernel/kernel/devices/block_device_utils.tests.cpp
+++ b/kernel/kernel/devices/block_device_utils.tests.cpp
@@ -37,7 +37,7 @@ SCENARIO("reading from a block device with block_device_utils", "[devices][block
 
       THEN("the correct number of bytes is read")
       {
-        REQUIRE(bytes_read == kstd::units::bytes{read_buffer.size()});
+        REQUIRE(bytes_read == kstd::bytes{read_buffer.size()});
       }
 
       THEN("the data read matches the data written to the block device")
@@ -53,7 +53,7 @@ SCENARIO("reading from a block device with block_device_utils", "[devices][block
 
       THEN("the correct number of bytes is read")
       {
-        REQUIRE(bytes_read == kstd::units::bytes{static_cast<std::size_t>(1.5 * block_size.value)});
+        REQUIRE(bytes_read == kstd::bytes{static_cast<std::size_t>(1.5 * block_size.value)});
       }
 
       THEN("the data read matches the expected data across block boundaries")
@@ -110,7 +110,7 @@ SCENARIO("writing to a block device using block_device_utils", "[devices][block_
 
       THEN("the correct number of bytes is written")
       {
-        REQUIRE(bytes_written == kstd::units::bytes{write_buffer.size()});
+        REQUIRE(bytes_written == kstd::bytes{write_buffer.size()});
       }
 
       THEN("the data written matches the data read back from the block device")
@@ -133,7 +133,7 @@ SCENARIO("writing to a block device using block_device_utils", "[devices][block_
 
       THEN("the correct number of bytes is written")
       {
-        REQUIRE(bytes_written == kstd::units::bytes{static_cast<std::size_t>(1.5 * block_size.value)});
+        REQUIRE(bytes_written == kstd::bytes{static_cast<std::size_t>(1.5 * block_size.value)});
       }
 
       THEN("the data written matches the data read back from the block device across block boundaries")
diff --git a/kernel/kernel/drivers/pseudo/null.cpp b/kernel/kernel/drivers/pseudo/null.cpp
index f6ecf5cc..d2ae81c6 100644
--- a/kernel/kernel/drivers/pseudo/null.cpp
+++ b/kernel/kernel/drivers/pseudo/null.cpp
@@ -47,14 +47,14 @@ namespace kernel::drivers::pseudo
     struct null_node final : kapi::filesystem::character_special_file
     {
     public:
-      [[nodiscard]] auto read(std::span<std::byte>) -> kstd::result<kstd::units::bytes> override
+      [[nodiscard]] auto read(std::span<std::byte>) -> kstd::result<kstd::bytes> override
       {
         return 0_B;
       }
 
-      auto write(std::span<std::byte const> buffer) -> kstd::result<kstd::units::bytes> override
+      auto write(std::span<std::byte const> buffer) -> kstd::result<kstd::bytes> override
       {
-        return kstd::units::bytes{buffer.size()};
+        return kstd::bytes{buffer.size()};
       }
     };
 
diff --git a/kernel/kernel/drivers/pseudo/zero.cpp b/kernel/kernel/drivers/pseudo/zero.cpp
index e486a985..0d5e0f8f 100644
--- a/kernel/kernel/drivers/pseudo/zero.cpp
+++ b/kernel/kernel/drivers/pseudo/zero.cpp
@@ -47,15 +47,15 @@ namespace kernel::drivers::pseudo
     struct zero_node final : kapi::filesystem::character_special_file
     {
     public:
-      [[nodiscard]] auto read(std::span<std::byte> buffer) -> kstd::result<kstd::units::bytes> override
+      [[nodiscard]] auto read(std::span<std::byte> buffer) -> kstd::result<kstd::bytes> override
       {
         std::ranges::fill(buffer, std::byte{0});
-        return kstd::units::bytes{buffer.size()};
+        return kstd::bytes{buffer.size()};
       }
 
-      auto write(std::span<std::byte const> buffer) -> kstd::result<kstd::units::bytes> override
+      auto write(std::span<std::byte const> buffer) -> kstd::result<kstd::bytes> override
       {
-        return kstd::units::bytes{buffer.size()};
+        return kstd::bytes{buffer.size()};
       }
     };
 
diff --git a/kernel/kernel/drivers/storage/ram_disk.cpp b/kernel/kernel/drivers/storage/ram_disk.cpp
index 778feeeb..186f8cbc 100644
--- a/kernel/kernel/drivers/storage/ram_disk.cpp
+++ b/kernel/kernel/drivers/storage/ram_disk.cpp
@@ -54,10 +54,10 @@ namespace kernel::drivers::storage
       {}
 
       [[nodiscard]] auto read_block(std::size_t block_index, std::span<std::byte> buffer)
-          -> kstd::result<kstd::units::bytes> override
+          -> kstd::result<kstd::bytes> override
       {
         auto const info = devices::block_device_utils::calculate_transfer(*this, block_index);
-        auto const transfer_size = std::min(info.to_transfer, kstd::units::bytes{buffer.size()});
+        auto const transfer_size = std::min(info.to_transfer, kstd::bytes{buffer.size()});
 
         if (transfer_size > 0_B)
         {
@@ -68,11 +68,10 @@ namespace kernel::drivers::storage
         return transfer_size;
       }
 
-      auto write_block(std::size_t block_index, std::span<std::byte const> buffer)
-          -> kstd::result<kstd::units::bytes> override
+      auto write_block(std::size_t block_index, std::span<std::byte const> buffer) -> kstd::result<kstd::bytes> override
       {
         auto const info = devices::block_device_utils::calculate_transfer(*this, block_index);
-        auto const transfer_size = std::min(info.to_transfer, kstd::units::bytes{buffer.size()});
+        auto const transfer_size = std::min(info.to_transfer, kstd::bytes{buffer.size()});
 
         if (transfer_size > 0_B)
         {
@@ -83,14 +82,14 @@ namespace kernel::drivers::storage
         return transfer_size;
       }
 
-      [[nodiscard]] auto block_size() const -> kstd::units::bytes override
+      [[nodiscard]] auto block_size() const -> kstd::bytes override
       {
         return kapi::memory::page_size;
       }
 
-      [[nodiscard]] auto capacity() const -> kstd::units::bytes override
+      [[nodiscard]] auto capacity() const -> kstd::bytes override
       {
-        return kstd::units::bytes{m_module.size};
+        return kstd::bytes{m_module.size};
       }
 
     private:
diff --git a/kernel/kernel/filesystem/devfs/inode.cpp b/kernel/kernel/filesystem/devfs/inode.cpp
index 3f222f31..4153d3ac 100644
--- a/kernel/kernel/filesystem/devfs/inode.cpp
+++ b/kernel/kernel/filesystem/devfs/inode.cpp
@@ -10,12 +10,12 @@ using namespace kstd::units_literals;
 
 namespace kernel::filesystem::devfs
 {
-  auto inode::read(std::span<std::byte>, kstd::units::bytes) const -> kstd::result<kstd::units::bytes>
+  auto inode::read(std::span<std::byte>, kstd::bytes) const -> kstd::result<kstd::bytes>
   {
     return 0_B;
   }
 
-  auto inode::write(std::span<std::byte const>, kstd::units::bytes) -> kstd::result<kstd::units::bytes>
+  auto inode::write(std::span<std::byte const>, kstd::bytes) -> kstd::result<kstd::bytes>
   {
     return 0_B;
   }
diff --git a/kernel/kernel/filesystem/devfs/inode.hpp b/kernel/kernel/filesystem/devfs/inode.hpp
index 6639d180..a68baef6 100644
--- a/kernel/kernel/filesystem/devfs/inode.hpp
+++ b/kernel/kernel/filesystem/devfs/inode.hpp
@@ -24,8 +24,8 @@ namespace kernel::filesystem::devfs
     @param size Number of bytes requested.
     @return Number of bytes read (always 0 because this inode does not expose file data).
     */
-    [[nodiscard]] auto read(std::span<std::byte> buffer, kstd::units::bytes offset) const
-        -> kstd::result<kstd::units::bytes> override;
+    [[nodiscard]] auto read(std::span<std::byte> buffer, kstd::bytes offset) const
+        -> kstd::result<kstd::bytes> override;
 
     /**
     @brief Writes to the devfs directory inode.
@@ -34,8 +34,7 @@ namespace kernel::filesystem::devfs
     @param size Number of bytes requested.
     @return Number of bytes written (always 0 because writes are not supported for this inode).
     */
-    auto write(std::span<std::byte const> buffer, kstd::units::bytes offset)
-        -> kstd::result<kstd::units::bytes> override;
+    auto write(std::span<std::byte const> buffer, kstd::bytes offset) -> kstd::result<kstd::bytes> override;
 
     /**
     @brief Check if this inode represents a directory.
diff --git a/kernel/kernel/filesystem/device_inode.cpp b/kernel/kernel/filesystem/device_inode.cpp
index 53201e08..f45023d3 100644
--- a/kernel/kernel/filesystem/device_inode.cpp
+++ b/kernel/kernel/filesystem/device_inode.cpp
@@ -40,8 +40,7 @@ namespace kernel::filesystem
     }
   }
 
-  auto device_inode::read(std::span<std::byte> buffer, kstd::units::bytes offset) const
-      -> kstd::result<kstd::units::bytes>
+  auto device_inode::read(std::span<std::byte> buffer, kstd::bytes offset) const -> kstd::result<kstd::bytes>
   {
     if (m_device->state() == kapi::devices::state::removed)
     {
@@ -62,8 +61,7 @@ namespace kernel::filesystem
     return kstd::failure(vfs_errc::no_such_device);
   }
 
-  auto device_inode::write(std::span<std::byte const> buffer, kstd::units::bytes offset)
-      -> kstd::result<kstd::units::bytes>
+  auto device_inode::write(std::span<std::byte const> buffer, kstd::bytes offset) -> kstd::result<kstd::bytes>
   {
     if (m_device->state() == kapi::devices::state::removed)
     {
diff --git a/kernel/kernel/filesystem/device_inode.hpp b/kernel/kernel/filesystem/device_inode.hpp
index 759119e7..663974ed 100644
--- a/kernel/kernel/filesystem/device_inode.hpp
+++ b/kernel/kernel/filesystem/device_inode.hpp
@@ -42,8 +42,8 @@ namespace kernel::filesystem
     @param size The number of bytes to read.
     @return The number of bytes read.
     */
-    [[nodiscard]] auto read(std::span<std::byte> buffer, kstd::units::bytes offset) const
-        -> kstd::result<kstd::units::bytes> override;
+    [[nodiscard]] auto read(std::span<std::byte> buffer, kstd::bytes offset) const
+        -> kstd::result<kstd::bytes> override;
 
     /**
     @brief Write data to the device inode (and in the background from the associated device) from a @p buffer, starting
@@ -53,8 +53,7 @@ namespace kernel::filesystem
     @param size The number of bytes to write.
     @return The number of bytes written.
     */
-    auto write(std::span<std::byte const> buffer, kstd::units::bytes offset)
-        -> kstd::result<kstd::units::bytes> override;
+    auto write(std::span<std::byte const> buffer, kstd::bytes offset) -> kstd::result<kstd::bytes> override;
 
     /**
     @brief Get the associated device.
diff --git a/kernel/kernel/filesystem/device_inode.tests.cpp b/kernel/kernel/filesystem/device_inode.tests.cpp
index 2a5e54c7..c4b117fb 100644
--- a/kernel/kernel/filesystem/device_inode.tests.cpp
+++ b/kernel/kernel/filesystem/device_inode.tests.cpp
@@ -39,12 +39,12 @@ namespace
 
   struct mock_origin_inode : kernel::filesystem::inode
   {
-    auto read(std::span<std::byte>, kstd::units::bytes) const -> kstd::result<kstd::units::bytes> override
+    auto read(std::span<std::byte>, kstd::bytes) const -> kstd::result<kstd::bytes> override
     {
       return 0_B;
     }
 
-    auto write(std::span<std::byte const>, kstd::units::bytes) -> kstd::result<kstd::units::bytes> override
+    auto write(std::span<std::byte const>, kstd::bytes) -> kstd::result<kstd::bytes> override
     {
       return 0_B;
     }
diff --git a/kernel/kernel/filesystem/device_number_registry.tests.cpp b/kernel/kernel/filesystem/device_number_registry.tests.cpp
index 865a6de9..913acf9a 100644
--- a/kernel/kernel/filesystem/device_number_registry.tests.cpp
+++ b/kernel/kernel/filesystem/device_number_registry.tests.cpp
@@ -23,7 +23,7 @@ using namespace kstd::units_literals;
 namespace
 {
   auto make_bound_block_device(kapi::devices::facet_registry & facets, kstd::string const & name,
-                               kstd::units::bytes block_size, std::optional<std::uint8_t> major)
+                               kstd::bytes block_size, std::optional<std::uint8_t> major)
       -> kstd::shared_ptr<kernel::tests::devices::block_device>
   {
     auto device = kstd::make_shared<kernel::tests::devices::block_device>(name, block_size);
diff --git a/kernel/kernel/filesystem/ext2/filesystem.cpp b/kernel/kernel/filesystem/ext2/filesystem.cpp
index 08f827a6..7a1153e4 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.cpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.cpp
@@ -163,7 +163,7 @@ namespace kernel::filesystem::ext2
           return read_inode(entry->inode);
         }
 
-        bytes_read += kstd::units::bytes{entry->rec_len};
+        bytes_read += kstd::bytes{entry->rec_len};
         entry = reinterpret_cast<linked_directory_entry const *>(buffer.data() + bytes_read);
       }
     }
@@ -273,21 +273,21 @@ namespace kernel::filesystem::ext2
     while (true)
     {
       auto const * entry = reinterpret_cast<linked_directory_entry const *>(buffer.data() + offset);
-      if (offset + kstd::units::bytes{entry->rec_len} >= block_size())
+      if (offset + kstd::bytes{entry->rec_len} >= block_size())
       {
         break;
       }
-      offset += kstd::units::bytes{entry->rec_len};
+      offset += kstd::bytes{entry->rec_len};
     }
 
     auto const file_type = map_inode_mode_to_file_type(mode);
     auto const name_len = static_cast<uint8_t>(name.size());
-    auto const needed_rec_len = static_cast<kstd::units::bytes>((8u + name_len + 3u) & ~3u);
+    auto const needed_rec_len = static_cast<kstd::bytes>((8u + name_len + 3u) & ~3u);
 
     auto * last_entry = reinterpret_cast<linked_directory_entry *>(buffer.data() + offset);
-    auto const last_entry_actual_len = static_cast<kstd::units::bytes>((8u + last_entry->name_len + 3u) & ~3u);
+    auto const last_entry_actual_len = static_cast<kstd::bytes>((8u + last_entry->name_len + 3u) & ~3u);
 
-    if (kstd::units::bytes{last_entry->rec_len} - last_entry_actual_len >= needed_rec_len)
+    if (kstd::bytes{last_entry->rec_len} - last_entry_actual_len >= needed_rec_len)
     {
       last_entry->rec_len = last_entry_actual_len.value;
       write_directory_entry_to_buffer(buffer.data(), offset + last_entry_actual_len, child_inode_number, name,
@@ -339,7 +339,7 @@ namespace kernel::filesystem::ext2
 
     kstd::vector<uint8_t> buffer(block_size().value, 0);
     write_directory_entry_to_buffer(buffer.data(), 0_B, new_inode->number(), ".", 2);
-    auto const dot_actual_len = static_cast<kstd::units::bytes>((8u + 1 + 3u) & ~3u);
+    auto const dot_actual_len = static_cast<kstd::bytes>((8u + 1 + 3u) & ~3u);
     auto * entry = reinterpret_cast<linked_directory_entry *>(buffer.data());
     entry->rec_len = dot_actual_len.value;
 
@@ -355,7 +355,7 @@ namespace kernel::filesystem::ext2
         .transform([](auto) {});
   }
 
-  auto filesystem::write_directory_entry_to_buffer(uint8_t * block_buffer, kstd::units::bytes offset,
+  auto filesystem::write_directory_entry_to_buffer(uint8_t * block_buffer, kstd::bytes offset,
                                                    uint32_t child_inode_number, std::string_view name,
                                                    uint8_t file_type) -> void
   {
@@ -402,7 +402,7 @@ namespace kernel::filesystem::ext2
     }
   }
 
-  auto filesystem::calculate_inode_offset(uint32_t inode_number) const -> kstd::result<kstd::units::bytes>
+  auto filesystem::calculate_inode_offset(uint32_t inode_number) const -> kstd::result<kstd::bytes>
   {
     auto const inodes_per_group = m_superblock.inodes_per_group;
     auto const block_group_index = (inode_number - 1) / inodes_per_group;
@@ -699,13 +699,13 @@ namespace kernel::filesystem::ext2
     return kstd::success();
   }
 
-  auto filesystem::read_block(uint32_t block_number, void * buffer) const -> kstd::result<kstd::units::bytes>
+  auto filesystem::read_block(uint32_t block_number, void * buffer) const -> kstd::result<kstd::bytes>
   {
     auto const block_offset = static_cast<size_t>(block_number) * block_size();
     return m_backing_inode->read(std::span{static_cast<std::byte *>(buffer), block_size().value}, block_offset);
   }
 
-  auto filesystem::write_block(uint32_t block_number, void const * buffer) -> kstd::result<kstd::units::bytes>
+  auto filesystem::write_block(uint32_t block_number, void const * buffer) -> kstd::result<kstd::bytes>
   {
     auto const block_offset = static_cast<size_t>(block_number) * block_size();
     return m_backing_inode->write(std::span{static_cast<std::byte const *>(buffer), block_size().value}, block_offset);
@@ -784,9 +784,9 @@ namespace kernel::filesystem::ext2
     return block_numbers_per_doubly_indirect_block() * block_numbers_per_block();
   }
 
-  auto filesystem::block_size() const -> kstd::units::bytes
+  auto filesystem::block_size() const -> kstd::bytes
   {
-    return kstd::units::bytes{constants::base_block_size.value << m_superblock.log_block_size};
+    return kstd::bytes{constants::base_block_size.value << m_superblock.log_block_size};
   }
 
   auto filesystem::revision_level() const -> uint32_t
@@ -794,9 +794,9 @@ namespace kernel::filesystem::ext2
     return m_superblock.rev_level;
   }
 
-  auto filesystem::inode_size() const -> kstd::units::bytes
+  auto filesystem::inode_size() const -> kstd::bytes
   {
-    return kstd::units::bytes(revision_level() == constants::good_old_revision ? 128 : m_superblock.inode_size);
+    return kstd::bytes(revision_level() == constants::good_old_revision ? 128 : m_superblock.inode_size);
   }
 
   auto filesystem::inode_block_count(inode_data const & data) const -> uint32_t
@@ -809,7 +809,7 @@ namespace kernel::filesystem::ext2
     data.blocks += delta * (2 << m_superblock.log_block_size);
   }
 
-  auto filesystem::block_group_descriptor_table_offset() const -> kstd::units::bytes
+  auto filesystem::block_group_descriptor_table_offset() const -> kstd::bytes
   {
     return block_size() == 1024_B ? 2 * block_size() : block_size();
   }
diff --git a/kernel/kernel/filesystem/ext2/filesystem.hpp b/kernel/kernel/filesystem/ext2/filesystem.hpp
index b8794a14..d7132f39 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.hpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.hpp
@@ -29,8 +29,8 @@ namespace kernel::filesystem::ext2
   */
   namespace constants
   {
-    constexpr kstd::units::bytes inline base_block_size = kstd::units::bytes{1024};
-    constexpr kstd::units::bytes inline superblock_offset = base_block_size;
+    constexpr kstd::bytes inline base_block_size = kstd::bytes{1024};
+    constexpr kstd::bytes inline superblock_offset = base_block_size;
     constexpr uint16_t inline magic_number = 0xEF53;
 
     constexpr uint32_t inline good_old_revision = 0;
@@ -89,7 +89,7 @@ namespace kernel::filesystem::ext2
     @brief Gets the size of a block in the filesystem.
     @return The size of a block in bytes.
     */
-    [[nodiscard]] auto block_size() const -> kstd::units::bytes;
+    [[nodiscard]] auto block_size() const -> kstd::bytes;
 
     /**
     @brief Gets the revision level of the filesystem.
@@ -103,7 +103,7 @@ namespace kernel::filesystem::ext2
     @param buffer The buffer to read the block data into.
     @return The number of bytes read.
     */
-    auto read_block(uint32_t block_number, void * buffer) const -> kstd::result<kstd::units::bytes>;
+    auto read_block(uint32_t block_number, void * buffer) const -> kstd::result<kstd::bytes>;
 
     /**
     @brief Writes a block of data from the provided buffer to the backing device.
@@ -111,7 +111,7 @@ namespace kernel::filesystem::ext2
     @param buffer The buffer containing the data to write.
     @return The number of bytes written.
     */
-    auto write_block(uint32_t block_number, void const * buffer) -> kstd::result<kstd::units::bytes>;
+    auto write_block(uint32_t block_number, void const * buffer) -> kstd::result<kstd::bytes>;
 
     /**
     @brief Allocates a specified number of blocks.
@@ -124,7 +124,7 @@ namespace kernel::filesystem::ext2
     @brief Gets the size of an inode in the filesystem.
     @return The size of an inode in bytes.
     */
-    [[nodiscard]] auto inode_size() const -> kstd::units::bytes;
+    [[nodiscard]] auto inode_size() const -> kstd::bytes;
 
     /**
     @brief Gets the number of blocks allocated to an inode.
@@ -179,14 +179,14 @@ namespace kernel::filesystem::ext2
         -> kstd::result<void>;
     auto init_directory(kstd::shared_ptr<kernel::filesystem::ext2::inode> const & new_inode,
                         kernel::filesystem::ext2::inode * parent_inode) -> kstd::result<void>;
-    auto write_directory_entry_to_buffer(uint8_t * block_buffer, kstd::units::bytes offset, uint32_t child_inode_number,
+    auto write_directory_entry_to_buffer(uint8_t * block_buffer, kstd::bytes offset, uint32_t child_inode_number,
                                          std::string_view name, uint8_t file_type) -> void;
 
-    [[nodiscard]] auto calculate_inode_offset(uint32_t inode_number) const -> kstd::result<kstd::units::bytes>;
+    [[nodiscard]] auto calculate_inode_offset(uint32_t inode_number) const -> kstd::result<kstd::bytes>;
     [[nodiscard]] auto read_inode(uint32_t inode_number) const -> kstd::result<kstd::shared_ptr<inode>>;
     [[nodiscard]] auto read_block_number_at_index(uint32_t block_number, size_t index) const -> kstd::result<uint32_t>;
 
-    [[nodiscard]] auto block_group_descriptor_table_offset() const -> kstd::units::bytes;
+    [[nodiscard]] auto block_group_descriptor_table_offset() const -> kstd::bytes;
 
     [[nodiscard]] auto block_numbers_per_block() const -> size_t;
     [[nodiscard]] auto block_numbers_per_singly_indirect_block() const -> size_t;
diff --git a/kernel/kernel/filesystem/ext2/filesystem.tests.cpp b/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
index 6bd17188..f6ade274 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
@@ -150,11 +150,11 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
           std::vector{std::byte{'H'}, std::byte{'e'}, std::byte{'l'}, std::byte{'l'}, std::byte{'o'}, std::byte{' '},
                       std::byte{'W'}, std::byte{'o'}, std::byte{'r'}, std::byte{'l'}, std::byte{'d'}, std::byte{'!'}};
       auto bytes_written = new_inode.value()->write(buffer, 0_B);
-      REQUIRE(bytes_written == kstd::units::bytes{buffer.size()});
+      REQUIRE(bytes_written == kstd::bytes{buffer.size()});
 
       auto read_buffer = std::vector<std::byte>(5, std::byte{0xAA});
       auto bytes_read = new_inode.value()->read(read_buffer, 0_B);
-      REQUIRE(bytes_read == kstd::units::bytes{read_buffer.size()});
+      REQUIRE(bytes_read == kstd::bytes{read_buffer.size()});
 
       std::string_view result{reinterpret_cast<char *>(read_buffer.data()), static_cast<size_t>(*bytes_read)};
       REQUIRE(result == "Hello");
@@ -276,7 +276,7 @@ SCENARIO("Ext2 block writing includes direct and all indirect levels", "[filesys
     auto fs = kernel::filesystem::ext2::filesystem{};
     REQUIRE(fs.mount(dev_inode));
 
-    auto read_u32 = [&](kstd::units::bytes offset) -> uint32_t {
+    auto read_u32 = [&](kstd::bytes offset) -> uint32_t {
       auto value = uint32_t{0};
       std::memcpy(&value, device->data.data() + offset, sizeof(value));
       return value;
@@ -301,12 +301,12 @@ SCENARIO("Ext2 block writing includes direct and all indirect levels", "[filesys
 
       REQUIRE(fs.write_global_block_number_to_inode_block_index(singly_start, inode_data, singly_global_block_number));
       REQUIRE(inode_data.block[12] == 16);
-      REQUIRE(read_u32(static_cast<kstd::units::bytes>(inode_data.block[12]) * block_size.value) ==
+      REQUIRE(read_u32(static_cast<kstd::bytes>(inode_data.block[12]) * block_size.value) ==
               singly_global_block_number);
 
       REQUIRE(fs.write_global_block_number_to_inode_block_index(singly_start + 1, inode_data,
                                                                 singly_global_block_number + 1));
-      REQUIRE(read_u32(static_cast<kstd::units::bytes>(inode_data.block[12]) * block_size.value +
+      REQUIRE(read_u32(static_cast<kstd::bytes>(inode_data.block[12]) * block_size.value +
                        1 * kstd::size_of<uint32_t>()) == singly_global_block_number + 1);
 
       REQUIRE(fs.write_global_block_number_to_inode_block_index(doubly_start, inode_data, doubly_global_block_number));
diff --git a/kernel/kernel/filesystem/ext2/inode.cpp b/kernel/kernel/filesystem/ext2/inode.cpp
index cba0e70c..5f161e82 100644
--- a/kernel/kernel/filesystem/ext2/inode.cpp
+++ b/kernel/kernel/filesystem/ext2/inode.cpp
@@ -31,12 +31,12 @@ namespace kernel::filesystem::ext2
     }
   }
 
-  auto inode::read(std::span<std::byte> buffer, kstd::units::bytes offset) const -> kstd::result<kstd::units::bytes>
+  auto inode::read(std::span<std::byte> buffer, kstd::bytes offset) const -> kstd::result<kstd::bytes>
   {
     auto const max_readable = this->size() - offset;
-    auto const requested_size = std::min(kstd::units::bytes{buffer.size()}, max_readable);
+    auto const requested_size = std::min(kstd::bytes{buffer.size()}, max_readable);
 
-    if (is_symbolic_link() && this->size() <= kstd::units::bytes{sizeof(m_data.block)})
+    if (is_symbolic_link() && this->size() <= kstd::bytes{sizeof(m_data.block)})
     {
       auto inline_target = reinterpret_cast<uint8_t const *>(m_data.block.data());
       kstd::libc::memcpy(buffer.data(), inline_target + offset, requested_size.value);
@@ -83,7 +83,7 @@ namespace kernel::filesystem::ext2
     return bytes_read;
   }
 
-  auto inode::write(std::span<std::byte const> buffer, kstd::units::bytes offset) -> kstd::result<kstd::units::bytes>
+  auto inode::write(std::span<std::byte const> buffer, kstd::bytes offset) -> kstd::result<kstd::bytes>
   {
     if (!is_regular())
     {
@@ -93,7 +93,7 @@ namespace kernel::filesystem::ext2
     // TODO check maximum file size of filesystem
     // TODO handle sparse files
 
-    auto const new_inode_size = std::max(this->size(), offset + kstd::units::bytes{buffer.size()});
+    auto const new_inode_size = std::max(this->size(), offset + kstd::bytes{buffer.size()});
 
     auto const current_block_count = m_filesystem->inode_block_count(m_data);
     auto const max_new_inode_size_without_new_blocks = current_block_count * m_filesystem->block_size();
@@ -116,7 +116,7 @@ namespace kernel::filesystem::ext2
 
     auto bytes_written = 0_B;
 
-    while (bytes_written < kstd::units::bytes{buffer.size()})
+    while (bytes_written < kstd::bytes{buffer.size()})
     {
       auto const block_number = m_filesystem->map_inode_block_index_to_global_block_number(block_index, m_data);
       // TODO BA-FS26 if blocknumber == 0 --> handle sparse file
@@ -126,7 +126,7 @@ namespace kernel::filesystem::ext2
       }
 
       auto const bytes_to_write =
-          std::min(kstd::units::bytes{buffer.size()} - bytes_written, m_filesystem->block_size() - in_block_offset);
+          std::min(kstd::bytes{buffer.size()} - bytes_written, m_filesystem->block_size() - in_block_offset);
 
       auto const block_start_offset = block_number.value() * m_filesystem->block_size();
       auto const write_offset = block_start_offset + in_block_offset;
@@ -244,7 +244,7 @@ namespace kernel::filesystem::ext2
     };
   }
 
-  auto inode::size() const -> kstd::units::bytes
+  auto inode::size() const -> kstd::bytes
   {
     uint64_t size = m_data.size;
 
@@ -253,10 +253,10 @@ namespace kernel::filesystem::ext2
       size |= static_cast<uint64_t>(m_data.dir_acl) << 32;
     }
 
-    return kstd::units::bytes{size};
+    return kstd::bytes{size};
   }
 
-  auto inode::set_size(kstd::units::bytes new_size) -> void
+  auto inode::set_size(kstd::bytes new_size) -> void
   {
     if (m_filesystem->revision_level() > constants::good_old_revision && is_regular())
     {
diff --git a/kernel/kernel/filesystem/ext2/inode.hpp b/kernel/kernel/filesystem/ext2/inode.hpp
index 9d145dfc..7937c643 100644
--- a/kernel/kernel/filesystem/ext2/inode.hpp
+++ b/kernel/kernel/filesystem/ext2/inode.hpp
@@ -61,8 +61,8 @@ namespace kernel::filesystem::ext2
     @param size Number of bytes requested.
     @return Number of bytes read.
     */
-    [[nodiscard]] auto read(std::span<std::byte> buffer, kstd::units::bytes offset) const
-        -> kstd::result<kstd::units::bytes> override;
+    [[nodiscard]] auto read(std::span<std::byte> buffer, kstd::bytes offset) const
+        -> kstd::result<kstd::bytes> override;
 
     /**
     @brief Writes to the ext2 inode into a @p buffer, starting at the specified @p offset and for a given @p size.
@@ -71,8 +71,7 @@ namespace kernel::filesystem::ext2
     @param size Number of bytes requested.
     @return Number of bytes written.
     */
-    auto write(std::span<std::byte const> buffer, kstd::units::bytes offset)
-        -> kstd::result<kstd::units::bytes> override;
+    auto write(std::span<std::byte const> buffer, kstd::bytes offset) -> kstd::result<kstd::bytes> override;
 
     /**
     @brief Appends the specified number of blocks to the inode.
@@ -123,13 +122,13 @@ namespace kernel::filesystem::ext2
     @brief Get the size of the file represented by this inode.
     @return The size of the file in bytes.
      */
-    [[nodiscard]] auto size() const -> kstd::units::bytes;
+    [[nodiscard]] auto size() const -> kstd::bytes;
 
     /**
     @brief Set the size of the file represented by this inode.
     @param new_size The new size of the file in bytes.
      */
-    auto set_size(kstd::units::bytes new_size) -> void;
+    auto set_size(kstd::bytes new_size) -> void;
 
     /**
     @brief Get the inode number of this inode.
diff --git a/kernel/kernel/filesystem/ext2/inode.tests.cpp b/kernel/kernel/filesystem/ext2/inode.tests.cpp
index 78695b51..13e9d414 100644
--- a/kernel/kernel/filesystem/ext2/inode.tests.cpp
+++ b/kernel/kernel/filesystem/ext2/inode.tests.cpp
@@ -169,7 +169,7 @@ SCENARIO("Ext2 inode handles zeros in block mappings as file holes", "[filesyste
     THEN("correct number of bytes are read and holes are returned as zeros")
     {
       auto const bytes_read = inode.read(buffer, 0_B);
-      REQUIRE(bytes_read == kstd::units::bytes{data.size});
+      REQUIRE(bytes_read == kstd::bytes{data.size});
 
       auto const text = std::string_view{reinterpret_cast<char const *>(buffer.data()), bytes_read->value};
       REQUIRE(text.substr(0, 5) == "Hello");
@@ -211,7 +211,7 @@ SCENARIO("Ext2 inode handles zeros in block mappings as file holes", "[filesyste
     THEN("correct number of bytes are read and holes are returned as zeros")
     {
       auto const bytes_read = inode.read(buffer, 0_B);
-      REQUIRE(bytes_read == kstd::units::bytes{data.size});
+      REQUIRE(bytes_read == kstd::bytes{data.size});
 
       auto const text = std::string_view{reinterpret_cast<char const *>(buffer.data()), bytes_read->value};
       REQUIRE(text.substr(0, 5) == "Hello");
@@ -247,7 +247,7 @@ SCENARIO("Ext2 inode handles zeros in block mappings as file holes", "[filesyste
     THEN("all direct blocks are zero when singly indirect block pointer is zero")
     {
       auto const bytes_read = inode.read(buffer, 0_B);
-      REQUIRE(bytes_read == kstd::units::bytes{buffer.size()});
+      REQUIRE(bytes_read == kstd::bytes{buffer.size()});
       REQUIRE(std::ranges::all_of(buffer, [](std::byte c) { return c == std::byte{0x00}; }));
     }
   }
@@ -280,7 +280,7 @@ SCENARIO("Ext2 inode read across block boundaries", "[filesystem][ext2][inode]")
     THEN("reading across the block boundary returns the combined content")
     {
       auto const bytes_read = inode.read(buffer, block_size - 6_B);
-      REQUIRE(bytes_read == kstd::units::bytes{12});
+      REQUIRE(bytes_read == kstd::bytes{12});
 
       auto const text = std::string_view{reinterpret_cast<char const *>(buffer.data()), bytes_read->value};
       REQUIRE(text == "Hello World!");
@@ -318,11 +318,11 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture, "Ext2 in
                                                   std::byte{'r'}, std::byte{'l'}, std::byte{'d'}, std::byte{'!'}};
 
       auto const bytes_written = file.value()->write(write_buffer, 0_B);
-      REQUIRE(bytes_written == kstd::units::bytes{12});
+      REQUIRE(bytes_written == kstd::bytes{12});
 
       auto read_buffer = kstd::vector<std::byte>(42, std::byte{0x00});
       auto const bytes_read = file.value()->read(read_buffer, 0_B);
-      REQUIRE(bytes_read == kstd::units::bytes{12});
+      REQUIRE(bytes_read == kstd::bytes{12});
 
       auto const text = std::string_view{reinterpret_cast<char const *>(read_buffer.data()), bytes_read->value};
       REQUIRE(text == "Hello World!");
@@ -450,7 +450,7 @@ SCENARIO("Ext2 inode write across block boundaries", "[filesystem][ext2][inode]"
     {
       auto const offset = block_size - 4_B;
       auto const bytes_written = inode.write(buffer, offset);
-      REQUIRE(bytes_written == kstd::units::bytes{buffer.size()});
+      REQUIRE(bytes_written == kstd::bytes{buffer.size()});
 
       auto const text = std::string_view{
         reinterpret_cast<char const *>(device->data.data() + 21 * block_size.value - 4), bytes_written->value};
@@ -461,7 +461,7 @@ SCENARIO("Ext2 inode write across block boundaries", "[filesystem][ext2][inode]"
       REQUIRE(block_bitmap == read_block_bitmap);
 
       auto read_inode = do_read_inode();
-      REQUIRE(offset + kstd::units::bytes{buffer.size()} == read_inode.size());
+      REQUIRE(offset + kstd::bytes{buffer.size()} == read_inode.size());
       REQUIRE(inode_data.blocks == read_inode.data().blocks);
 
       auto const current_blocks = inode_data.block;
@@ -473,7 +473,7 @@ SCENARIO("Ext2 inode write across block boundaries", "[filesystem][ext2][inode]"
     {
       auto const offset = block_size * 2 - 4_B;
       auto const bytes_written = inode.write(buffer, offset);
-      REQUIRE(bytes_written == kstd::units::bytes{buffer.size()});
+      REQUIRE(bytes_written == kstd::bytes{buffer.size()});
 
       auto read_buffer = std::vector<std::byte>(buffer.size(), std::byte{0x00});
       auto const bytes_read = inode.read(read_buffer, offset);
@@ -488,7 +488,7 @@ SCENARIO("Ext2 inode write across block boundaries", "[filesystem][ext2][inode]"
       REQUIRE(expected_block_bitmap == read_block_bitmap);
 
       auto read_inode = do_read_inode();
-      REQUIRE(offset + kstd::units::bytes{buffer.size()} == read_inode.size());
+      REQUIRE(offset + kstd::bytes{buffer.size()} == read_inode.size());
       REQUIRE(inode_data.blocks + 2 == read_inode.data().blocks);
 
       auto expected_blocks = inode_data.block;
@@ -535,7 +535,7 @@ SCENARIO("Ext2 inode get_size() and set_size() handles size correctly depending
     data.size = 256;
     data.dir_acl = 32;
 
-    auto const verify_size_and_set_size = [&](uint16_t mode, kstd::units::bytes expected_initial_size,
+    auto const verify_size_and_set_size = [&](uint16_t mode, kstd::bytes expected_initial_size,
                                               uint32_t expected_dir_acl_after_set_size) {
       data.mode = mode;
 
@@ -578,7 +578,7 @@ SCENARIO("Ext2 inode get_size() and set_size() handles size correctly depending
     data.size = 256;
     data.dir_acl = 32;
 
-    auto const verify_size_and_set_size = [&](uint16_t mode, kstd::units::bytes expected_initial_size,
+    auto const verify_size_and_set_size = [&](uint16_t mode, kstd::bytes expected_initial_size,
                                               uint32_t expected_dir_acl_after_set_size) {
       data.mode = mode;
 
diff --git a/kernel/kernel/filesystem/inode.hpp b/kernel/kernel/filesystem/inode.hpp
index 7ebac995..f0fbf689 100644
--- a/kernel/kernel/filesystem/inode.hpp
+++ b/kernel/kernel/filesystem/inode.hpp
@@ -27,8 +27,8 @@ namespace kernel::filesystem
     //! @param offset Read offset in bytes.
     //! @param size Number of bytes requested.
     //! @return The number of bytes read on success, an error otherwise.
-    [[nodiscard]] virtual auto read(std::span<std::byte> buffer, kstd::units::bytes offset) const
-        -> kstd::result<kstd::units::bytes> = 0;
+    [[nodiscard]] virtual auto read(std::span<std::byte> buffer, kstd::bytes offset) const
+        -> kstd::result<kstd::bytes> = 0;
 
     //! Writes data from a buffer into this inode.
     //!
@@ -36,8 +36,7 @@ namespace kernel::filesystem
     //! @param offset Write offset in bytes.
     //! @param size Number of bytes to write.
     //! @return The number of bytes written on success, an error otherwise.
-    virtual auto write(std::span<std::byte const> buffer, kstd::units::bytes offset)
-        -> kstd::result<kstd::units::bytes> = 0;
+    virtual auto write(std::span<std::byte const> buffer, kstd::bytes offset) -> kstd::result<kstd::bytes> = 0;
 
     //! Check if this inode is a directory.
     //!
diff --git a/kernel/kernel/filesystem/open_file_descriptor.cpp b/kernel/kernel/filesystem/open_file_descriptor.cpp
index 379b0708..a6d97b8e 100644
--- a/kernel/kernel/filesystem/open_file_descriptor.cpp
+++ b/kernel/kernel/filesystem/open_file_descriptor.cpp
@@ -25,7 +25,7 @@ namespace kernel::filesystem
     }
   }
 
-  auto open_file_descriptor::read(std::span<std::byte> buffer) -> kstd::result<kstd::units::bytes>
+  auto open_file_descriptor::read(std::span<std::byte> buffer) -> kstd::result<kstd::bytes>
   {
     if (auto result = m_dentry->get_inode()->read(buffer, m_offset); !result)
     {
@@ -39,7 +39,7 @@ namespace kernel::filesystem
     }
   }
 
-  auto open_file_descriptor::write(std::span<std::byte const> buffer) -> kstd::result<kstd::units::bytes>
+  auto open_file_descriptor::write(std::span<std::byte const> buffer) -> kstd::result<kstd::bytes>
   {
     if (auto result = m_dentry->get_inode()->write(buffer, m_offset); !result)
     {
@@ -53,8 +53,8 @@ namespace kernel::filesystem
     }
   }
 
-  auto open_file_descriptor::seek(kstd::units::bytes offset, kapi::filesystem::seek_direction direction,
-                                  kapi::filesystem::seek_origin origin) -> kstd::result<kstd::units::bytes>
+  auto open_file_descriptor::seek(kstd::bytes offset, kapi::filesystem::seek_direction direction,
+                                  kapi::filesystem::seek_origin origin) -> kstd::result<kstd::bytes>
   {
     switch (origin)
     {
@@ -96,7 +96,7 @@ namespace kernel::filesystem
     return kstd::failure(vfs_errc::invalid_argument);
   }
 
-  auto open_file_descriptor::offset() const -> kstd::units::bytes
+  auto open_file_descriptor::offset() const -> kstd::bytes
   {
     return m_offset;
   }
diff --git a/kernel/kernel/filesystem/open_file_descriptor.hpp b/kernel/kernel/filesystem/open_file_descriptor.hpp
index f0b55d72..25dbf719 100644
--- a/kernel/kernel/filesystem/open_file_descriptor.hpp
+++ b/kernel/kernel/filesystem/open_file_descriptor.hpp
@@ -38,7 +38,7 @@ namespace kernel::filesystem
     @param buffer The buffer to read data into.
     @return The number of bytes read.
     */
-    auto read(std::span<std::byte> buffer) -> kstd::result<kstd::units::bytes>;
+    auto read(std::span<std::byte> buffer) -> kstd::result<kstd::bytes>;
 
     /**
     @brief Writes data to the open file descriptor from a @p buffer, starting at the current file offset and for a
@@ -47,7 +47,7 @@ namespace kernel::filesystem
     @param buffer The buffer to write data from.
     @return The number of bytes written.
     */
-    auto write(std::span<std::byte const> buffer) -> kstd::result<kstd::units::bytes>;
+    auto write(std::span<std::byte const> buffer) -> kstd::result<kstd::bytes>;
 
     //! Move the read/write offset of the file.
     //!
@@ -55,14 +55,14 @@ namespace kernel::filesystem
     //! @param offset The direction to seek in, relative to the given origin.
     //! @param origin The origin of the offset.
     //! @return the new offset on success, an error otherwise.
-    auto seek(kstd::units::bytes offset, kapi::filesystem::seek_direction direction,
-              kapi::filesystem::seek_origin origin) -> kstd::result<kstd::units::bytes>;
+    auto seek(kstd::bytes offset, kapi::filesystem::seek_direction direction, kapi::filesystem::seek_origin origin)
+        -> kstd::result<kstd::bytes>;
 
     /**
     @brief Returns the current file offset for this open file descriptor.
     @return The current file offset in bytes.
      */
-    [[nodiscard]] auto offset() const -> kstd::units::bytes;
+    [[nodiscard]] auto offset() const -> kstd::bytes;
 
     /**
     @brief Return a reference to the dentry associated with this open file descriptor.
@@ -72,7 +72,7 @@ namespace kernel::filesystem
 
   private:
     kstd::shared_ptr<dentry> m_dentry;
-    kstd::units::bytes m_offset;
+    kstd::bytes m_offset;
   };
 
 }  // namespace kernel::filesystem
diff --git a/kernel/kernel/filesystem/open_file_descriptor.tests.cpp b/kernel/kernel/filesystem/open_file_descriptor.tests.cpp
index ec86e8d3..a2e30c16 100644
--- a/kernel/kernel/filesystem/open_file_descriptor.tests.cpp
+++ b/kernel/kernel/filesystem/open_file_descriptor.tests.cpp
@@ -118,12 +118,12 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "Ope
     {
       kstd::vector<std::byte> buffer(4);
       auto bytes_read_1 = ofd->read(std::span{buffer}.first(buffer.size() / 2));
-      REQUIRE(bytes_read_1 == kstd::units::bytes{buffer.size() / 2});
-      REQUIRE(ofd->offset() == kstd::units::bytes{buffer.size() / 2});
+      REQUIRE(bytes_read_1 == kstd::bytes{buffer.size() / 2});
+      REQUIRE(ofd->offset() == kstd::bytes{buffer.size() / 2});
 
       auto bytes_read_2 = ofd->read(std::span{buffer}.last(buffer.size() / 2));
-      REQUIRE(bytes_read_2 == kstd::units::bytes{buffer.size() / 2});
-      REQUIRE(ofd->offset() == kstd::units::bytes{buffer.size()});
+      REQUIRE(bytes_read_2 == kstd::bytes{buffer.size() / 2});
+      REQUIRE(ofd->offset() == kstd::bytes{buffer.size()});
 
       std::string_view buffer_as_str{reinterpret_cast<char *>(buffer.data()),
                                      bytes_read_1->value + bytes_read_2->value};
@@ -142,12 +142,12 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "Ope
     {
       auto write_buffer = kstd::vector<std::byte>(8, std::byte{0xAA});
       auto const bytes_written_1 = ofd->write(std::span{write_buffer}.first(write_buffer.size() / 2));
-      REQUIRE(bytes_written_1 == kstd::units::bytes{write_buffer.size() / 2});
-      REQUIRE(ofd->offset() == kstd::units::bytes{write_buffer.size() / 2});
+      REQUIRE(bytes_written_1 == kstd::bytes{write_buffer.size() / 2});
+      REQUIRE(ofd->offset() == kstd::bytes{write_buffer.size() / 2});
 
       auto const bytes_written_2 = ofd->write(std::span{write_buffer}.last(write_buffer.size() / 2));
-      REQUIRE(bytes_written_2 == kstd::units::bytes{write_buffer.size() / 2});
-      REQUIRE(ofd->offset() == kstd::units::bytes{write_buffer.size()});
+      REQUIRE(bytes_written_2 == kstd::bytes{write_buffer.size() / 2});
+      REQUIRE(ofd->offset() == kstd::bytes{write_buffer.size()});
     }
   }
 }
diff --git a/kernel/kernel/filesystem/rootfs/inode.cpp b/kernel/kernel/filesystem/rootfs/inode.cpp
index 07607417..0ee0b517 100644
--- a/kernel/kernel/filesystem/rootfs/inode.cpp
+++ b/kernel/kernel/filesystem/rootfs/inode.cpp
@@ -10,14 +10,14 @@
 
 namespace kernel::filesystem::rootfs
 {
-  auto inode::read(std::span<std::byte>, kstd::units::bytes) const -> kstd::result<kstd::units::bytes>
+  auto inode::read(std::span<std::byte>, kstd::bytes) const -> kstd::result<kstd::bytes>
   {
-    return kstd::units::bytes{};
+    return kstd::bytes{};
   }
 
-  auto inode::write(std::span<std::byte const>, kstd::units::bytes) -> kstd::result<kstd::units::bytes>
+  auto inode::write(std::span<std::byte const>, kstd::bytes) -> kstd::result<kstd::bytes>
   {
-    return kstd::units::bytes{};
+    return kstd::bytes{};
   }
 
   auto inode::is_directory() const -> bool
diff --git a/kernel/kernel/filesystem/rootfs/inode.hpp b/kernel/kernel/filesystem/rootfs/inode.hpp
index e9c6e738..82df2f1a 100644
--- a/kernel/kernel/filesystem/rootfs/inode.hpp
+++ b/kernel/kernel/filesystem/rootfs/inode.hpp
@@ -25,8 +25,8 @@ namespace kernel::filesystem::rootfs
     @param offset Read offset in bytes.
     @return Number of bytes read (always 0 because this inode does not expose file data).
     */
-    [[nodiscard]] auto read(std::span<std::byte> buffer, kstd::units::bytes offset) const
-        -> kstd::result<kstd::units::bytes> override;
+    [[nodiscard]] auto read(std::span<std::byte> buffer, kstd::bytes offset) const
+        -> kstd::result<kstd::bytes> override;
 
     /**
     @brief Writes to the rootfs directory inode.
@@ -34,8 +34,7 @@ namespace kernel::filesystem::rootfs
     @param offset Write offset in bytes.
     @return Number of bytes written (always 0 because writes are not supported for this inode).
     */
-    auto write(std::span<std::byte const> buffer, kstd::units::bytes offset)
-        -> kstd::result<kstd::units::bytes> override;
+    auto write(std::span<std::byte const> buffer, kstd::bytes offset) -> kstd::result<kstd::bytes> override;
 
     /**
     @brief Check if this inode represents a directory.
diff --git a/kernel/kernel/filesystem/vfs.tests.cpp b/kernel/kernel/filesystem/vfs.tests.cpp
index 8693b9f5..a035e083 100644
--- a/kernel/kernel/filesystem/vfs.tests.cpp
+++ b/kernel/kernel/filesystem/vfs.tests.cpp
@@ -666,11 +666,11 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_vfs_fixture, "VFS
 
         auto marker = kstd::vector{std::byte{'M'}, std::byte{'K'}, std::byte{'N'}, std::byte{'O'}, std::byte{'D'}};
         auto written = (*via_persistent_fs)->get_inode()->write(marker, 0_B);
-        REQUIRE(written == kstd::units::bytes{marker.size()});
+        REQUIRE(written == kstd::bytes{marker.size()});
 
         auto read_back = kstd::vector<std::byte>(marker.size());
         auto read = (*via_devfs)->get_inode()->read(read_back, 0_B);
-        REQUIRE(read == kstd::units::bytes{marker.size()});
+        REQUIRE(read == kstd::bytes{marker.size()});
 
         REQUIRE(read_back == marker);
       }
diff --git a/kernel/kernel/memory.cpp b/kernel/kernel/memory.cpp
index 663137eb..b65a89db 100644
--- a/kernel/kernel/memory.cpp
+++ b/kernel/kernel/memory.cpp
@@ -21,7 +21,7 @@ namespace kernel::memory
     {
       null_allocator static instance;
 
-      [[nodiscard]] auto allocate(kstd::units::bytes, kstd::units::bytes) noexcept -> void * override
+      [[nodiscard]] auto allocate(kstd::bytes, kstd::bytes) noexcept -> void * override
       {
         kstd::print(kstd::print_sink::stderr, "Tried to allocate memory without an active heap!");
         return nullptr;
diff --git a/kernel/kernel/memory/block_list_allocator.cpp b/kernel/kernel/memory/block_list_allocator.cpp
index a682051f..993dd470 100644
--- a/kernel/kernel/memory/block_list_allocator.cpp
+++ b/kernel/kernel/memory/block_list_allocator.cpp
@@ -20,7 +20,7 @@ namespace kernel::memory
 
   namespace
   {
-    [[nodiscard]] constexpr auto align_up(std::byte * pointer, kstd::units::bytes alignment) noexcept -> std::byte *
+    [[nodiscard]] constexpr auto align_up(std::byte * pointer, kstd::bytes alignment) noexcept -> std::byte *
     {
       auto const remainder = std::bit_cast<std::uintptr_t>(pointer) % static_cast<std::size_t>(alignment);
       return remainder == 0 ? pointer : pointer + static_cast<std::size_t>(alignment) - remainder;
@@ -35,7 +35,7 @@ namespace kernel::memory
       , m_lock{}
   {}
 
-  auto block_list_allocator::allocate(kstd::units::bytes size, kstd::units::bytes alignment) noexcept -> void *
+  auto block_list_allocator::allocate(kstd::bytes size, kstd::bytes alignment) noexcept -> void *
   {
     kstd::lock_guard guard{m_lock};
 
@@ -49,13 +49,13 @@ namespace kernel::memory
           auto const raw_block = reinterpret_cast<std::byte *>(current);
           auto const unaligned_payload = raw_block + allocated_metadata_size;
           auto const aligned_payload = align_up(unaligned_payload, alignment);
-          auto const required_padding = static_cast<kstd::units::bytes>(aligned_payload - unaligned_payload);
+          auto const required_padding = static_cast<kstd::bytes>(aligned_payload - unaligned_payload);
           auto const total_required_size = required_padding + allocated_metadata_size + size;
 
           if (current->usable_size >= total_required_size)
           {
             auto const payload_header = aligned_payload - sizeof(block_header *) - sizeof(block_header);
-            auto const front_padding = static_cast<kstd::units::bytes>(payload_header - raw_block);
+            auto const front_padding = static_cast<kstd::bytes>(payload_header - raw_block);
 
             auto payload_block = current;
 
@@ -75,7 +75,7 @@ namespace kernel::memory
             }
 
             auto const header_size =
-                static_cast<kstd::units::bytes>(aligned_payload - reinterpret_cast<std::byte *>(payload_block));
+                static_cast<kstd::bytes>(aligned_payload - reinterpret_cast<std::byte *>(payload_block));
             auto const payload_size = header_size - allocated_metadata_size + size;
             split(payload_block, payload_size, 0_B);
 
@@ -117,7 +117,7 @@ namespace kernel::memory
     coalesce(block);
   }
 
-  auto block_list_allocator::expand(kstd::units::bytes size) noexcept -> bool
+  auto block_list_allocator::expand(kstd::bytes size) noexcept -> bool
   {
     auto const total_required_size = size + allocated_metadata_size;
     auto const frames_needed = (total_required_size + kapi::memory::frame::size - 1_B) / kapi::memory::frame::size;
@@ -190,8 +190,7 @@ namespace kernel::memory
     }
   }
 
-  auto block_list_allocator::split(block_header * block, kstd::units::bytes size, kstd::units::bytes padding) noexcept
-      -> void
+  auto block_list_allocator::split(block_header * block, kstd::bytes size, kstd::bytes padding) noexcept -> void
   {
     auto const new_block_size = size + padding;
 
diff --git a/kernel/kernel/memory/block_list_allocator.hpp b/kernel/kernel/memory/block_list_allocator.hpp
index ac6257c0..55d9e361 100644
--- a/kernel/kernel/memory/block_list_allocator.hpp
+++ b/kernel/kernel/memory/block_list_allocator.hpp
@@ -33,7 +33,7 @@ namespace kernel::memory
     //! @param size The size of the block to allocate
     //! @param alignment The desired alignment of the allocated block
     //! @return A pointer to the beginning of the block on success, @p nullptr otherwise.
-    [[nodiscard]] auto allocate(kstd::units::bytes size, kstd::units::bytes alignment) noexcept -> void * override;
+    [[nodiscard]] auto allocate(kstd::bytes size, kstd::bytes alignment) noexcept -> void * override;
 
     //! Deallocate a block of memory previously allocated.
     //!
@@ -43,7 +43,7 @@ namespace kernel::memory
   private:
     struct block_header final
     {
-      kstd::units::bytes usable_size{};
+      kstd::bytes usable_size{};
       bool free{};
       block_header * next{};
       block_header * prev{};
@@ -53,16 +53,16 @@ namespace kernel::memory
     //!
     //! Each allocated block carries a block header, like any unallocated one, but in addition also has a back-pointer
     //! to the block header to support padding due to alignment.
-    constexpr auto static allocated_metadata_size = kstd::units::bytes{sizeof(block_header) + sizeof(block_header *)};
+    constexpr auto static allocated_metadata_size = kstd::bytes{sizeof(block_header) + sizeof(block_header *)};
 
     //! The minimum number of bytes for an allocation.
-    constexpr auto static minimum_allocation_size = kstd::units::bytes{16uz};
+    constexpr auto static minimum_allocation_size = kstd::bytes{16uz};
 
     //! Try to expand the heap to accommodate the given size.
     //!
     //! @param delta The size to expand the heap by.
     //! @return @p true if the heap was expanded, @p false otherwise.
-    auto expand(kstd::units::bytes delta) noexcept -> bool;
+    auto expand(kstd::bytes delta) noexcept -> bool;
 
     //! Split a given free block to accommodate and allocation.
     //!
@@ -71,7 +71,7 @@ namespace kernel::memory
     //! @param block The block to split.
     //! @param size The size of the allocation.
     //! @param padding The amount of padding to apply.
-    auto split(block_header * block, kstd::units::bytes size, kstd::units::bytes padding) noexcept -> void;
+    auto split(block_header * block, kstd::bytes size, kstd::bytes padding) noexcept -> void;
 
     //! Try to coalesce a given block with it's preceding and/or following block.
     //!
diff --git a/kernel/kernel/memory/heap_allocator.hpp b/kernel/kernel/memory/heap_allocator.hpp
index 59fa98b0..3a5a023b 100644
--- a/kernel/kernel/memory/heap_allocator.hpp
+++ b/kernel/kernel/memory/heap_allocator.hpp
@@ -16,7 +16,7 @@ namespace kernel::memory
     //! @param size The size of the block to allocate
     //! @param alignment The desired alignment of the allocated block
     //! @return A pointer to the beginning of the block on success, @p nullptr otherwise.
-    [[nodiscard]] virtual auto allocate(kstd::units::bytes size, kstd::units::bytes alignment) noexcept -> void * = 0;
+    [[nodiscard]] virtual auto allocate(kstd::bytes size, kstd::bytes alignment) noexcept -> void * = 0;
 
     //! Deallocate a block of memory previously allocated.
     //!
diff --git a/kernel/kernel/memory/operators.cpp b/kernel/kernel/memory/operators.cpp
index 5de5101d..45ba5152 100644
--- a/kernel/kernel/memory/operators.cpp
+++ b/kernel/kernel/memory/operators.cpp
@@ -10,8 +10,8 @@
 [[nodiscard]] auto operator new(std::size_t size, std::align_val_t alignment, std::nothrow_t const &) noexcept -> void *
 {
   auto & allocator = kernel::memory::get_heap_allocator();
-  return allocator.allocate(static_cast<kstd::units::bytes>(size),
-                            static_cast<kstd::units::bytes>(static_cast<std::size_t>(alignment)));
+  return allocator.allocate(static_cast<kstd::bytes>(size),
+                            static_cast<kstd::bytes>(static_cast<std::size_t>(alignment)));
 }
 
 [[nodiscard]] auto operator new(std::size_t size, std::align_val_t alignment) -> void *
diff --git a/kernel/kernel/test_support/devices/block_device.cpp b/kernel/kernel/test_support/devices/block_device.cpp
index 8ac1e23c..c9ab4a5e 100644
--- a/kernel/kernel/test_support/devices/block_device.cpp
+++ b/kernel/kernel/test_support/devices/block_device.cpp
@@ -18,14 +18,14 @@ using namespace kstd::units_literals;
 
 namespace kernel::tests::devices
 {
-  block_device::block_device(kstd::string const & name, kstd::units::bytes block_size, kstd::units::bytes initial_size)
+  block_device::block_device(kstd::string const & name, kstd::bytes block_size, kstd::bytes initial_size)
       : kapi::devices::device{name}
       , m_block_size{block_size}
   {
     data.resize(initial_size.value, 0);
   }
 
-  auto block_device::read_block(size_t block_index, std::span<std::byte> buffer) -> kstd::result<kstd::units::bytes>
+  auto block_device::read_block(size_t block_index, std::span<std::byte> buffer) -> kstd::result<kstd::bytes>
   {
     auto const offset = block_index * block_size();
     if (offset.value >= data.size())
@@ -34,7 +34,7 @@ namespace kernel::tests::devices
       return 0_B;
     }
 
-    auto const bytes_to_read = std::min(block_size(), kstd::units::bytes{data.size()} - offset);
+    auto const bytes_to_read = std::min(block_size(), kstd::bytes{data.size()} - offset);
     kstd::libc::memcpy(buffer.data(), data.data() + offset, bytes_to_read.value);
     if (bytes_to_read < block_size())
     {
@@ -44,8 +44,7 @@ namespace kernel::tests::devices
     return bytes_to_read;
   }
 
-  auto block_device::write_block(size_t block_index, std::span<std::byte const> buffer)
-      -> kstd::result<kstd::units::bytes>
+  auto block_device::write_block(size_t block_index, std::span<std::byte const> buffer) -> kstd::result<kstd::bytes>
   {
     auto const offset = block_index * block_size();
     auto const write_end = offset + block_size();
@@ -58,14 +57,14 @@ namespace kernel::tests::devices
     return block_size();
   }
 
-  auto block_device::block_size() const -> kstd::units::bytes
+  auto block_device::block_size() const -> kstd::bytes
   {
     return m_block_size;
   }
 
-  auto block_device::capacity() const -> kstd::units::bytes
+  auto block_device::capacity() const -> kstd::bytes
   {
-    return kstd::units::bytes{data.size()};
+    return kstd::bytes{data.size()};
   }
 
   auto block_device::query_facet(kapi::capabilities::facet_id facet) -> void *
diff --git a/kernel/kernel/test_support/devices/block_device.hpp b/kernel/kernel/test_support/devices/block_device.hpp
index 11065109..5f00f27e 100644
--- a/kernel/kernel/test_support/devices/block_device.hpp
+++ b/kernel/kernel/test_support/devices/block_device.hpp
@@ -18,21 +18,20 @@ namespace kernel::tests::devices
 
   struct block_device final : kapi::devices::device, kapi::filesystem::block_special_file
   {
-    block_device(kstd::string const & name, kstd::units::bytes block_size, kstd::units::bytes initial_size = {});
+    block_device(kstd::string const & name, kstd::bytes block_size, kstd::bytes initial_size = {});
 
-    auto read_block(size_t block_index, std::span<std::byte> buffer) -> kstd::result<kstd::units::bytes> override;
-    auto write_block(size_t block_index, std::span<std::byte const> buffer)
-        -> kstd::result<kstd::units::bytes> override;
+    auto read_block(size_t block_index, std::span<std::byte> buffer) -> kstd::result<kstd::bytes> override;
+    auto write_block(size_t block_index, std::span<std::byte const> buffer) -> kstd::result<kstd::bytes> override;
 
-    [[nodiscard]] auto block_size() const -> kstd::units::bytes override;
-    [[nodiscard]] auto capacity() const -> kstd::units::bytes override;
+    [[nodiscard]] auto block_size() const -> kstd::bytes override;
+    [[nodiscard]] auto capacity() const -> kstd::bytes override;
 
     kstd::vector<uint8_t> data{};
 
   private:
     [[nodiscard]] auto query_facet(kapi::capabilities::facet_id facet) -> void * override;
 
-    kstd::units::bytes m_block_size{};
+    kstd::bytes m_block_size{};
   };
 
 }  // namespace kernel::tests::devices
diff --git a/kernel/kernel/test_support/filesystem/ext2.cpp b/kernel/kernel/test_support/filesystem/ext2.cpp
index 6ea41bab..96d94ea1 100644
--- a/kernel/kernel/test_support/filesystem/ext2.cpp
+++ b/kernel/kernel/test_support/filesystem/ext2.cpp
@@ -20,11 +20,11 @@ namespace kernel::tests::filesystem::ext2
     constexpr uint32_t root_directory_data_block = 20;
   }  // namespace
 
-  auto write_bytes(kernel::tests::devices::block_device & device, kstd::units::bytes offset, void const * source,
-                   kstd::units::bytes size) -> void
+  auto write_bytes(kernel::tests::devices::block_device & device, kstd::bytes offset, void const * source,
+                   kstd::bytes size) -> void
   {
     auto const required_size = offset + size;
-    if (kstd::units::bytes{device.data.size()} < required_size)
+    if (kstd::bytes{device.data.size()} < required_size)
     {
       device.data.resize(required_size.value, 0);
     }
@@ -32,7 +32,7 @@ namespace kernel::tests::filesystem::ext2
     std::memcpy(device.data.data() + offset, source, size.value);
   }
 
-  auto write_u32(kernel::tests::devices::block_device & device, kstd::units::bytes offset, uint32_t value) -> void
+  auto write_u32(kernel::tests::devices::block_device & device, kstd::bytes offset, uint32_t value) -> void
   {
     write_bytes(device, offset, &value, kstd::size_of(value));
   }
@@ -73,7 +73,7 @@ namespace kernel::tests::filesystem::ext2
 
     auto const root_inode_offset =
         static_cast<size_t>(group_descriptor.inode_table) * kernel::filesystem::ext2::constants::base_block_size +
-        (kernel::filesystem::ext2::constants::root_inode_number - 1) * kstd::units::bytes{superblock.inode_size};
+        (kernel::filesystem::ext2::constants::root_inode_number - 1) * kstd::bytes{superblock.inode_size};
     write_bytes(device, root_inode_offset, &root_inode_data, kstd::size_of(root_inode_data));
   }
 }  // namespace kernel::tests::filesystem::ext2
\ No newline at end of file
diff --git a/kernel/kernel/test_support/filesystem/ext2.hpp b/kernel/kernel/test_support/filesystem/ext2.hpp
index a8f73ab5..a83bdd94 100644
--- a/kernel/kernel/test_support/filesystem/ext2.hpp
+++ b/kernel/kernel/test_support/filesystem/ext2.hpp
@@ -11,9 +11,9 @@
 
 namespace kernel::tests::filesystem::ext2
 {
-  auto write_bytes(kernel::tests::devices::block_device & device, kstd::units::bytes offset, void const * source,
-                   kstd::units::bytes size) -> void;
-  auto write_u32(kernel::tests::devices::block_device & device, kstd::units::bytes offset, uint32_t value) -> void;
+  auto write_bytes(kernel::tests::devices::block_device & device, kstd::bytes offset, void const * source,
+                   kstd::bytes size) -> void;
+  auto write_u32(kernel::tests::devices::block_device & device, kstd::bytes offset, uint32_t value) -> void;
   auto setup_mock_ext2_layout(kernel::tests::devices::block_device & device) -> void;
   auto setup_mock_ext2_layout(kernel::tests::devices::block_device & device,
                               kernel::filesystem::ext2::superblock const & superblock) -> void;
diff --git a/kernel/kernel/test_support/filesystem/inode.cpp b/kernel/kernel/test_support/filesystem/inode.cpp
index 96a30c33..409efe77 100644
--- a/kernel/kernel/test_support/filesystem/inode.cpp
+++ b/kernel/kernel/test_support/filesystem/inode.cpp
@@ -10,14 +10,14 @@
 
 namespace kernel::tests::filesystem
 {
-  auto inode::read(std::span<std::byte> buffer, kstd::units::bytes) const -> kstd::result<kstd::units::bytes>
+  auto inode::read(std::span<std::byte> buffer, kstd::bytes) const -> kstd::result<kstd::bytes>
   {
-    return kstd::units::bytes{buffer.size()};
+    return kstd::bytes{buffer.size()};
   }
 
-  auto inode::write(std::span<std::byte const> buffer, kstd::units::bytes) -> kstd::result<kstd::units::bytes>
+  auto inode::write(std::span<std::byte const> buffer, kstd::bytes) -> kstd::result<kstd::bytes>
   {
-    return kstd::units::bytes{buffer.size()};
+    return kstd::bytes{buffer.size()};
   }
 
   auto inode::is_regular() const -> bool
diff --git a/kernel/kernel/test_support/filesystem/inode.hpp b/kernel/kernel/test_support/filesystem/inode.hpp
index 383ca6f5..51773f15 100644
--- a/kernel/kernel/test_support/filesystem/inode.hpp
+++ b/kernel/kernel/test_support/filesystem/inode.hpp
@@ -13,10 +13,8 @@ namespace kernel::tests::filesystem
 {
   struct inode : kernel::filesystem::inode
   {
-    auto read(std::span<std::byte> buffer, kstd::units::bytes offset) const
-        -> kstd::result<kstd::units::bytes> override;
-    auto write(std::span<std::byte const> buffer, kstd::units::bytes offset)
-        -> kstd::result<kstd::units::bytes> override;
+    auto read(std::span<std::byte> buffer, kstd::bytes offset) const -> kstd::result<kstd::bytes> override;
+    auto write(std::span<std::byte const> buffer, kstd::bytes offset) -> kstd::result<kstd::bytes> override;
 
     [[nodiscard]] auto is_regular() const -> bool override;
   };
diff --git a/kernel/kernel/test_support/kapi/memory.cpp b/kernel/kernel/test_support/kapi/memory.cpp
index 01fc078a..e554145d 100644
--- a/kernel/kernel/test_support/kapi/memory.cpp
+++ b/kernel/kernel/test_support/kapi/memory.cpp
@@ -12,8 +12,8 @@
 namespace
 {
   //! The size of the simulated RAM.
-  constexpr auto physical_size = kstd::units::MiB(32u);
-  constexpr auto virtual_size = kstd::units::GiB(1u);
+  constexpr auto physical_size = kstd::MiB(32u);
+  constexpr auto virtual_size = kstd::GiB(1u);
 
   constexpr auto number_of_frames = physical_size / kapi::memory::frame::size;
 
diff --git a/kernel/kernel/test_support/page_mapper.cpp b/kernel/kernel/test_support/page_mapper.cpp
index b1a6f92b..3a0072b4 100644
--- a/kernel/kernel/test_support/page_mapper.cpp
+++ b/kernel/kernel/test_support/page_mapper.cpp
@@ -11,7 +11,7 @@
 namespace kernel::tests
 {
 
-  page_mapper::page_mapper(kstd::units::bytes physical_size, kstd::units::bytes virtual_size)
+  page_mapper::page_mapper(kstd::bytes physical_size, kstd::bytes virtual_size)
       : memory{physical_size, virtual_size}
   {}
 
diff --git a/kernel/kernel/test_support/page_mapper.hpp b/kernel/kernel/test_support/page_mapper.hpp
index a9985393..ee02217c 100644
--- a/kernel/kernel/test_support/page_mapper.hpp
+++ b/kernel/kernel/test_support/page_mapper.hpp
@@ -20,7 +20,7 @@ namespace kernel::tests
     //!
     //! @param physical_size The size of the physical memory.
     //! @param virtual_size The size of the virtual address space.
-    page_mapper(kstd::units::bytes physical_size, kstd::units::bytes virtual_size);
+    page_mapper(kstd::bytes physical_size, kstd::bytes virtual_size);
 
     //! @copydoc kapi::memory::page_mapper::map
     //!
diff --git a/kernel/kernel/test_support/simulated_memory.cpp b/kernel/kernel/test_support/simulated_memory.cpp
index 07adab17..7614816b 100644
--- a/kernel/kernel/test_support/simulated_memory.cpp
+++ b/kernel/kernel/test_support/simulated_memory.cpp
@@ -17,7 +17,7 @@
 namespace kernel::tests
 {
 
-  simulated_memory::simulated_memory(kstd::units::bytes physical_size, kstd::units::bytes virtual_size)
+  simulated_memory::simulated_memory(kstd::bytes physical_size, kstd::bytes virtual_size)
       : m_descriptor{memfd_create("teachos_simulated_memory", 0)}
       , m_physical_size{physical_size}
       , m_virtual_size{virtual_size}
@@ -76,7 +76,7 @@ namespace kernel::tests
     return m_physical_base;
   }
 
-  auto simulated_memory::physical_size() const noexcept -> kstd::units::bytes
+  auto simulated_memory::physical_size() const noexcept -> kstd::bytes
   {
     return m_physical_size;
   }
@@ -86,12 +86,12 @@ namespace kernel::tests
     return kapi::memory::linear_address{m_virtual_base};
   }
 
-  auto simulated_memory::virtual_size() const noexcept -> kstd::units::bytes
+  auto simulated_memory::virtual_size() const noexcept -> kstd::bytes
   {
     return m_virtual_size;
   }
 
-  auto simulated_memory::map(kstd::units::bytes size, std::byte * to, off_t offset) -> std::byte *
+  auto simulated_memory::map(kstd::bytes size, std::byte * to, off_t offset) -> std::byte *
   {
     auto mapped_ptr = mmap(to, size.value, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, m_descriptor, offset);
     if (mapped_ptr == MAP_FAILED)
diff --git a/kernel/kernel/test_support/simulated_memory.hpp b/kernel/kernel/test_support/simulated_memory.hpp
index e7ca9f6c..e1046ef4 100644
--- a/kernel/kernel/test_support/simulated_memory.hpp
+++ b/kernel/kernel/test_support/simulated_memory.hpp
@@ -23,7 +23,7 @@ namespace kernel::tests
     //! Construct a new simulated memory device.
     //! @param physical_size The size of the physical memory.
     //! @param virtual_size The size of the virtual address space.
-    simulated_memory(kstd::units::bytes physical_size, kstd::units::bytes virtual_size);
+    simulated_memory(kstd::bytes physical_size, kstd::bytes virtual_size);
 
     //! Destroy this device
     ~simulated_memory();
@@ -38,13 +38,13 @@ namespace kernel::tests
     [[nodiscard]] auto physical_base() const noexcept -> std::byte const *;
 
     //! Get the size of the physical memory of this device.
-    [[nodiscard]] auto physical_size() const noexcept -> kstd::units::bytes;
+    [[nodiscard]] auto physical_size() const noexcept -> kstd::bytes;
 
     //! Get the base address of the virtual address space of this device.
     [[nodiscard]] auto virtual_base() const noexcept -> kapi::memory::linear_address;
 
     //! Get the size of the virtual address space of this device.
-    [[nodiscard]] auto virtual_size() const noexcept -> kstd::units::bytes;
+    [[nodiscard]] auto virtual_size() const noexcept -> kstd::bytes;
 
     //! Map a region of physical memory to a region of virtual memory.
     //!
@@ -52,12 +52,12 @@ namespace kernel::tests
     //! @param to The base address of the virtual region.
     //! @param offset The offset into the physical memory to map.
     //! @return A pointer to the first byte of the mapped region.
-    [[nodiscard]] auto map(kstd::units::bytes size, std::byte * to, off_t offset) -> std::byte *;
+    [[nodiscard]] auto map(kstd::bytes size, std::byte * to, off_t offset) -> std::byte *;
 
   private:
     int m_descriptor{};
-    kstd::units::bytes m_physical_size{0};
-    kstd::units::bytes m_virtual_size{0};
+    kstd::bytes m_physical_size{0};
+    kstd::bytes m_virtual_size{0};
     std::byte * m_physical_base{nullptr};
     std::byte * m_virtual_base{nullptr};
   };
diff --git a/libs/acpi/acpi/common/table_header.cpp b/libs/acpi/acpi/common/table_header.cpp
index ebceca1d..cf2e7c23 100644
--- a/libs/acpi/acpi/common/table_header.cpp
+++ b/libs/acpi/acpi/common/table_header.cpp
@@ -52,7 +52,7 @@ namespace acpi
     return std::string_view{base + offset, size};
   }
 
-  auto table_header::length() const noexcept -> kstd::units::bytes
+  auto table_header::length() const noexcept -> kstd::bytes
   {
     using type = decltype(common_table_header_data::length);
 
@@ -64,7 +64,7 @@ namespace acpi
 
     kstd::libc::memcpy(&raw_value, data.data(), size);
 
-    return kstd::units::bytes{raw_value};
+    return kstd::bytes{raw_value};
   }
 
   auto table_header::oem_id() const noexcept -> std::string_view
diff --git a/libs/acpi/acpi/common/table_header.hpp b/libs/acpi/acpi/common/table_header.hpp
index 8e1d7c59..18e1dfdf 100644
--- a/libs/acpi/acpi/common/table_header.hpp
+++ b/libs/acpi/acpi/common/table_header.hpp
@@ -30,7 +30,7 @@ namespace acpi
     [[nodiscard]] auto creator_id() const noexcept -> std::string_view;
 
     //! Get the length of the entire table, including this header.
-    [[nodiscard]] auto length() const noexcept -> kstd::units::bytes;
+    [[nodiscard]] auto length() const noexcept -> kstd::bytes;
 
     //! Get the ID of the OEM.
     [[nodiscard]] auto oem_id() const noexcept -> std::string_view;
diff --git a/libs/acpi/acpi/pointers.cpp b/libs/acpi/acpi/pointers.cpp
index 0393292c..85329bf2 100644
--- a/libs/acpi/acpi/pointers.cpp
+++ b/libs/acpi/acpi/pointers.cpp
@@ -38,9 +38,9 @@ namespace acpi
     return signature() == "RSD PTR " && validate_checksum({reinterpret_cast<std::byte const *>(this), sizeof(rsdp)});
   }
 
-  auto xsdp::length() const noexcept -> kstd::units::bytes
+  auto xsdp::length() const noexcept -> kstd::bytes
   {
-    return kstd::units::bytes{m_length};
+    return kstd::bytes{m_length};
   }
 
   auto xsdp::table_address() const noexcept -> std::uintptr_t
diff --git a/libs/acpi/acpi/pointers.hpp b/libs/acpi/acpi/pointers.hpp
index 310447f5..761d8748 100644
--- a/libs/acpi/acpi/pointers.hpp
+++ b/libs/acpi/acpi/pointers.hpp
@@ -50,7 +50,7 @@ namespace acpi
   struct [[gnu::packed]] xsdp : rsdp
   {
     //! Get the length of the data contained in this pointer.
-    [[nodiscard]] auto length() const noexcept -> kstd::units::bytes;
+    [[nodiscard]] auto length() const noexcept -> kstd::bytes;
 
     //! Get the physical address of the pointed-to Extended System Description Table.
     [[nodiscard]] auto table_address() const noexcept -> std::uintptr_t;
diff --git a/libs/kstd/kstd/units.hpp b/libs/kstd/kstd/units.hpp
index cb33af21..e3868aa7 100644
--- a/libs/kstd/kstd/units.hpp
+++ b/libs/kstd/kstd/units.hpp
@@ -9,71 +9,76 @@
 namespace kstd
 {
 
-  namespace units
-  {
-
-    using bytes = basic_unit<std::size_t, struct bytes_tag>;
-
-    // NOLINTNEXTLINE(readability-identifier-naming)
-    constexpr auto KiB(std::unsigned_integral auto value) noexcept -> bytes
-    {
-      return bytes{static_cast<bytes::value_type>(value) * 1024};
-    }
+  using bytes = basic_unit<std::size_t, struct bytes_tag>;
 
-    // NOLINTNEXTLINE(readability-identifier-naming)
-    constexpr auto MiB(std::unsigned_integral auto value) noexcept -> bytes
-    {
-      return bytes{static_cast<bytes::value_type>(value) * 1024 * 1024};
-    }
-
-    // NOLINTNEXTLINE(readability-identifier-naming)
-    constexpr auto GiB(std::unsigned_integral auto value) noexcept -> bytes
-    {
-      return bytes{static_cast<bytes::value_type>(value) * 1024 * 1024 * 1024};
-    }
-
-    template<typename ValueType>
-    constexpr auto operator+(ValueType * pointer, bytes offset) -> ValueType *
-    {
-      return pointer + offset.value;
-    }
-
-  }  // namespace units
+  // NOLINTNEXTLINE(readability-identifier-naming)
+  constexpr auto KiB(std::unsigned_integral auto value) noexcept -> bytes
+  {
+    return bytes{static_cast<bytes::value_type>(value) * 1024};
+  }
 
-  namespace units_literals
+  // NOLINTNEXTLINE(readability-identifier-naming)
+  constexpr auto MiB(std::unsigned_integral auto value) noexcept -> bytes
   {
-    constexpr auto operator""_B(unsigned long long value) noexcept -> units::bytes
-    {
-      return units::bytes{value};
-    }
+    return bytes{static_cast<bytes::value_type>(value) * 1024 * 1024};
+  }
 
-    constexpr auto operator""_KiB(unsigned long long value) noexcept -> units::bytes
-    {
-      return units::KiB(value);
-    }
+  // NOLINTNEXTLINE(readability-identifier-naming)
+  constexpr auto GiB(std::unsigned_integral auto value) noexcept -> bytes
+  {
+    return bytes{static_cast<bytes::value_type>(value) * 1024 * 1024 * 1024};
+  }
 
-    constexpr auto operator""_MiB(unsigned long long value) noexcept -> units::bytes
-    {
-      return units::MiB(value);
-    }
+  template<typename ValueType>
+  constexpr auto operator+(ValueType * pointer, bytes offset) -> ValueType *
+  {
+    return pointer + offset.value;
+  }
 
-    constexpr auto operator""_GiB(unsigned long long value) noexcept -> units::bytes
+  inline namespace literals
+  {
+    inline namespace units_literals
     {
-      return units::GiB(value);
-    }
-
-  }  // namespace units_literals
-
-  template<typename ValueType>
-  consteval auto size_of(ValueType const &) noexcept -> units::bytes
+      constexpr auto operator""_B(unsigned long long value) noexcept -> bytes
+      {
+        return bytes{value};
+      }
+
+      constexpr auto operator""_KiB(unsigned long long value) noexcept -> bytes
+      {
+        return KiB(value);
+      }
+
+      constexpr auto operator""_MiB(unsigned long long value) noexcept -> bytes
+      {
+        return MiB(value);
+      }
+
+      constexpr auto operator""_GiB(unsigned long long value) noexcept -> bytes
+      {
+        return GiB(value);
+      }
+
+    }  // namespace units_literals
+  }  // namespace literals
+
+  //! Calculate the size of a given object.
+  //!
+  //! @param object The object to calculate the size for.
+  //! @return the size, in bytes, of the given object.
+  consteval auto size_of(auto const & object) noexcept -> bytes
   {
-    return units::bytes{sizeof(ValueType)};
+    return bytes{sizeof(object)};
   }
 
-  template<typename ValueType>
-  consteval auto size_of() noexcept -> units::bytes
+  //! Calculate the size of a given type.
+  //!
+  //! @tparam Type The type to calculate the size for.
+  //! @return the size, in bytes, of the given type.
+  template<typename Type>
+  consteval auto size_of() noexcept -> bytes
   {
-    return units::bytes{sizeof(ValueType)};
+    return bytes{sizeof(Type)};
   }
 
 }  // namespace kstd
diff --git a/libs/multiboot2/multiboot2/information.hpp b/libs/multiboot2/multiboot2/information.hpp
index f12969e8..709d64a8 100644
--- a/libs/multiboot2/multiboot2/information.hpp
+++ b/libs/multiboot2/multiboot2/information.hpp
@@ -124,9 +124,9 @@ namespace multiboot2
       return {data(), vla_tag::size()};
     }
 
-    [[nodiscard]] constexpr auto size() const noexcept -> kstd::units::bytes
+    [[nodiscard]] constexpr auto size() const noexcept -> kstd::bytes
     {
-      return kstd::units::bytes{end_address - start_address};
+      return kstd::bytes{end_address - start_address};
     }
   };
 
@@ -157,9 +157,9 @@ namespace multiboot2
     using pointer = iterator::pointer;
     using reference = iterator::reference;
 
-    [[nodiscard]] auto size() const noexcept -> kstd::units::bytes
+    [[nodiscard]] auto size() const noexcept -> kstd::bytes
     {
-      return kstd::units::bytes{m_size};
+      return kstd::bytes{m_size};
     }
 
     // Range access
diff --git a/libs/multiboot2/multiboot2/information/data.hpp b/libs/multiboot2/multiboot2/information/data.hpp
index 734bbc6f..59d82b9e 100644
--- a/libs/multiboot2/multiboot2/information/data.hpp
+++ b/libs/multiboot2/multiboot2/information/data.hpp
@@ -29,14 +29,14 @@ namespace multiboot2
     //! loader.
     struct basic_memory : tag_data<information_id::basic_memory_information>
     {
-      [[nodiscard]] constexpr auto lower() const noexcept -> kstd::units::bytes
+      [[nodiscard]] constexpr auto lower() const noexcept -> kstd::bytes
       {
-        return kstd::units::bytes{lower_KiB * 1024};
+        return kstd::bytes{lower_KiB * 1024};
       }
 
-      [[nodiscard]] constexpr auto upper() const noexcept -> kstd::units::bytes
+      [[nodiscard]] constexpr auto upper() const noexcept -> kstd::bytes
       {
-        return kstd::units::bytes{upper_KiB * 1024};
+        return kstd::bytes{upper_KiB * 1024};
       }
 
       //! The amount of lower memory available to the system.
@@ -84,9 +84,9 @@ namespace multiboot2
     //! time. The array begins after the last member of this structure.
     struct elf_symbols : tag_data<information_id::elf_sections>
     {
-      [[nodiscard]] constexpr auto entry_size() const noexcept -> kstd::units::bytes
+      [[nodiscard]] constexpr auto entry_size() const noexcept -> kstd::bytes
       {
-        return kstd::units::bytes{entry_size_in_B};
+        return kstd::bytes{entry_size_in_B};
       }
 
       //! The number of section header table entries.
@@ -119,9 +119,9 @@ namespace multiboot2
           return type == memory_type::available;
         }
 
-        [[nodiscard]] constexpr auto size() const noexcept -> kstd::units::bytes
+        [[nodiscard]] constexpr auto size() const noexcept -> kstd::bytes
         {
-          return kstd::units::bytes{size_in_B};
+          return kstd::bytes{size_in_B};
         }
 
         //! The physical start address of this region
@@ -139,9 +139,9 @@ namespace multiboot2
         std::uint32_t : 0;
       };
 
-      [[nodiscard]] constexpr auto entry_size() const noexcept -> kstd::units::bytes
+      [[nodiscard]] constexpr auto entry_size() const noexcept -> kstd::bytes
       {
-        return kstd::units::bytes{entry_size_in_B};
+        return kstd::bytes{entry_size_in_B};
       }
 
       //! The size of each entry present in the map.