From 0e72a1b27df2008013f2ee9c468a88c3e3843fae Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Thu, 27 Aug 2026 12:33:31 +0200
Subject: kapi/fs: implement read_directory

This change also replaces the kernel internal directory_listing_cursor
and directory_listing_entry with the kapi types directory_cursor and
directory_entry.
---
 kapi/kapi/filesystem.hpp                           |  6 ++----
 kapi/kapi/filesystem/directory_entry.hpp           |  4 ++--
 kernel/kapi/filesystem.cpp                         | 12 ++++-------
 kernel/kapi/filesystem.tests.cpp                   |  8 +++++++-
 kernel/kernel/filesystems/devfs/inode.cpp          | 16 +++++++--------
 kernel/kernel/filesystems/devfs/inode.hpp          | 10 +++++-----
 kernel/kernel/filesystems/devfs/inode.tests.cpp    | 22 ++++++++++-----------
 kernel/kernel/filesystems/ext2/inode.cpp           | 12 +++++------
 kernel/kernel/filesystems/ext2/inode.hpp           |  8 +++-----
 kernel/kernel/filesystems/ext2/inode.tests.cpp     | 18 ++++++++---------
 kernel/kernel/filesystems/rootfs/inode.cpp         |  9 +++++----
 kernel/kernel/filesystems/rootfs/inode.hpp         | 10 +++++-----
 kernel/kernel/vfs.hpp                              |  2 --
 kernel/kernel/vfs/byte_offset_file_descriptor.hpp  |  1 -
 kernel/kernel/vfs/directory_file_descriptor.cpp    |  8 ++++----
 kernel/kernel/vfs/directory_file_descriptor.hpp    |  8 +++-----
 .../kernel/vfs/directory_file_descriptor.tests.cpp | 10 ++++------
 kernel/kernel/vfs/directory_listing_cursor.hpp     | 23 ----------------------
 kernel/kernel/vfs/directory_listing_entry.hpp      | 23 ----------------------
 kernel/kernel/vfs/inode.cpp                        |  6 ++----
 kernel/kernel/vfs/inode.hpp                        |  9 +++------
 kernel/kernel/vfs/open_file_descriptor.cpp         |  3 +--
 kernel/kernel/vfs/open_file_descriptor.hpp         |  3 +--
 kernel/kernel/vfs/open_file_descriptor.tests.cpp   |  5 ++---
 24 files changed, 83 insertions(+), 153 deletions(-)
 delete mode 100644 kernel/kernel/vfs/directory_listing_cursor.hpp
 delete mode 100644 kernel/kernel/vfs/directory_listing_entry.hpp

diff --git a/kapi/kapi/filesystem.hpp b/kapi/kapi/filesystem.hpp
index 9da18c11..cd687c45 100644
--- a/kapi/kapi/filesystem.hpp
+++ b/kapi/kapi/filesystem.hpp
@@ -110,11 +110,9 @@ namespace kapi::filesystem
   //! List the contents of a directory.
   //!
   //! @param file_descriptor A file descriptor pointing to an open directory.
-  //! @param position The starting position of the listing.
   //! @param buffer A buffer to write the directory entries into.
-  //! @return The number of entries read and the next read position on success, an error otherwise.
-  auto read_directory(std::size_t file_descriptor, directory_cursor position, std::span<directory_entry> buffer)
-      -> kstd::result<std::pair<std::size_t, directory_cursor>>;
+  //! @return The number of entries read on success, an error otherwise.
+  auto read_directory(std::size_t file_descriptor, std::span<directory_entry> buffer) -> kstd::result<std::size_t>;
 
   //! @}
 }  // namespace kapi::filesystem
diff --git a/kapi/kapi/filesystem/directory_entry.hpp b/kapi/kapi/filesystem/directory_entry.hpp
index e881e415..6519f7df 100644
--- a/kapi/kapi/filesystem/directory_entry.hpp
+++ b/kapi/kapi/filesystem/directory_entry.hpp
@@ -14,9 +14,9 @@ namespace kapi::filesystem
 
   struct directory_entry
   {
-    std::uint64_t inode_number{};
-    file_type type{};
     kstd::string name{};
+    file_type type{};
+    std::uint64_t inode_number{};
   };
 
 }  // namespace kapi::filesystem
diff --git a/kernel/kapi/filesystem.cpp b/kernel/kapi/filesystem.cpp
index 7a0c2728..2f3c524e 100644
--- a/kernel/kapi/filesystem.cpp
+++ b/kernel/kapi/filesystem.cpp
@@ -4,7 +4,6 @@
 
 #include <kstd/memory.hpp>
 #include <kstd/result.hpp>
-#include <kstd/system_error.hpp>
 #include <kstd/units.hpp>
 
 #include <cstddef>
@@ -12,7 +11,6 @@
 #include <expected>
 #include <span>
 #include <string_view>
-#include <utility>
 
 namespace kapi::filesystem
 {
@@ -90,13 +88,11 @@ namespace kapi::filesystem
     return kernel::vfs::vfs::get().create_device_node(path, static_cast<std::uint32_t>(type), number);
   }
 
