feat(cache): let a hit rebuild empty folders the task made

A task that makes a folder and leaves it empty, like `astro build` making
`.astro/collections`, pinned the folder holding it as an input: fspy
didn't record a mkdir as one (on Windows it was a read), so the empty
folder wasn't rebuildable, and the archive held only files, so a hit
couldn't recreate it. Removing the folder, as on a clean checkout, was a
cache miss.

fspy now records the path of a mkdir as a mkdir, a new access kind, before
the call, so a failed call, like one finding the folder there already, is
recorded too:

- Unix preload: `mkdir` and `mkdirat`.
- Linux seccomp supervisor, for static binaries: `mkdirat`, plus `mkdir`
  on x86_64.
- Windows: `NtCreateFile` with `FILE_DIRECTORY_FILE` and `FILE_CREATE` or
  `FILE_OPEN_IF`, where `CreateDirectoryW` ends. These opens were recorded
  as reads; a mkdir isn't one on Unix either.

`Rebuildable` takes the mkdirs that are empty folders after the run
(`.DS_Store` aside) as rebuildable folders and climbs from them too, so a
folder holding only such folders, rebuildable folders and files the task
wrote is rebuildable. Each folder is listed once: a mkdir'd folder above a
written path is decided while climbing, where an empty one counts as
rebuildable, and only the other mkdirs are checked for being empty. A run
without inferred reads skips the climb and checks every mkdir, for the
archive.

The archive gets directory entries for the empty folders, filtered by
output exclusions and `ignoreOutput` like files: all of them with
automatic output tracking, and otherwise those an `output` glob matches,
since the glob walk yields files only. Restoring recreates them. A folder
holding anything needs no entry, since what it holds recreates it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: wan9chi

CHANGELOG.md

@@ -1,5 +1,6 @@
 # Changelog
 
