fix: handle DT_UNKNOWN in dir_iterator for bind-mounted filesystems

src/bun.js/node/dir_iterator.zig

@@ -162,14 +162,17 @@ pub fn NewIterator(comptime use_windows_ospath: bool) type {
                         continue :start_over;
                     }
 
-                    const entry_kind = switch (linux_entry.type) {
+                    const entry_kind: Entry.Kind = switch (linux_entry.type) {
                         linux.DT.BLK => Entry.Kind.block_device,
                         linux.DT.CHR => Entry.Kind.character_device,
                         linux.DT.DIR => Entry.Kind.directory,
                         linux.DT.FIFO => Entry.Kind.named_pipe,
                         linux.DT.LNK => Entry.Kind.sym_link,
                         linux.DT.REG => Entry.Kind.file,
                         linux.DT.SOCK => Entry.Kind.unix_domain_socket,
+                        // DT_UNKNOWN: Some filesystems (e.g., bind mounts, FUSE, NFS)
+                        // don't provide d_type. Callers should use lstatat() to determine
+                        // the type when needed (lazy stat pattern for performance).
                         else => Entry.Kind.unknown,
                     };
                     return .{

src/bun.js/node/node_fs.zig

@@ -4627,6 +4627,9 @@ pub const NodeFS = struct {
                 break :brk bun.path.joinZBuf(buf, &path_parts, .auto);
             };
 
+            // Track effective kind - may be resolved from .unknown via stat
+            var effective_kind = current.kind;
+
             enqueue: {
                 switch (current.kind) {
                     // a symlink might be a directory or might not be
@@ -4646,6 +4649,24 @@ pub const NodeFS = struct {
 
                         async_task.enqueue(name_to_copy);
                     },
+                    // Some filesystems (e.g., Docker bind mounts, FUSE, NFS) return
+                    // DT_UNKNOWN for d_type. Use lstatat to determine the actual type.
+                    .unknown => {
+                        if (current.name.len + 1 + name_to_copy.len > bun.MAX_PATH_BYTES) break :enqueue;
+
+                        // Lazy stat to determine the actual kind (lstatat to not follow symlinks)
+                        const stat_result = bun.sys.lstatat(fd, current.name.sliceAssumeZ());
+                        switch (stat_result) {
+                            .result => |st| {
+                                const real_kind = bun.sys.kindFromMode(st.mode);
+                                effective_kind = real_kind;
+                                if (real_kind == .directory or real_kind == .sym_link) {
+                                    async_task.enqueue(name_to_copy);
+                                }
+                            },
+                            .err => {}, // Skip entries we can't stat
+                        }
+                    },
                     else => {},
                 }
             }
@@ -4662,7 +4683,7 @@ pub const NodeFS = struct {
                     entries.append(.{
                         .name = bun.String.cloneUTF8(utf8_name),
                         .path = dirent_path_prev,
-                        .kind = current.kind,
+                        .kind = effective_kind,
                     }) catch |err| bun.handleOom(err);
                 },
                 Buffer => {
@@ -4774,6 +4795,9 @@ pub const NodeFS = struct {
                     break :brk bun.path.joinZBuf(buf, &path_parts, .auto);
                 };
 
+                // Track effective kind - may be resolved from .unknown via stat
+                var effective_kind = current.kind;
+
                 enqueue: {
                     switch (current.kind) {
                         // a symlink might be a directory or might not be
@@ -4786,6 +4810,24 @@ pub const NodeFS = struct {
                             if (current.name.len + 1 + name_to_copy.len > bun.MAX_PATH_BYTES) break :enqueue;
                             stack.writeItem(basename_allocator.dupeZ(u8, name_to_copy) catch break :enqueue) catch break :enqueue;
                         },
+                        // Some filesystems (e.g., Docker bind mounts, FUSE, NFS) return
+                        // DT_UNKNOWN for d_type. Use lstatat to determine the actual type.
+                        .unknown => {
+                            if (current.name.len + 1 + name_to_copy.len > bun.MAX_PATH_BYTES) break :enqueue;
+
+                            // Lazy stat to determine the actual kind (lstatat to not follow symlinks)
+                            const stat_result = bun.sys.lstatat(fd, current.name.sliceAssumeZ());
+                            switch (stat_result) {
+                                .result => |st| {
+                                    const real_kind = bun.sys.kindFromMode(st.mode);
+                                    effective_kind = real_kind;
+                                    if (real_kind == .directory or real_kind == .sym_link) {
+                                        stack.writeItem(basename_allocator.dupeZ(u8, name_to_copy) catch break :enqueue) catch break :enqueue;
+                                    }
+                                },
+                                .err => {}, // Skip entries we can't stat
+                            }
+                        },
                         else => {},
                     }
                 }
@@ -4801,7 +4843,7 @@ pub const NodeFS = struct {
                         entries.append(.{
                             .name = jsc.WebCore.encoding.toBunString(utf8_name, args.encoding),
                             .path = dirent_path_prev,
-                            .kind = current.kind,
+                            .kind = effective_kind,
                         }) catch |err| bun.handleOom(err);
                     },
                     Buffer => {

src/glob/GlobWalker.zig

@@ -154,6 +154,12 @@ pub const SyscallAccessor = struct {
         };
     }
 
+    /// Like statat but does not follow symlinks.
+    pub fn lstatat(handle: Handle, path: [:0]const u8) Maybe(bun.Stat) {
+        if (comptime bun.Environment.isWindows) return statatWindows(handle.value, path);
+        return Syscall.lstatat(handle.value, path);
+    }
+
     pub fn openat(handle: Handle, path: [:0]const u8) !Maybe(Handle) {
         return switch (Syscall.openat(handle.value, path, bun.O.DIRECTORY | bun.O.RDONLY, 0)) {
             .err => |err| .{ .err = err },
@@ -247,6 +253,20 @@ pub const DirEntryAccessor = struct {
         return Syscall.stat(path);
     }
 
+    /// Like statat but does not follow symlinks.
+    pub fn lstatat(handle: Handle, path_: [:0]const u8) Maybe(bun.Stat) {
+        var path: [:0]const u8 = path_;
+        var buf: bun.PathBuffer = undefined;
+        if (!bun.path.Platform.auto.isAbsolute(path)) {
+            if (handle.value) |entry| {
+                const slice = bun.path.joinStringBuf(&buf, [_][]const u8{ entry.dir, path }, .auto);
+                buf[slice.len] = 0;
+                path = buf[0..slice.len :0];
+            }
+        }
+        return Syscall.lstat(path);
+    }
+
     pub fn open(path: [:0]const u8) !Maybe(Handle) {
         return openat(.empty, path);
     }
@@ -902,6 +922,93 @@ pub fn GlobWalker_(
 
                                     continue;
                                 },
+                                // Some filesystems (e.g., Docker bind mounts, FUSE, NFS) return
+                                // DT_UNKNOWN for d_type. Use lazy stat to determine the real kind
+                                // only when needed (PR #18172 pattern for performance).
+                                .unknown => {
+                                    // First check if name might match pattern (avoid unnecessary stat)
+                                    const might_match = this.walker.matchPatternImpl(dir_iter_state.pattern, entry_name);
+                                    if (!might_match) continue;
+
+                                    // Need to stat to determine actual kind (lstatat to not follow symlinks)
+                                    // Use stack fallback for short names (typical case) to avoid arena allocation
+                                    const stackbuf_size = 256;
+                                    var stfb = std.heap.stackFallback(stackbuf_size, this.walker.arena.allocator());
+                                    const name_z = stfb.get().dupeZ(u8, entry_name) catch bun.outOfMemory();
+                                    const stat_result = Accessor.lstatat(dir.fd, name_z);
+                                    const real_kind: std.fs.File.Kind = switch (stat_result) {
+                                        .result => |st| bun.sys.kindFromMode(st.mode),
+                                        .err => continue, // Skip entries we can't stat
+                                    };
+
+                                    // Process based on actual kind
+                                    switch (real_kind) {
+                                        .file => {
+                                            const matches = this.walker.matchPatternFile(entry_name, dir_iter_state.component_idx, dir.is_last, dir_iter_state.pattern, dir_iter_state.next_pattern);
+                                            if (matches) {
+                                                const prepared = try this.walker.prepareMatchedPath(entry_name, dir.dir_path) orelse continue;
+                                                return .{ .result = prepared };
+                                            }
+                                        },
+                                        .directory => {
+                                            var add_dir: bool = false;
+                                            const recursion_idx_bump_ = this.walker.matchPatternDir(dir_iter_state.pattern, dir_iter_state.next_pattern, entry_name, dir_iter_state.component_idx, dir_iter_state.is_last, &add_dir);
+
+                                            if (recursion_idx_bump_) |recursion_idx_bump| {
+                                                const subdir_parts: []const []const u8 = &[_][]const u8{
+                                                    dir.dir_path[0..dir.dir_path.len],
+                                                    entry_name,
+                                                };
+
+                                                const subdir_entry_name = try this.walker.join(subdir_parts);
+
+                                                if (recursion_idx_bump == 2) {
+                                                    try this.walker.workbuf.append(
+                                                        this.walker.arena.allocator(),
+                                                        WorkItem.new(subdir_entry_name, dir_iter_state.component_idx + recursion_idx_bump, .directory),
+                                                    );
+                                                    try this.walker.workbuf.append(
+                                                        this.walker.arena.allocator(),
+                                                        WorkItem.new(subdir_entry_name, dir_iter_state.component_idx, .directory),
+                                                    );
+                                                } else {
+                                                    try this.walker.workbuf.append(
+                                                        this.walker.arena.allocator(),
+                                                        WorkItem.new(subdir_entry_name, dir_iter_state.component_idx + recursion_idx_bump, .directory),
+                                                    );
+                                                }
+                                            }
+
+                                            if (add_dir and !this.walker.only_files) {
+                                                const prepared_path = try this.walker.prepareMatchedPath(entry_name, dir.dir_path) orelse continue;
+                                                return .{ .result = prepared_path };
+                                            }
+                                        },
+                                        .sym_link => {
+                                            if (this.walker.follow_symlinks) {
+                                                const subdir_parts: []const []const u8 = &[_][]const u8{
+                                                    dir.dir_path[0..dir.dir_path.len],
+                                                    entry_name,
+                                                };
+                                                const entry_start: u32 = @intCast(if (dir.dir_path.len == 0) 0 else dir.dir_path.len + 1);
+                                                const subdir_entry_name = try this.walker.join(subdir_parts);
+
+                                                try this.walker.workbuf.append(
+                                                    this.walker.arena.allocator(),
+                                                    WorkItem.newSymlink(subdir_entry_name, dir_iter_state.component_idx, entry_start),
+                                                );
+                                            } else if (!this.walker.only_files) {
+                                                const matches = this.walker.matchPatternFile(entry_name, dir_iter_state.component_idx, dir_iter_state.is_last, dir_iter_state.pattern, dir_iter_state.next_pattern);
+                                                if (matches) {
+                                                    const prepared_path = try this.walker.prepareMatchedPath(entry_name, dir.dir_path) orelse continue;
+                                                    return .{ .result = prepared_path };
+                                                }
+                                            }
+                                        },
+                                        else => {}, // Skip other types (block devices, etc.)
+                                    }
+                                    continue;
+                                },
                                 else => continue,
                             }
                         },

src/sys.zig

@@ -744,6 +744,29 @@ pub fn fstatat(fd: bun.FileDescriptor, path: [:0]const u8) Maybe(bun.Stat) {
     return Maybe(bun.Stat){ .result = stat_buf };
 }
 
+/// Like fstatat but does not follow symlinks (uses AT.SYMLINK_NOFOLLOW).
+/// This is the "at" equivalent of lstat.
+pub fn lstatat(fd: bun.FileDescriptor, path: [:0]const u8) Maybe(bun.Stat) {
+    if (Environment.isWindows) {
+        // Use O.NOFOLLOW to not follow symlinks (FILE_OPEN_REPARSE_POINT on Windows)
+        return switch (openatWindowsA(fd, path, O.NOFOLLOW, 0)) {
+            .result => |file| {
+                defer file.close();
+                return fstat(file);
+            },
+            .err => |err| Maybe(bun.Stat){ .err = err },
+        };
+    }
+    var stat_buf = mem.zeroes(bun.Stat);
+    const fd_valid = if (fd == bun.invalid_fd) std.posix.AT.FDCWD else fd.native();
+    if (Maybe(bun.Stat).errnoSysFP(syscall.fstatat(fd_valid, path, &stat_buf, std.posix.AT.SYMLINK_NOFOLLOW), .fstatat, fd, path)) |err| {
+        log("lstatat({f}, {s}) = {s}", .{ fd, path, @tagName(err.getErrno()) });
+        return err;
+    }
+    log("lstatat({f}, {s}) = 0", .{ fd, path });
+    return Maybe(bun.Stat){ .result = stat_buf };
+}
+
 pub fn mkdir(file_path: [:0]const u8, flags: mode_t) Maybe(void) {
     return switch (Environment.os) {
         .mac => Maybe(void).errnoSysP(syscall.mkdir(file_path, flags), .mkdir, file_path) orelse .success,