-  auto read_directory(std::size_t file_descriptor, directory_cursor position, std::span<directory_entry> buffer)
-      -> kstd::result<std::pair<std::size_t, directory_cursor>>
+  auto read_directory(std::size_t file_descriptor, std::span<directory_entry> buffer) -> kstd::result<std::size_t>
   {
-    static_cast<void>(file_descriptor);
-    static_cast<void>(position);
-    static_cast<void>(buffer);
-    return kstd::failure(make_error_code(kstd::errc::not_supported));
+    return kernel::vfs::open_file_table::get().file(file_descriptor).and_then([=](auto file) {
+      return file->read_directory(buffer);
+    });
   }
 
 }  // namespace kapi::filesystem
\ No newline at end of file
diff --git a/kernel/kapi/filesystem.tests.cpp b/kernel/kapi/filesystem.tests.cpp
index b2e39967..6fa2de3d 100644
--- a/kernel/kapi/filesystem.tests.cpp
+++ b/kernel/kapi/filesystem.tests.cpp
@@ -11,6 +11,7 @@
 #include <bit>
 #include <cstddef>
 #include <filesystem>
+#include <ranges>
 #include <string_view>
 #include <vector>
 
@@ -299,7 +300,12 @@ SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_vfs_fixture, "Kapi files
       REQUIRE(directory);
 
       auto buffer = std::vector<kapi::filesystem::directory_entry>{10};
-      REQUIRE_FALSE(kapi::filesystem::read_directory(*directory, {}, buffer));
+      REQUIRE(kapi::filesystem::read_directory(*directory, buffer) == 4);
+
+      REQUIRE(std::ranges::find(buffer, "info_1.txt", &kapi::filesystem::directory_entry::name) !=
+              std::ranges::end(buffer));
+      REQUIRE(std::ranges::find(buffer, "info_2.txt", &kapi::filesystem::directory_entry::name) !=
+              std::ranges::end(buffer));
     }
   }
 }
diff --git a/kernel/kernel/filesystems/devfs/inode.cpp b/kernel/kernel/filesystems/devfs/inode.cpp
index 01ce185f..e79a82e0 100644
--- a/kernel/kernel/filesystems/devfs/inode.cpp
+++ b/kernel/kernel/filesystems/devfs/inode.cpp
@@ -1,8 +1,6 @@
 #include <kernel/filesystems/devfs/inode.hpp>
 
 #include <kernel/vfs/device_number_registry.hpp>
-#include <kernel/vfs/directory_listing_cursor.hpp>
-#include <kernel/vfs/directory_listing_entry.hpp>
 #include <kernel/vfs/error.hpp>
 
 #include <kapi/filesystem.hpp>
@@ -27,7 +25,7 @@ namespace kernel::filesystems::devfs
 {
   namespace
   {
-    constexpr auto static sentinel = vfs::directory_listing_cursor{std::numeric_limits<std::uint64_t>::max()};
+    constexpr auto static sentinel = kapi::filesystem::directory_cursor{std::numeric_limits<std::uint64_t>::max()};
   }
 
   auto inode::read(std::span<std::byte>, kstd::bytes) const -> kstd::result<kstd::bytes>
@@ -45,9 +43,9 @@ namespace kernel::filesystems::devfs
     return true;
   }
 
-  auto inode::read_directory(vfs::directory_listing_cursor position,
-                             std::span<vfs::directory_listing_entry> entries) const
-      -> kstd::result<std::pair<std::size_t, vfs::directory_listing_cursor>>
+  auto inode::read_directory(kapi::filesystem::directory_cursor position,
+                             std::span<kapi::filesystem::directory_entry> entries) const
+      -> kstd::result<std::pair<std::size_t, kapi::filesystem::directory_cursor>>
   {
     auto const requested = entries.size();
     if (requested == 0)
@@ -81,7 +79,7 @@ namespace kernel::filesystems::devfs
     }
 
     std::ranges::transform(begin, begin + to_read, std::ranges::begin(entries), [](auto const & entry) {
-      return vfs::directory_listing_entry{
+      return kapi::filesystem::directory_entry{
         .name = entry.name,
         .type = entry.type,
         .inode_number = std::bit_cast<std::uint16_t>(entry.number),
@@ -95,8 +93,8 @@ namespace kernel::filesystems::devfs
     }
 
     auto const new_device_number = last_copied->number;
-    auto const new_cursor = vfs::directory_listing_cursor{static_cast<std::uint64_t>(new_device_number.minor) |
-                                                          (static_cast<std::uint64_t>(new_device_number.major) << 8)};
+    auto const new_cursor = kapi::filesystem::directory_cursor{
+      static_cast<std::uint64_t>(new_device_number.minor) | (static_cast<std::uint64_t>(new_device_number.major) << 8)};
     return std::pair{to_read, new_cursor};
   }
 }  // namespace kernel::filesystems::devfs
\ No newline at end of file
diff --git a/kernel/kernel/filesystems/devfs/inode.hpp b/kernel/kernel/filesystems/devfs/inode.hpp
index a4bbccfa..61bec8cf 100644
--- a/kernel/kernel/filesystems/devfs/inode.hpp
+++ b/kernel/kernel/filesystems/devfs/inode.hpp
@@ -1,10 +1,10 @@
 #ifndef TEACHOS_KERNEL_FILESYSTEMS_DEVFS_INODE_HPP
 #define TEACHOS_KERNEL_FILESYSTEMS_DEVFS_INODE_HPP
 
-#include <kernel/vfs/directory_listing_cursor.hpp>
-#include <kernel/vfs/directory_listing_entry.hpp>
 #include <kernel/vfs/inode.hpp>
 
+#include <kapi/filesystem.hpp>
+
 #include <kstd/result.hpp>
 #include <kstd/units.hpp>
 
@@ -26,9 +26,9 @@ namespace kernel::filesystems::devfs
 
     [[nodiscard]] auto is_directory() const -> bool override;
 
-    [[nodiscard]] auto read_directory(vfs::directory_listing_cursor position,
-                                      std::span<vfs::directory_listing_entry> entries) const
-        -> kstd::result<std::pair<std::size_t, vfs::directory_listing_cursor>> override;
+    [[nodiscard]] auto read_directory(kapi::filesystem::directory_cursor position,
+                                      std::span<kapi::filesystem::directory_entry> entries) const
+        -> kstd::result<std::pair<std::size_t, kapi::filesystem::directory_cursor>> override;
   };
 }  // namespace kernel::filesystems::devfs
 