+- **Fixed** A cache hit now restores the empty folders a task made if they're among its outputs, like the `.astro/collections` folder that `astro build` leaves empty: with automatic output tracking that's every such folder, and with `output` globs, the ones they match. A folder holding only such folders and files the task wrote, like `.astro`, may now be missing, as on a fresh clone, and the next run is still a cache hit, which restores it if what it holds is among the task's outputs. Previously a hit left empty folders missing, and removing a folder holding one was a cache miss ([#917](https://github.com/voidzero-dev/vite-task/pull/917)).
 - **Fixed** A task's automatically tracked outputs now include the files it renames into place, like Vitest's `fsModuleCache` entries written under a temporary name, every file in a folder it renames into place, like Vite's dependency optimizer renaming `deps_temp_*` to `deps`, and the hard links it creates. The next run is a cache hit if they are missing, as on a fresh clone, and the hit restores them if they're among the task's outputs. Previously they weren't restored, and removing one that the task read back was a cache miss ([#916](https://github.com/voidzero-dev/vite-task/pull/916)).
 - **Changed** When a task lists a folder, the files it wrote there and the folders holding only such files no longer count as entries of the listing: the next run is a cache hit if they are missing, as on a fresh clone, and the hit restores them if they're among the task's outputs. For example, `tsc` with no `include` lists the package root, which holds its `lib` output folder; removing `lib` used to be a cache miss. The folder's other entries still count ([#915](https://github.com/voidzero-dev/vite-task/pull/915)).
 - **Changed** A task that checks or lists a folder holding only files it wrote, like `tsc` checking its `dist` output folder, is now a cache hit when the folder is missing, as on a fresh clone, and the hit restores the folder if its files are among the task's outputs. Previously the missing folder was a cache miss ([#914](https://github.com/voidzero-dev/vite-task/pull/914)).

crates/fspy/src/unix/syscall_handler/mod.rs

@@ -105,6 +105,8 @@ impl_handler!(
     faccessat,
     faccessat2,
 
+    #[cfg(target_arch = "x86_64")] mkdir,
+    mkdirat,
     #[cfg(target_arch = "x86_64")] rename,
     renameat,
     renameat2,

crates/fspy/src/unix/syscall_handler/namespace.rs

@@ -1,7 +1,9 @@
-//! Syscalls that put an existing file or folder at a new path without opening
-//! it: rename and hard link. The new path of a rename is recorded as a rename
-//! target, which may be a whole folder, and that of a hard link, always a
-//! file, as a write. The source of a rename needs no record.
+//! Syscalls that make an entry at a path without opening it: mkdir, and
+//! rename and hard link, which put an existing file or folder at a new path.
+//! The path of a mkdir is recorded as a mkdir, whether or not the folder is
+//! there already; the new path of a rename as a rename target, which may be
+//! a whole folder; and that of a hard link, always a file, as a write. The
+//! source of a rename needs no record.
 
 use std::io;
 
@@ -11,6 +13,19 @@ use fspy_shared::ipc::AccessMode;
 use super::SyscallHandler;
 
 impl SyscallHandler {
+    #[cfg(target_arch = "x86_64")]
+    pub(super) fn mkdir(&mut self, caller: Caller, (path,): (CStrPtr,)) -> io::Result<()> {
+        self.handle_path(caller, Fd::cwd(), path, AccessMode::Mkdir)
+    }
+
+    pub(super) fn mkdirat(
+        &mut self,
+        caller: Caller,
+        (dir_fd, path): (Fd, CStrPtr),
+    ) -> io::Result<()> {
+        self.handle_path(caller, dir_fd, path, AccessMode::Mkdir)
+    }
+
     #[cfg(target_arch = "x86_64")]
     pub(super) fn rename(
         &mut self,

crates/fspy/tests/rust_std.rs

@@ -138,6 +138,24 @@ async fn renamex_np_destination() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[test(tokio::test)]
+async fn mkdir() -> anyhow::Result<()> {
+    let tmp_dir = tempfile::tempdir()?;
+    fs::create_dir(tmp_dir.path().join("existing"))?;
+    let tmp_dir_str = tmp_dir.path().to_str().unwrap().to_owned();
+    let accesses = track_fn!(tmp_dir_str, |tmp_dir_str: String| {
+        let tmp_dir = std::path::Path::new(&tmp_dir_str);
+        fs::create_dir(tmp_dir.join("new")).unwrap();
+        // Fails, since the folder is there already; recorded anyway.
+        fs::create_dir(tmp_dir.join("existing")).unwrap_err();
+    })
+    .await?;
+    assert_contains(&accesses, tmp_dir.path().join("new").as_path(), PathAccess::Mkdir);
+    assert_contains(&accesses, tmp_dir.path().join("existing").as_path(), PathAccess::Mkdir);
+
+    Ok(())
+}
+
 #[test(tokio::test)]
 async fn metadata() -> anyhow::Result<()> {
     let tmp_dir = tempfile::tempdir()?;

crates/fspy/tests/static_executable.rs

@@ -89,6 +89,14 @@ async fn openat2_readwrite() {
     assert_contains(&accesses, Path::new("/hello"), fspy::PathAccess::ReadWrite);
 }
 
+#[test(tokio::test)]
+async fn mkdir() {
+    // The mkdir fails, since `/hello` doesn't exist; the folder is recorded
+    // anyway.
+    let accesses = track_test_bin(&["mkdir", "/hello/world"], None).await;
+    assert_contains(&accesses, Path::new("/hello/world"), fspy::PathAccess::Mkdir);
+}
+
 #[test(tokio::test)]
 async fn rename_destination() {
     // The rename fails, since `/hello` doesn't exist; the destination is

crates/fspy_e2e/src/main.rs

@@ -52,6 +52,7 @@ impl AccessCollector {
             PathAccess::RenameTarget(path) => {
                 relative(path).map(|path| format!("{path}: RenameTarget"))
             }
+            PathAccess::Mkdir(path) => relative(path).map(|path| format!("{path}: Mkdir")),
         };
         self.accesses.extend(line);
     }

crates/fspy_preload_unix/src/interceptions/namespace.rs

@@ -1,17 +1,34 @@
-//! Calls that put an existing file or folder at a new path without opening
-//! it: rename and hard link. The new path is recorded before the call, so a
-//! failed call is recorded too: as a rename target for a rename, which may
-//! move a whole folder, and as a write for a hard link, always to a file. The
-//! source of a rename needs no record.
+//! Calls that make an entry at a path without opening it: mkdir, and rename
+//! and hard link, which put an existing file or folder at a new path. The
+//! path is recorded before the call, so a failed call is recorded too: as a
+//! mkdir for a mkdir, whose folder may be there already; as a rename target
+//! for a rename, which may move a whole folder; and as a write for a hard
+//! link, always to a file. The source of a rename needs no record.
 
 use fspy_shared::ipc::AccessMode;
-use libc::{c_char, c_int};
+use libc::{c_char, c_int, mode_t};
 
 use crate::{
     client::{convert::PathAt, handle_open},
     macros::intercept,
 };
 
+intercept!(mkdir: unsafe extern "C" fn(path: *const c_char, mode: mode_t) -> c_int);
+unsafe extern "C" fn mkdir(path: *const c_char, mode: mode_t) -> c_int {
+    // SAFETY: path is a valid C string pointer provided by the caller of the interposed function
+    unsafe { handle_open(fspy_nostd::CStr::from_ptr(path.cast()), AccessMode::Mkdir) };
+    // SAFETY: calling the original libc mkdir() with the same arguments forwarded from the interposed function
+    unsafe { mkdir::original()(path, mode) }
+}
+
+intercept!(mkdirat: unsafe extern "C" fn(dirfd: c_int, path: *const c_char, mode: mode_t) -> c_int);
+unsafe extern "C" fn mkdirat(dirfd: c_int, path: *const c_char, mode: mode_t) -> c_int {
+    // SAFETY: dirfd is -1 or a valid file descriptor, and path is a valid C string, provided by the caller of the interposed function
+    unsafe { handle_open(PathAt::borrow_raw(dirfd, path), AccessMode::Mkdir) };
+    // SAFETY: calling the original libc mkdirat() with the same arguments forwarded from the interposed function
+    unsafe { mkdirat::original()(dirfd, path, mode) }
+}
+
 intercept!(rename: unsafe extern "C" fn(old: *const c_char, new: *const c_char) -> c_int);
 unsafe extern "C" fn rename(old: *const c_char, new: *const c_char) -> c_int {
     // SAFETY: new is a valid C string pointer provided by the caller of the interposed function

crates/fspy_preload_windows/src/windows/detours/nt.rs

@@ -3,10 +3,11 @@ use std::mem::{offset_of, size_of, size_of_val};
 use fspy_shared::ipc::{AccessMode, IpcPath, PathAccess};
 use ntapi::{
     ntioapi::{
-        FILE_INFORMATION_CLASS, FILE_RENAME_INFORMATION, FileLinkInformation,
-        FileLinkInformationEx, FileRenameInformation, FileRenameInformationEx,
-        NtQueryDirectoryFile, NtQueryFullAttributesFile, NtQueryInformationByName,
-        PFILE_BASIC_INFORMATION, PFILE_NETWORK_OPEN_INFORMATION, PIO_APC_ROUTINE, PIO_STATUS_BLOCK,
+        FILE_CREATE, FILE_DIRECTORY_FILE, FILE_INFORMATION_CLASS, FILE_OPEN_IF,
+        FILE_RENAME_INFORMATION, FileLinkInformation, FileLinkInformationEx, FileRenameInformation,
+        FileRenameInformationEx, NtQueryDirectoryFile, NtQueryFullAttributesFile,
+        NtQueryInformationByName, PFILE_BASIC_INFORMATION, PFILE_NETWORK_OPEN_INFORMATION,
+        PIO_APC_ROUTINE, PIO_STATUS_BLOCK,
     },
     ntpsapi::{
         NtCreateUserProcess, PPS_ATTRIBUTE_LIST, PPS_CREATE_INFO, PS_ATTRIBUTE,
@@ -161,6 +162,11 @@ unsafe fn read_process_image_attribute<'a>(
     None
 }
 
+// An open that may create a directory, from `CreateDirectoryW` (`FILE_CREATE`)
+// or a caller making it if it's missing (`FILE_OPEN_IF`), is recorded as a
+// mkdir, like `mkdir` on Unix, rather than as the read its
+// `FILE_LIST_DIRECTORY` access maps to. Listing the directory is recorded by
+// `NtQueryDirectoryFile`.
 static DETOUR_NT_CREATE_FILE: Detour<
     unsafe extern "system" fn(
         file_handle: PHANDLE,
@@ -192,8 +198,15 @@ static DETOUR_NT_CREATE_FILE: Detour<
                 ea_buffer: PVOID,
                 ea_length: ULONG,
             ) -> HFILE {
-                // SAFETY: intercepting file open to record access before forwarding to real function
-                unsafe { handle_open(desired_access, object_attributes) };
+                if create_options & FILE_DIRECTORY_FILE != 0
+                    && matches!(create_disposition, FILE_CREATE | FILE_OPEN_IF)
+                {
+                    // SAFETY: intercepting directory creation to record it before forwarding to real function
+                    unsafe { handle_open(AccessMode::Mkdir, object_attributes) };
+                } else {
+                    // SAFETY: intercepting file open to record access before forwarding to real function
+                    unsafe { handle_open(desired_access, object_attributes) };
+                }
 
                 // SAFETY: calling the original NtCreateFile with all original arguments
                 unsafe {

crates/fspy_shared/src/ipc/mod.rs

@@ -21,6 +21,7 @@ pub enum AccessMode {
     ReadWrite,
     ReadDir,
     RenameTarget,
+    Mkdir,
 }
 
 impl AccessMode {
@@ -32,6 +33,7 @@ impl AccessMode {
             Self::ReadWrite => PathAccess::ReadWrite(path),
             Self::ReadDir => PathAccess::ReadDir(path),
             Self::RenameTarget => PathAccess::RenameTarget(path),
+            Self::Mkdir => PathAccess::Mkdir(path),
         }
     }
 }
@@ -48,6 +50,9 @@ pub enum PathAccess<'a> {
     /// The new path of a rename. What is there after the call, a file or a
     /// whole folder, was put there without being opened.
     RenameTarget(&'a IpcPath),
+    /// A folder made by `mkdir`, recorded whether or not the call succeeded,
+    /// so the folder may have been there already.
+    Mkdir(&'a IpcPath),
 }
 
 impl<'a> PathAccess<'a> {
@@ -58,7 +63,8 @@ impl<'a> PathAccess<'a> {
             | PathAccess::Write(path)
             | PathAccess::ReadWrite(path)
             | PathAccess::ReadDir(path)
-            | PathAccess::RenameTarget(path) => iter::once(path),
+            | PathAccess::RenameTarget(path)
+            | PathAccess::Mkdir(path) => iter::once(path),
         }
     }
 
@@ -70,6 +76,7 @@ impl<'a> PathAccess<'a> {
             PathAccess::ReadWrite(path) => PathAccess::ReadWrite(path.clone_in(bump)),
             PathAccess::ReadDir(path) => PathAccess::ReadDir(path.clone_in(bump)),
             PathAccess::RenameTarget(path) => PathAccess::RenameTarget(path.clone_in(bump)),
+            PathAccess::Mkdir(path) => PathAccess::Mkdir(path.clone_in(bump)),
         }
     }
 }

crates/fspy_test_bin/src/main.rs

@@ -48,6 +48,9 @@ fn main() {
         "execve" => {
             let _ = std::process::Command::new(path).spawn();
         }
+        "mkdir" => {
+            let _ = std::fs::create_dir(path);
+        }
         "rename" => {
             let _ = std::fs::rename(path, second_path());
         }