Bun.file: make exists()/size/lastModified reflect the current filesystem state

src/jsc/webcore_types.rs

@@ -129,6 +129,10 @@ pub struct Blob {
     pub charset: Cell<AsciiStatus>,
     /// Was it created via the `File` constructor?
     pub is_jsdom_file: Cell<bool>,
+    /// True when `size` is a bound the caller asked for (`Blob.slice`). For a
+    /// file store `size` is otherwise a `stat` hint that must be refreshed on
+    /// every access: the filesystem can change between calls.
+    pub size_is_explicit: Cell<bool>,
     /// `bun.ptr.RawRefCount(u32, .single_threaded)` — counts in-flight `*Blob`
     /// borrows handed to async readers; not the JS GC retain count. Zero while
     /// the JS cell is the sole owner.
@@ -162,6 +166,7 @@ impl Default for Blob {
             content_type_was_set: Cell::new(false),
             charset: Cell::new(AsciiStatus::Unknown),
             is_jsdom_file: Cell::new(false),
+            size_is_explicit: Cell::new(false),
             ref_count: bun_ptr::RawRefCount::init(0),
             global_this: Cell::new(core::ptr::null()),
             last_modified: Cell::new(0.0),
@@ -374,6 +379,7 @@ impl Blob {
             content_type_was_set: Cell::new(self.content_type_was_set.get()),
             charset: Cell::new(self.charset.get()),
             is_jsdom_file: Cell::new(self.is_jsdom_file.get()),
+            size_is_explicit: Cell::new(self.size_is_explicit.get()),
             ref_count: bun_ptr::RawRefCount::init(0), // setNotHeapAllocated
             global_this: Cell::new(self.global_this.get()),
             last_modified: Cell::new(self.last_modified.get()),

src/runtime/webcore/Blob.rs

@@ -755,10 +755,15 @@ impl BlobExt for Blob {
                 writer.write_int_le::<u32>(stored_name.len() as u32)?;
                 writer.write_all(stored_name)?;
             } else {
-                // Version 4: a file-backed slice's window end. Written before
-                // resolve_size() so an unresolved blob stays MAX_SIZE (unknown)
-                // on the wire and the receiver stats it locally, like v3.
-                writer.write_int_le::<u64>(self.size.get())?;
+                // Version 4: a file-backed slice's window end. A stat-derived
+                // `size` is a hint (the receiver re-stats locally), so only a
+                // caller-supplied slice bound goes on the wire; an unbounded
+                // view stays MAX_SIZE (unknown), like v3.
+                writer.write_int_le::<u64>(if self.size_is_explicit.get() {
+                    self.size.get()
+                } else {
+                    MAX_SIZE
+                })?;
                 self.resolve_size();
                 store.serialize(writer)?;
             }
@@ -1266,25 +1271,24 @@ impl BlobExt for Blob {
     }
 
     fn get_exists_sync(&self) -> JSValue {
-        if self.size.get() == MAX_SIZE {
-            self.resolve_size();
-        }
-
         // If there's no store that means it's empty and we just return true
         let Some(store) = self.store.get() else {
             return JSValue::TRUE;
         };
 
-        if matches!(store.data, store::Data::Bytes(_)) {
+        match store.data_mut().tag() {
             // Bytes will never error
-            return JSValue::TRUE;
+            store::DataTag::Bytes => JSValue::TRUE,
+            store::DataTag::File => {
+                // Always re-stat: `exists()` must reflect the current
+                // filesystem state, not a cached snapshot.
+                resolve_file_stat(store);
+                let file = store.data_mut().as_file();
+                // We say regular files and pipes exist.
+                JSValue::from(bun_sys::S::ISREG(file.mode) || bun_sys::S::ISFIFO(file.mode))
+            }
+            store::DataTag::S3 => JSValue::FALSE,
         }
-
-        // We say regular files and pipes exist.
-        let store::Data::File(file) = &store.data else {
-            return JSValue::FALSE;
-        };
-        JSValue::from(bun_sys::S::ISREG(file.mode) || bun_sys::S::ISFIFO(file.mode))
     }
     fn do_write(&self, global_this: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
         // SAFETY: bun_vm() never returns null for a Bun-owned global.
@@ -1970,6 +1974,9 @@ impl BlobExt for Blob {
         let blob = self.dupe();
         blob.offset.set(offset);
         blob.size.set(len);
+        // `MAX_SIZE` is the "unbounded" sentinel, so an unbounded slice of an
+        // unresolved file blob is still unbounded.
+        blob.size_is_explicit.set(len != MAX_SIZE);
 
         let content_type_was_allocated = content_type.is_owned() && !content_type.is_empty();
         // infer the content type if it was not specified
@@ -2152,18 +2159,11 @@ impl BlobExt for Blob {
     fn get_last_modified(&self, _: &JSGlobalObject) -> JSValue {
         if let Some(store) = self.store.get() {
             if matches!(store.data, store::Data::File(_)) {
-                // do not hold a pattern-bound `&File` across
-                // `resolve_file_stat` — it materializes `&mut File` on the same
-                // memory (Stacked Borrows UB; the optimizer may legally cache the
-                // pre-call `last_modified` and return the stale `INIT_TIMESTAMP`).
-                // Re-read via `StoreRef::data_mut` (raw-ptr-backed accessor) after
-                // the mutating call.
-                let last_modified = store.data_mut().as_file().last_modified;
-                // last_modified can be already set during read.
-                if last_modified == jsc::INIT_TIMESTAMP && !self.is_s3() {
-                    resolve_file_stat(store);
-                }
-                // Fresh borrow after possible mutation by `resolve_file_stat`.
+                // Always re-stat so `lastModified` reflects the current mtime
+                // instead of a cached snapshot. Do not hold a pattern-bound
+                // `&File` across `resolve_file_stat` (Stacked Borrows UB).
+                resolve_file_stat(store);
+                // Fresh borrow after mutation by `resolve_file_stat`.
                 return JSValue::js_number(JSValue::purify_nan(
                     store.data_mut().as_file().last_modified as f64,
                 ));
@@ -2261,21 +2261,43 @@ impl BlobExt for Blob {
     }
 
     fn get_size(&self, _: &JSGlobalObject) -> JSValue {
+        if let Some(store) = self.store.get() {
+            if matches!(store.data, store::Data::File(_)) {
+                // Always re-stat so `size` reflects the current file size
+                // instead of a cached snapshot.
+                resolve_file_stat(store);
+                let file = store.data_mut().as_file();
+                if file.seekable.is_some() && file.max_size != MAX_SIZE {
+                    let offset = file.max_size.min(self.offset.get());
+                    let available = file.max_size - offset;
+                    // A caller-supplied `slice()` bound is authoritative, but
+                    // still cannot report past EOF.
+                    if self.size_is_explicit.get() {
+                        return JSValue::js_number(available.min(self.size.get()) as f64);
+                    }
+                    // Cache for `get_slice` (negative-index math reads it).
+                    self.size.set(available);
+                    return JSValue::js_number(available as f64);
+                }
+                // Non-seekable (pipe/FIFO/char device) or stat failed. A slice
+                // bound is the only size the caller has, so keep it.
+                if self.size_is_explicit.get() {
+                    return JSValue::js_number(self.size.get() as f64);
+                }
+                if file.seekable == Some(false) {
+                    return JSValue::js_number(f64::INFINITY);
+                }
+                self.size.set(0);
+                return JSValue::js_number(0.0);
+            }
+        }
         if self.size.get() == MAX_SIZE {
             if self.is_s3() {
                 return JSValue::js_number(f64::NAN);
             }
             self.resolve_size();
             if self.size.get() == MAX_SIZE && self.store.get().is_some() {
                 return JSValue::js_number(f64::INFINITY);
-            } else if self.size.get() == 0 && self.store.get().is_some() {
-                if let store::Data::File(file) =
-                    &self.store().expect("infallible: store present").data
-                {
-                    if !file.seekable.unwrap_or(true) && file.max_size == MAX_SIZE {
-                        return JSValue::js_number(f64::INFINITY);
-                    }
-                }
             }
         }
         JSValue::js_number(self.size.get() as f64)
@@ -3339,6 +3361,7 @@ impl BlobExt for Blob {
                                     ),
                                     charset: Cell::new(blob.charset.get()),
                                     is_jsdom_file: Cell::new(blob.is_jsdom_file.get()),
+                                    size_is_explicit: Cell::new(blob.size_is_explicit.get()),
                                     ref_count: bun_ptr::RawRefCount::init(0), // setNotHeapAllocated
                                     global_this: Cell::new(blob.global_this.get()),
                                     last_modified: Cell::new(blob.last_modified.get()),
@@ -4271,6 +4294,7 @@ fn on_structured_clone_deserialize<B: AsRef<[u8]>>(
         // resolve_size() clamps this to the actual file size on first use.
         if size != MAX_SIZE {
             blob.size.set(size as SizeType);
+            blob.size_is_explicit.set(true);
         }
     }
     if let Some(store) = blob.store.get() {
@@ -6184,37 +6208,33 @@ fn resolve_file_stat(store: &StoreRef) {
     // `StoreRef` liveness invariant; the caller holds the only ref across
     // this call, so an exclusive borrow is sound.
     let file = store.data_mut().as_file_mut();
-    match &file.pathlike {
+    let stat = match &file.pathlike {
         PathOrFileDescriptor::Path(path) => {
             let mut buffer = bun_paths::PathBuffer::uninit();
-            match bun_sys::stat(path.slice_z(&mut buffer)) {
-                bun_sys::Result::Ok(stat) => {
-                    file.max_size = if bun_sys::S::ISREG(stat.st_mode as _) || stat.st_size > 0 {
-                        ((stat.st_size.max(0)) as u64) as SizeType
-                    } else {
-                        MAX_SIZE
-                    };
-                    file.mode = stat.st_mode as bun_sys::Mode;
-                    file.seekable = Some(bun_sys::S::ISREG(stat.st_mode as _));
-                    file.last_modified = stat_to_js_mtime(&stat);
-                }
-                // the file may not exist yet. That's okay.
-                _ => {}
-            }
+            bun_sys::stat(path.slice_z(&mut buffer))
+        }
+        PathOrFileDescriptor::Fd(fd) => bun_sys::fstat(*fd),
+    };
+    match stat {
+        bun_sys::Result::Ok(stat) => {
+            file.max_size = if bun_sys::S::ISREG(stat.st_mode as _) || stat.st_size > 0 {
+                ((stat.st_size.max(0)) as u64) as SizeType
+            } else {
+                MAX_SIZE
+            };
+            file.mode = stat.st_mode as bun_sys::Mode;
+            file.seekable = Some(bun_sys::S::ISREG(stat.st_mode as _));
+            file.last_modified = stat_to_js_mtime(&stat);
+        }
+        // The file may not exist (or the fd is invalid). Clear the cached
+        // stat so the JS-facing getters reflect the current state instead
+        // of a past snapshot.
+        _ => {
+            file.max_size = MAX_SIZE;
+            file.mode = 0;
+            file.seekable = None;
+            file.last_modified = jsc::INIT_TIMESTAMP;
         }
-        PathOrFileDescriptor::Fd(fd) => match bun_sys::fstat(*fd) {
-            bun_sys::Result::Ok(stat) => {
-                file.max_size = if bun_sys::S::ISREG(stat.st_mode as _) || stat.st_size > 0 {
-                    ((stat.st_size.max(0)) as u64) as SizeType
-                } else {
-                    MAX_SIZE
-                };
-                file.mode = stat.st_mode as bun_sys::Mode;
-                file.seekable = Some(bun_sys::S::ISREG(stat.st_mode as _));
-                file.last_modified = stat_to_js_mtime(&stat);
-            }
-            _ => {}
-        },
     }
 }
 

test/js/bun/util/bun-file.test.ts

@@ -1,6 +1,7 @@
-import { expect, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
+import fs from "fs";
 import fsPromises from "fs/promises";
-import { bunEnv, bunExe, tempDirWithFiles } from "harness";
+import { bunEnv, bunExe, isPosix, tempDir, tempDirWithFiles } from "harness";
 import { join } from "path";
 
 test("delete() and stat() should work with unicode paths", async () => {
@@ -155,3 +156,87 @@ test("Bun.file().json() with UTF-8 BOM does not free an interior pointer", async
   });
   expect(exitCode).toBe(0);
 });
+
+describe("BunFile exists()/size/lastModified reflect the current filesystem state", () => {
+  test("exists() sees a file deleted after the first call", async () => {
+    using dir = tempDir("bunfile-stat-deleted", {});
+    const p = join(String(dir), "a");
+    fs.writeFileSync(p, "abc");
+    const f = Bun.file(p);
+    expect(await f.exists()).toBe(true);
+    expect(f.size).toBe(3);
+    fs.unlinkSync(p);
+    expect({ exists: await f.exists(), size: f.size, truth: fs.existsSync(p) }).toEqual({
+      exists: false,
+      size: 0,
+      truth: false,
+    });
+  });
+
+  test("exists() sees a file created after the first call, and reads its contents", async () => {
+    using dir = tempDir("bunfile-stat-created", {});
+    const p = join(String(dir), "b");
+    const f = Bun.file(p);
+    expect(await f.exists()).toBe(false);
+    fs.writeFileSync(p, "content");
+    expect({ exists: await f.exists(), size: f.size, text: await f.text() }).toEqual({
+      exists: true,
+      size: 7,
+      text: "content",
+    });
+  });
+
+  test("size and lastModified track changes to the underlying file", async () => {
+    using dir = tempDir("bunfile-stat-changed", {});
+    const p = join(String(dir), "c");
+    fs.writeFileSync(p, "0123456789");
+    const f = Bun.file(p);
+    expect(f.size).toBe(10);
+    const firstMtime = f.lastModified;
+    fs.appendFileSync(p, "0123456789");
+    fs.utimesSync(p, 1000, 2000);
+    expect({ size: f.size, lastModified: f.lastModified }).toEqual({
+      size: fs.statSync(p).size,
+      lastModified: fs.statSync(p).mtimeMs,
+    });
+    expect(f.lastModified).not.toBe(firstMtime);
+  });
+
+  test("polling exists() observes create and delete", async () => {
+    using dir = tempDir("bunfile-stat-poll", {});
+    const p = join(String(dir), "d");
+    const f = Bun.file(p);
+    const seen: boolean[] = [];
+    seen.push(await f.exists());
+    fs.writeFileSync(p, "x");
+    seen.push(await f.exists());
+    fs.unlinkSync(p);
+    seen.push(await f.exists());
+    fs.writeFileSync(p, "y");
+    seen.push(await f.exists());
+    expect(seen).toEqual([false, true, false, true]);
+    expect(await f.text()).toBe("y");
+  });
+
+  test("slice() size is preserved across re-stat", async () => {
+    using dir = tempDir("bunfile-stat-slice", {});
+    const p = join(String(dir), "e");
+    fs.writeFileSync(p, "0123456789");
+    const f = Bun.file(p);
+    const s = f.slice(0, 5);
+    expect(s.size).toBe(5);
+    expect(await s.exists()).toBe(true);
+    fs.appendFileSync(p, "0123456789");
+    expect({ whole: f.size, slice: s.size }).toEqual({ whole: 20, slice: 5 });
+  });
+
+  test("slice() size is preserved for non-seekable and missing files", () => {
+    using dir = tempDir("bunfile-stat-slice-edge", {});
+    // A slice bound must survive a re-stat that cannot produce a regular-file
+    // size: a missing file has no stat, and a char device has no st_size.
+    expect(Bun.file(join(String(dir), "missing")).slice(0, 5).size).toBe(5);
+    if (isPosix) {
+      expect(Bun.file("/dev/null").slice(0, 5).size).toBe(5);
+    }
+  });
+});