diff --git a/kernel/kernel/filesystems/devfs/inode.tests.cpp b/kernel/kernel/filesystems/devfs/inode.tests.cpp
index 956db26b..4e315a7a 100644
--- a/kernel/kernel/filesystems/devfs/inode.tests.cpp
+++ b/kernel/kernel/filesystems/devfs/inode.tests.cpp
@@ -3,8 +3,6 @@
 #include <kernel/test_support/devices/block_device.hpp>
 #include <kernel/test_support/devices/driver.hpp>
 #include <kernel/vfs/device_inode.hpp>
-#include <kernel/vfs/directory_listing_cursor.hpp>
-#include <kernel/vfs/directory_listing_entry.hpp>
 
 #include <kapi/devices.hpp>
 #include <kapi/filesystem.hpp>
@@ -91,8 +89,8 @@ SCENARIO("Devfs inode directory listing", "[filesystem][devfs][inode]")
 
     THEN("the directory listing is empty")
     {
-      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>{4};
-      auto result = root.read_directory(kernel::vfs::directory_listing_cursor{}, entries);
+      auto entries = kstd::vector<kapi::filesystem::directory_entry>{4};
+      auto result = root.read_directory(kapi::filesystem::directory_cursor{}, entries);
 
       REQUIRE(result);
       auto [count, next] = *result;
@@ -113,8 +111,8 @@ SCENARIO("Devfs inode directory listing", "[filesystem][devfs][inode]")
 
     WHEN("the directory listing is requested with a buffer large enough for all of them")
     {
-      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>{4};
-      auto result = root.read_directory(kernel::vfs::directory_listing_cursor{}, entries);
+      auto entries = kstd::vector<kapi::filesystem::directory_entry>{4};
+      auto result = root.read_directory(kapi::filesystem::directory_cursor{}, entries);
 
       THEN("all devices are listed")
       {
@@ -148,11 +146,11 @@ SCENARIO("Devfs inode directory listing", "[filesystem][devfs][inode]")
     WHEN("read_directory is called one entry at a time, chaining the returned cursor")
     {
       auto seen = kstd::vector<kstd::string>{};
-      auto position = kernel::vfs::directory_listing_cursor{};
+      auto position = kapi::filesystem::directory_cursor{};
 
       for (auto guard = 0; guard < 4; ++guard)
       {
-        auto one = kstd::vector<kernel::vfs::directory_listing_entry>(1);
+        auto one = kstd::vector<kapi::filesystem::directory_entry>(1);
         auto result = root.read_directory(position, one);
         REQUIRE(result);
         auto [count, next] = *result;
@@ -195,8 +193,8 @@ SCENARIO("Devfs inode read_directory orders by device number, not registration o
 
     WHEN("read_directory is called with room for both remaining entries")
     {
-      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>(2);
-      auto result = root.read_directory(kernel::vfs::directory_listing_cursor{}, entries);
+      auto entries = kstd::vector<kapi::filesystem::directory_entry>(2);
+      auto result = root.read_directory(kapi::filesystem::directory_cursor{}, entries);
 
       THEN("later_in (the reused, lower device number) comes back before still_in, by number, not by "
            "when each was registered")
@@ -224,8 +222,8 @@ SCENARIO("Devfs read_directory rejects non-directory inodes", "[filesystem][devf
 
     THEN("read_directory falls through to the base class default rather than enumerating anything")
     {
-      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>(1);
-      auto result = node.read_directory(kernel::vfs::directory_listing_cursor{}, entries);
+      auto entries = kstd::vector<kapi::filesystem::directory_entry>(1);
+      auto result = node.read_directory(kapi::filesystem::directory_cursor{}, entries);
 
       REQUIRE_FALSE(result);
     }
diff --git a/kernel/kernel/filesystems/ext2/inode.cpp b/kernel/kernel/filesystems/ext2/inode.cpp
index 8e5c4559..f9322723 100644
--- a/kernel/kernel/filesystems/ext2/inode.cpp
+++ b/kernel/kernel/filesystems/ext2/inode.cpp
@@ -5,8 +5,6 @@
 #include <kernel/filesystems/ext2/filesystem.hpp>
 #include <kernel/filesystems/ext2/mount_state.hpp>
 #include <kernel/filesystems/ext2/write_batch.hpp>
-#include <kernel/vfs/directory_listing_cursor.hpp>
-#include <kernel/vfs/directory_listing_entry.hpp>
 #include <kernel/vfs/error.hpp>
 #include <kernel/vfs/inode.hpp>
 #include <kernel/vfs/mount.hpp>
@@ -226,9 +224,9 @@ namespace kernel::filesystems::ext2
     return result;
   }
 
-  auto inode::read_directory(vfs::directory_listing_cursor position,
-                             std::span<vfs::directory_listing_entry> entries) const
-      -> kstd::result<std::pair<std::size_t, vfs::directory_listing_cursor>>
+  auto inode::read_directory(kapi::filesystem::directory_cursor position,
+                             std::span<kapi::filesystem::directory_entry> entries) const
+      -> kstd::result<std::pair<std::size_t, kapi::filesystem::directory_cursor>>
   {
     if (!is_directory())
     {
@@ -253,7 +251,7 @@ namespace kernel::filesystems::ext2
         continue;
       }
 
-      entries[count++] = vfs::directory_listing_entry{
+      entries[count++] = kapi::filesystem::directory_entry{
         .name = kstd::string{it->name()},
         .type = to_file_type(it->file_type),
         .inode_number = it->inode,
@@ -265,7 +263,7 @@ namespace kernel::filesystems::ext2
       }
     }
 
-    return std::pair{count, vfs::directory_listing_cursor{it.offset().value}};
+    return std::pair{count, kapi::filesystem::directory_cursor{it.offset().value}};
   }
 
   auto inode::append_blocks(size_t count, write_batch & batch) -> bool
diff --git a/kernel/kernel/filesystems/ext2/inode.hpp b/kernel/kernel/filesystems/ext2/inode.hpp
index e2cb74a1..6d40d73c 100644
--- a/kernel/kernel/filesystems/ext2/inode.hpp
+++ b/kernel/kernel/filesystems/ext2/inode.hpp
@@ -3,8 +3,6 @@
 
 #include <kernel/filesystems/ext2/mount_state.hpp>
 #include <kernel/filesystems/ext2/write_batch.hpp>
-#include <kernel/vfs/directory_listing_cursor.hpp>
-#include <kernel/vfs/directory_listing_entry.hpp>
 #include <kernel/vfs/inode.hpp>
 
 #include <kapi/filesystem.hpp>
@@ -92,9 +90,9 @@ namespace kernel::filesystems::ext2
 
     [[nodiscard]] auto status() const -> kstd::result<kapi::filesystem::file_status> override;
 
-    [[nodiscard]] auto read_directory(vfs::directory_listing_cursor position,
-                                      std::span<vfs::directory_listing_entry> entries) const
-        -> kstd::result<std::pair<std::size_t, vfs::directory_listing_cursor>> override;
+    [[nodiscard]] auto read_directory(kapi::filesystem::directory_cursor position,
+                                      std::span<kapi::filesystem::directory_entry> entries) const
+        -> kstd::result<std::pair<std::size_t, kapi::filesystem::directory_cursor>> override;
 
     //! @}
 
diff --git a/kernel/kernel/filesystems/ext2/inode.tests.cpp b/kernel/kernel/filesystems/ext2/inode.tests.cpp
index aa8a8da5..f0b38571 100644
--- a/kernel/kernel/filesystems/ext2/inode.tests.cpp
+++ b/kernel/kernel/filesystems/ext2/inode.tests.cpp
@@ -11,8 +11,6 @@
 #include <kernel/test_support/filesystems/ext2.hpp>
 #include <kernel/test_support/vfs/storage_boot_module_fixture.hpp>
 #include <kernel/vfs/device_inode.hpp>
-#include <kernel/vfs/directory_listing_cursor.hpp>
-#include <kernel/vfs/directory_listing_entry.hpp>
 #include <kernel/vfs/filesystem.hpp>
 #include <kernel/vfs/mount.hpp>
 
@@ -716,8 +714,8 @@ SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_fixture,
 
     WHEN("read_directory is called with a buffer large enough for everything in it")
     {
-      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>(8);
-      auto result = (*information)->read_directory(kernel::vfs::directory_listing_cursor{}, entries);
+      auto entries = kstd::vector<kapi::filesystem::directory_entry>(8);
+      auto result = (*information)->read_directory(kapi::filesystem::directory_cursor{}, entries);
 
       THEN("known entries come back, correctly typed")
       {
@@ -761,8 +759,8 @@ SCENARIO("Ext2 inode read_directory rejects non-directory inodes", "[filesystem]
 
     THEN("read_directory fails without needing a mount at all")
     {
-      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>(1);
-      auto result = inode.read_directory(kernel::vfs::directory_listing_cursor{}, entries);
+      auto entries = kstd::vector<kapi::filesystem::directory_entry>(1);
+      auto result = inode.read_directory(kapi::filesystem::directory_cursor{}, entries);
 
       REQUIRE_FALSE(result);
     }
@@ -824,11 +822,11 @@ SCENARIO("Ext2 inode read_directory skips deleted entries and paginates correctl
     WHEN("read_directory is called one entry at a time, chaining the returned cursor")
     {
       auto seen = std::vector<std::string>{};
-      auto position = kernel::vfs::directory_listing_cursor{};
+      auto position = kapi::filesystem::directory_cursor{};
 
       for (auto guard = 0; guard < 8; ++guard)
       {
-        auto one = kstd::vector<kernel::vfs::directory_listing_entry>(1);
+        auto one = kstd::vector<kapi::filesystem::directory_entry>(1);
         auto result = directory.read_directory(position, one);
         REQUIRE(result);
         auto [count, next] = *result;
@@ -852,8 +850,8 @@ SCENARIO("Ext2 inode read_directory skips deleted entries and paginates correctl
 
     WHEN("read_directory is called with a buffer that exactly fits the three real entries")
     {
-      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>(3);
-      auto result = directory.read_directory(kernel::vfs::directory_listing_cursor{}, entries);
+      auto entries = kstd::vector<kapi::filesystem::directory_entry>(3);
+      auto result = directory.read_directory(kapi::filesystem::directory_cursor{}, entries);
 
       THEN("all three come back, and the very next call reports exhaustion, not a fourth entry")
       {
diff --git a/kernel/kernel/filesystems/rootfs/inode.cpp b/kernel/kernel/filesystems/rootfs/inode.cpp
index 4c5b5384..2555ecda 100644
--- a/kernel/kernel/filesystems/rootfs/inode.cpp
+++ b/kernel/kernel/filesystems/rootfs/inode.cpp
@@ -1,8 +1,8 @@
 #include <kernel/vfs/inode.hpp>
 
 #include <kernel/filesystems/rootfs/inode.hpp>
-#include <kernel/vfs/directory_listing_cursor.hpp>
-#include <kernel/vfs/directory_listing_entry.hpp>
+
+#include <kapi/filesystem.hpp>
 
 #include <kstd/result.hpp>
 #include <kstd/units.hpp>
@@ -28,8 +28,9 @@ namespace kernel::filesystems::rootfs
     return true;
   }
 
-  auto inode::read_directory(vfs::directory_listing_cursor position, std::span<vfs::directory_listing_entry>) const
-      -> kstd::result<std::pair<std::size_t, vfs::directory_listing_cursor>>
+  auto inode::read_directory(kapi::filesystem::directory_cursor position,
+                             std::span<kapi::filesystem::directory_entry>) const
+      -> kstd::result<std::pair<std::size_t, kapi::filesystem::directory_cursor>>
   {
     return std::pair{0, position};
   }
diff --git a/kernel/kernel/filesystems/rootfs/inode.hpp b/kernel/kernel/filesystems/rootfs/inode.hpp
index 37b2fc54..10e6a4e1 100644
--- a/kernel/kernel/filesystems/rootfs/inode.hpp
+++ b/kernel/kernel/filesystems/rootfs/inode.hpp
@@ -1,10 +1,10 @@
 #ifndef TEACHOS_KERNEL_FILESYSTEMS_ROOTFS_INODE_HPP
 #define TEACHOS_KERNEL_FILESYSTEMS_ROOTFS_INODE_HPP
 
-#include <kernel/vfs/directory_listing_cursor.hpp>
-#include <kernel/vfs/directory_listing_entry.hpp>
 #include <kernel/vfs/inode.hpp>
 
+#include <kapi/filesystem.hpp>
+
 #include <kstd/memory.hpp>
 #include <kstd/result.hpp>
 #include <kstd/string.hpp>
@@ -27,9 +27,9 @@ namespace kernel::filesystems::rootfs
 
     [[nodiscard]] auto is_directory() const -> bool override;
 
-    [[nodiscard]] auto read_directory(vfs::directory_listing_cursor position,
-                                      std::span<vfs::directory_listing_entry> entries) const
-        -> kstd::result<std::pair<std::size_t, vfs::directory_listing_cursor>> override;
+    [[nodiscard]] auto read_directory(kapi::filesystem::directory_cursor position,
+                                      std::span<kapi::filesystem::directory_entry> entries) const
+        -> kstd::result<std::pair<std::size_t, kapi::filesystem::directory_cursor>> override;
   };
 }  // namespace kernel::filesystems::rootfs
 
diff --git a/kernel/kernel/vfs.hpp b/kernel/kernel/vfs.hpp
index fed967d0..136d5f5c 100644
--- a/kernel/kernel/vfs.hpp
+++ b/kernel/kernel/vfs.hpp
@@ -7,8 +7,6 @@
 #include <kernel/vfs/device_inode.hpp>                 // IWYU pragma: export
 #include <kernel/vfs/device_number_registry.hpp>       // IWYU pragma: export
 #include <kernel/vfs/directory_file_descriptor.hpp>    // IWYU pragma: export
-#include <kernel/vfs/directory_listing_cursor.hpp>     // IWYU pragma: export
-#include <kernel/vfs/directory_listing_entry.hpp>      // IWYU pragma: export
 #include <kernel/vfs/driver_registry.hpp>              // IWYU pragma: export
 #include <kernel/vfs/error.hpp>                        // IWYU pragma: export
 #include <kernel/vfs/file_type_bindings.hpp>           // IWYU pragma: export
diff --git a/kernel/kernel/vfs/byte_offset_file_descriptor.hpp b/kernel/kernel/vfs/byte_offset_file_descriptor.hpp
index 4008d500..b0b11cb9 100644
--- a/kernel/kernel/vfs/byte_offset_file_descriptor.hpp
+++ b/kernel/kernel/vfs/byte_offset_file_descriptor.hpp
@@ -2,7 +2,6 @@
 #define TEACHOS_KERNEL_VFS_BYTE_OFFSET_FILE_DESCRIPTOR_HPP
 
 #include <kernel/vfs/dentry.hpp>
-#include <kernel/vfs/directory_listing_entry.hpp>
 #include <kernel/vfs/open_file_descriptor.hpp>
 
 #include <kapi/filesystem.hpp>
diff --git a/kernel/kernel/vfs/directory_file_descriptor.cpp b/kernel/kernel/vfs/directory_file_descriptor.cpp
index fd60d1d5..c1fb2a55 100644
--- a/kernel/kernel/vfs/directory_file_descriptor.cpp
+++ b/kernel/kernel/vfs/directory_file_descriptor.cpp
@@ -1,8 +1,8 @@
 #include <kernel/vfs/directory_file_descriptor.hpp>
 
 #include <kernel/vfs/dentry.hpp>
-#include <kernel/vfs/directory_listing_cursor.hpp>
-#include <kernel/vfs/directory_listing_entry.hpp>
+
+#include <kapi/filesystem.hpp>
 
 #include <kstd/memory.hpp>
 #include <kstd/result.hpp>
@@ -13,7 +13,7 @@
 namespace kernel::vfs
 {
 
-  auto directory_file_descriptor::read_directory(std::span<directory_listing_entry> entries)
+  auto directory_file_descriptor::read_directory(std::span<kapi::filesystem::directory_entry> entries)
       -> kstd::result<std::size_t>
   {
     auto result = get_dentry()->inode()->read_directory(m_position, entries);
@@ -26,7 +26,7 @@ namespace kernel::vfs
     return result->first;
   }
 
-  auto directory_file_descriptor::position() const noexcept -> directory_listing_cursor
+  auto directory_file_descriptor::position() const noexcept -> kapi::filesystem::directory_cursor
   {
     return m_position;
   }
diff --git a/kernel/kernel/vfs/directory_file_descriptor.hpp b/kernel/kernel/vfs/directory_file_descriptor.hpp
index 92649783..119d9210 100644
--- a/kernel/kernel/vfs/directory_file_descriptor.hpp
+++ b/kernel/kernel/vfs/directory_file_descriptor.hpp
@@ -2,8 +2,6 @@
 #define TEACHOS_KERNEL_VFS_DIRECTORY_FILE_DESCRIPTOR_HPP
 
 #include <kernel/vfs/dentry.hpp>
-#include <kernel/vfs/directory_listing_cursor.hpp>
-#include <kernel/vfs/directory_listing_entry.hpp>
 #include <kernel/vfs/open_file_descriptor.hpp>
 
 #include <kapi/filesystem.hpp>
@@ -22,12 +20,12 @@ namespace kernel::vfs
   {
     using open_file_descriptor::open_file_descriptor;
 
-    auto read_directory(std::span<directory_listing_entry> entries) -> kstd::result<std::size_t> override;
+    auto read_directory(std::span<kapi::filesystem::directory_entry> entries) -> kstd::result<std::size_t> override;
 
-    [[nodiscard]] auto position() const noexcept -> directory_listing_cursor;
+    [[nodiscard]] auto position() const noexcept -> kapi::filesystem::directory_cursor;
 
   private:
-    directory_listing_cursor m_position{};
+    kapi::filesystem::directory_cursor m_position{};
   };
 
 }  // namespace kernel::vfs
diff --git a/kernel/kernel/vfs/directory_file_descriptor.tests.cpp b/kernel/kernel/vfs/directory_file_descriptor.tests.cpp
index dd7a5afc..e6867f17 100644
--- a/kernel/kernel/vfs/directory_file_descriptor.tests.cpp
+++ b/kernel/kernel/vfs/directory_file_descriptor.tests.cpp
@@ -4,8 +4,6 @@
 #include <kernel/test_support/vfs/storage_boot_module_vfs_fixture.hpp>
 #include <kernel/vfs.hpp>
 #include <kernel/vfs/dentry.hpp>
-#include <kernel/vfs/directory_listing_cursor.hpp>
-#include <kernel/vfs/directory_listing_entry.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -39,7 +37,7 @@ SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_vfs_fixture,
 
     THEN("position starts at a default-constructed cursor")
     {
-      REQUIRE(fd.position() == kernel::vfs::directory_listing_cursor{});
+      REQUIRE(fd.position() == kapi::filesystem::directory_cursor{});
     }
 
     WHEN("read_directory is called one entry at a time, with no cursor passed by the caller")
@@ -48,7 +46,7 @@ SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_vfs_fixture,
 
       for (auto guard = 0; guard < 16; ++guard)
       {
-        auto one = kstd::vector<kernel::vfs::directory_listing_entry>(1);
+        auto one = kstd::vector<kapi::filesystem::directory_entry>(1);
         auto result = fd.read_directory(one);
         REQUIRE(result);
         if (*result == 0)
@@ -60,7 +58,7 @@ SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_vfs_fixture,
 
       THEN("every call advanced position on its own, and the known entries all appear exactly once")
       {
-        REQUIRE(fd.position() != kernel::vfs::directory_listing_cursor{});
+        REQUIRE(fd.position() != kapi::filesystem::directory_cursor{});
         REQUIRE(std::ranges::find(seen, ".") != seen.end());
         REQUIRE(std::ranges::find(seen, "info_1.txt") != seen.end());
 
@@ -68,7 +66,7 @@ SCENARIO_METHOD(kernel::tests::vfs::storage_boot_module_vfs_fixture,
         {
           auto const position_at_exhaustion = fd.position();
 
-          auto one = kstd::vector<kernel::vfs::directory_listing_entry>(1);
+          auto one = kstd::vector<kapi::filesystem::directory_entry>(1);
           auto result = fd.read_directory(one);
 
           REQUIRE(result);
diff --git a/kernel/kernel/vfs/directory_listing_cursor.hpp b/kernel/kernel/vfs/directory_listing_cursor.hpp
deleted file mode 100644
index 544d1115..00000000
--- a/kernel/kernel/vfs/directory_listing_cursor.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef TEACHOS_KERNEL_VFS_DIRECTORY_LISTING_CURSOR_HPP
-#define TEACHOS_KERNEL_VFS_DIRECTORY_LISTING_CURSOR_HPP
-
-#include <compare>
-#include <cstdint>
-
-namespace kernel::vfs
-{
-
-  //! A cursor used to keep track of positions in directory listings.
-  struct directory_listing_cursor
-  {
-    constexpr auto friend operator<=>(directory_listing_cursor const &, directory_listing_cursor const &) noexcept
-        -> std::strong_ordering = default;
-    constexpr auto friend operator==(directory_listing_cursor const &, directory_listing_cursor const &) noexcept
-        -> bool = default;
-
-    std::uint64_t value;
-  };
-
-};  // namespace kernel::vfs
-
-#endif
\ No newline at end of file
diff --git a/kernel/kernel/vfs/directory_listing_entry.hpp b/kernel/kernel/vfs/directory_listing_entry.hpp
deleted file mode 100644
index f636a6bf..00000000
--- a/kernel/kernel/vfs/directory_listing_entry.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef TEACHOS_KERNEL_VFS_DIRECTORY_LISTING_ENTRY_HPP
-#define TEACHOS_KERNEL_VFS_DIRECTORY_LISTING_ENTRY_HPP
-
-#include <kapi/filesystem.hpp>
-
-#include <kstd/string.hpp>
-
-#include <cstdint>
-
-namespace kernel::vfs
-{
-
-  //! An entry in a directory listing.
-  struct directory_listing_entry
-  {
-    kstd::string name;
-    kapi::filesystem::file_type type;
-    std::uint64_t inode_number;
-  };
-
-};  // namespace kernel::vfs
-
-#endif
\ No newline at end of file
diff --git a/kernel/kernel/vfs/inode.cpp b/kernel/kernel/vfs/inode.cpp
index ee7aa1e9..9bf44512 100644
--- a/kernel/kernel/vfs/inode.cpp
+++ b/kernel/kernel/vfs/inode.cpp
@@ -1,7 +1,5 @@
 #include <kernel/vfs/inode.hpp>
 
-#include <kernel/vfs/directory_listing_cursor.hpp>
-#include <kernel/vfs/directory_listing_entry.hpp>
 #include <kernel/vfs/error.hpp>
 
 #include <kapi/filesystem.hpp>
@@ -84,8 +82,8 @@ namespace kernel::vfs
     return std::nullopt;
   }
 
-  auto inode::read_directory(directory_listing_cursor, std::span<directory_listing_entry>) const
-      -> kstd::result<std::pair<std::size_t, directory_listing_cursor>>
+  auto inode::read_directory(kapi::filesystem::directory_cursor, std::span<kapi::filesystem::directory_entry>) const
+      -> kstd::result<std::pair<std::size_t, kapi::filesystem::directory_cursor>>
   {
     return kstd::failure(errc::not_a_directory);
   }
diff --git a/kernel/kernel/vfs/inode.hpp b/kernel/kernel/vfs/inode.hpp
index 80657b92..d8db8046 100644
--- a/kernel/kernel/vfs/inode.hpp
+++ b/kernel/kernel/vfs/inode.hpp
@@ -1,9 +1,6 @@
 #ifndef TEACHOS_KERNEL_VFS_INODE_HPP
 #define TEACHOS_KERNEL_VFS_INODE_HPP
 
-#include <kernel/vfs/directory_listing_cursor.hpp>
-#include <kernel/vfs/directory_listing_entry.hpp>
-
 #include <kapi/filesystem.hpp>
 
 #include <kstd/memory.hpp>
@@ -113,9 +110,9 @@ namespace kernel::vfs
     //! @param position The current directory listing position.
     //! @param entries An output span to store directory entries.
     //! @return A pair of the number or read entries and the next listing position on success, an error otherwise.
-    [[nodiscard]] virtual auto read_directory(directory_listing_cursor position,
-                                              std::span<directory_listing_entry> entries) const
-        -> kstd::result<std::pair<std::size_t, directory_listing_cursor>>;
+    [[nodiscard]] virtual auto read_directory(kapi::filesystem::directory_cursor position,
+                                              std::span<kapi::filesystem::directory_entry> entries) const
+        -> kstd::result<std::pair<std::size_t, kapi::filesystem::directory_cursor>>;
 
     //! @}
 
diff --git a/kernel/kernel/vfs/open_file_descriptor.cpp b/kernel/kernel/vfs/open_file_descriptor.cpp
index 44d55bb9..4f0581d2 100644
--- a/kernel/kernel/vfs/open_file_descriptor.cpp
+++ b/kernel/kernel/vfs/open_file_descriptor.cpp
@@ -1,7 +1,6 @@
 #include <kernel/vfs/open_file_descriptor.hpp>
 
 #include <kernel/vfs/dentry.hpp>
-#include <kernel/vfs/directory_listing_entry.hpp>
 #include <kernel/vfs/error.hpp>
 
 #include <kapi/filesystem.hpp>
@@ -40,7 +39,7 @@ namespace kernel::vfs
     return kstd::failure(errc::is_a_directory);
   }
 
-  auto open_file_descriptor::read_directory(std::span<directory_listing_entry>) -> kstd::result<std::size_t>
+  auto open_file_descriptor::read_directory(std::span<kapi::filesystem::directory_entry>) -> kstd::result<std::size_t>
   {
     return kstd::failure(errc::not_a_directory);
   }
diff --git a/kernel/kernel/vfs/open_file_descriptor.hpp b/kernel/kernel/vfs/open_file_descriptor.hpp
index 2fa27adc..587105b8 100644
--- a/kernel/kernel/vfs/open_file_descriptor.hpp
+++ b/kernel/kernel/vfs/open_file_descriptor.hpp
@@ -2,7 +2,6 @@
 #define TEACHOS_KERNEL_VFS_OPEN_FILE_DESCRIPTOR_HPP
 
 #include <kernel/vfs/dentry.hpp>
-#include <kernel/vfs/directory_listing_entry.hpp>
 
 #include <kapi/filesystem.hpp>
 
@@ -52,7 +51,7 @@ namespace kernel::vfs
     //!
     //! @param entries A buffer to read the entries into.
     //! @return The number of read entries on success, an error otherwise.
-    virtual auto read_directory(std::span<directory_listing_entry> entries) -> kstd::result<std::size_t>;
+    virtual auto read_directory(std::span<kapi::filesystem::directory_entry> entries) -> kstd::result<std::size_t>;
 
     //! Get a reference to the directory entry associated with this open file descriptor.
     //!
diff --git a/kernel/kernel/vfs/open_file_descriptor.tests.cpp b/kernel/kernel/vfs/open_file_descriptor.tests.cpp
index 861bddef..b22cbbec 100644
--- a/kernel/kernel/vfs/open_file_descriptor.tests.cpp
+++ b/kernel/kernel/vfs/open_file_descriptor.tests.cpp
@@ -4,7 +4,6 @@
 #include <kernel/vfs/byte_offset_file_descriptor.hpp>
 #include <kernel/vfs/dentry.hpp>
 #include <kernel/vfs/directory_file_descriptor.hpp>
-#include <kernel/vfs/directory_listing_entry.hpp>
 #include <kernel/vfs/error.hpp>
 
 #include <kapi/filesystem.hpp>
@@ -58,7 +57,7 @@ SCENARIO("open_file_descriptor's base defaults fail every operation, uncondition
     THEN("read_directory fails as 'this is not a directory' — the opposite error, and the only one of "
          "the four that's correct for it")
     {
-      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>(1);
+      auto entries = kstd::vector<kapi::filesystem::directory_entry>(1);
       auto result = fd.read_directory(entries);
 
       REQUIRE_FALSE(result);
@@ -80,7 +79,7 @@ SCENARIO("Cross-type calls through open_file_descriptor fall through to the corr
 
     THEN("read_directory falls through to the base — byte_offset_file_descriptor never overrode it")
     {
-      auto entries = kstd::vector<kernel::vfs::directory_listing_entry>(1);
+      auto entries = kstd::vector<kapi::filesystem::directory_entry>(1);
       auto result = fd->read_directory(entries);
 
       REQUIRE_FALSE(result);
-- 
cgit v1.2.3