Chokidar reports a "change" event for *all* files when just one file is changed (using Deno)

[MrPixel1]

Describe the bug

Chokinar reports too many events: When a file in the watched directory is changed, Chokinar reports a change for every file.

This causes lots of issues and crashes when used in conjunction with Vite.

I use Deno on Linux.

Directory with some files:

.rw-r--r--  195 app-test.vue
.rw-r--r--  123 chokidar.ts
.rw-r--r--    3 deno.json
.rw-r--r-- 3,2k deno.lock
.rw-r--r--    0 irrelevant.json
.rw-r--r--    0 irrelevant.ts

The file chokidar.ts has the following contents:

import chokidar from "npm:chokidar@4.0.3"; // I changed the version here for different tests
chokidar.watch(".").on("all", (event, path) => {
        console.log(event, path);
});

Start chokidar:

$ deno --allow-env --allow-read chokidar.ts
addDir .
add deno.json
add irrelevant.ts
add irrelevant.json
add app-test.vue
add deno.lock
add chokidar.ts

Then, touch app-test.vue - all good so far:

change app-test.vue

But if I change the file with sed -i 's/test/tset/g' app-test.vue, Chokidar reports a change for all files:

change irrelevant.json
change app-test.vue
change deno.lock
change chokidar.ts
change deno.json
change irrelevant.ts

I also checked out this repository and ran tests. Tests fail at "thirtythree" (as indicated in #1411, not sure if it's related to this problem).

$ deno install
...

$ deno --allow-env --allow-read --unstable-sloppy-imports src/index.test.mts
✅ Granted write access to "/tmp/chokidar-1739094660884".
205 tests started...
chokidar
├─should expose public API methods: ☆
│ should expose public API methods: ✓
├─fs.watch (non-polling)
│ ├─watch a directory
│ │ ├─should produce an instance of chokidar.FSWatcher: ☆
│ │ │ should produce an instance of chokidar.FSWatcher: ✓
│ │ ├─should expose public API methods: ☆
│ │ │ should expose public API methods: ✓
│ │ ├─should emit `add` event when file was added: ☆
│ │ │ should emit `add` event when file was added: ✓
│ │ ├─should emit nine `add` events when nine files were added in one directory: ☆
│ │ │ should emit nine `add` events when nine files were added in one directory: ✓
│ │ ├─should emit thirtythree `add` events when thirtythree files were added in nine directories: ☆
│ │ │ should emit thirtythree `add` events when thirtythree files were added in nine directories: ☓
error: Uncaught (in promise) Error: timeout waitFor, passed ms: 32000
      reject(new Error('timeout waitFor, passed ms: ' + TEST_TIMEOUT));
             ^
    at file:///home/leme/projects/playgrounds/chokidar/src/index.test.mts:171:14
    at callback (ext:deno_web/02_timers.js:58:7)
    at eventLoopTick (ext:core/01_core.js:212:13)

Versions (please complete the following information):

• Chokidar version: 4.0.3, 3.6.0 and 3.0.0 (these are the versions I tested)
• Deno version: 2.1.7
• OS version: Arch Linux

Expected behavior
Just a "change" event for changed files, not for other files.

[43081j]

this is some deno weirdness

basically, if you have this structure:

files/
  foo
  bar
  baz

now set up an fs.watch for all 3 files (not using chokidar).

you'll then observe this:

• echo baz > files/baz, and you'll see a few change events for baz - all good
• use sed on it and you'll get a change/rename - fine

however, if you also watch files/ itself and repeat this, you'll observe the following:

• same as above
• a bunch of renames fire for each of the 3 file listeners! (like { ev: "rename", filename: "sed5gNkGZ" })

but these fire from the watchers setup on the specific files. what's up with that? deno's playing up here, maybe they have a bug

[MrPixel1]

Interesting; I didn't think this would possibly come from Deno. That said, I couldn't reproduce the behavior where Deno claims the other files in the directory have been changed.

With node:fs.watch(), performing an sed:

event type is: rename (sedXpvODP)
event type is: change (sedXpvODP)
event type is: change (sedXpvODP)
event type is: change (sedXpvODP)
event type is: change (sedXpvODP)
event type is: rename (sedXpvODP)
event type is: rename (app-test.vue)
event type is: rename (sedXpvODP)

With Deno.watchFs(), performing an sed:

remove [ "/home/leme/projects/playgrounds/nuxt-playground/test/sedZvMJvZ" ]
remove [ "/home/leme/projects/playgrounds/nuxt-playground/test/sedZvMJvZ" ]
remove [ "/home/leme/projects/playgrounds/nuxt-playground/test/sedZvMJvZ" ]
remove [ "/home/leme/projects/playgrounds/nuxt-playground/test/sedZvMJvZ" ]
remove [ "/home/leme/projects/playgrounds/nuxt-playground/test/sedZvMJvZ" ]
rename [ "/home/leme/projects/playgrounds/nuxt-playground/test/app-test.vue" ]
rename [
  "/home/leme/projects/playgrounds/nuxt-playground/test/sedZvMJvZ",
  "/home/leme/projects/playgrounds/nuxt-playground/test/app-test.vue"
]

That's more events that I'd expect, but I couldn't reproduce the case where events would be reported for the other files in the directory.

Scripts used for testing:

// node-watch.ts
import { watch } from "node:fs";
watch(".", (eventType, filename) => {
        console.log(`event type is: ${eventType} (${filename})`);
});

// deno-watch.ts
const watcher = Deno.watchFs(".");
for await (const event of watcher) {
        console.log(event.kind, event.paths);
}

[43081j]

You're looking for the wrong thing

There isn't an event fired for the other files. Those sed events fire in all watchers even though they're nothing to do with the file we told it to watch

We told it to watch foo in my examples, but it got these sed events that are nothing to do with it.

Chokidar correctly expects the events we receive to be related to the thing we told it to watch. But deno is misbehaving here and giving us events for other files

[MrPixel1]

I understand the additional events for non-existing "sed" files are surprising. But how come Chokidar comes up with this?

$ deno --allow-env --allow-read chokidar.ts
addDir .
add deno.json
add irrelevant.ts
add irrelevant.json
add app-test.vue
add deno.lock
add chokidar.ts
change irrelevant.json
change app-test.vue
change deno.lock
change chokidar.ts
change deno.json
change irrelevant.ts

These do not seem like "sed" files, these are the very files in my directory.

[43081j]

Don't focus on the change events, let me try explain again.

In my example, which certainly reproduces this problem (so it is nothing to do with chokidar), we have three files:

• foo
• bar
• baz

We set up a watcher for each one individually. That is, we ask node (or deno) to watch foo and tell us when it changes. The same for the other two files too.

When you use sed, it causes a few file system events to happen around what's presumably a temp file. This temp file is obviously not what we asked deno to watch. So we don't get those events in our watchers (good!).

However, if you also watch the directory, deno starts misbehaving and sending those temp file events to the 3 original watchers we set up (unrelated to the directory watcher we just added).

But we told deno to watch foo, and here it is giving that watcher's callback events for sed files nothing to do with it.

[MrPixel1]

I'm getting confused, and I'm still unsure as to how Deno would be misbehaving.

That said, I tested with NodeJS, and I get pretty much the same results with the same script. If I watch ., I get a these "sed" files.
If I watch just one file ( watch("app-test.vue", ...) ), I get this, but only once (further changes do not trigger any events):

event type is: change (app-test.vue)
event type is: rename (app-test.vue)
event type is: rename (app-test.vue)

When running the same script with Deno, and performing the same steps, I nearly get the same results (minus one redundant (?) rename event).

event type is: change (app-test.vue)
event type is: rename (app-test.vue)

So, I can't help but conclude that:

• Both Deno and NodeJS fire events for some hidden/temporary files.
• Neither Deno nor NodeJS fires events for untouched files in my directory.
• Chokidar reports file changes to untouched files in my directory.

EDIT: But... I did manage to test Chokidar with NodeJS, and it works well. So the usage of Deno seems to be causing issues in Chokidar...

[43081j]

I'm struggling to find a way to word this in a way you understand.

Forget chokidar and the events you saw for the moment, as this is unrelated to chokidar.

We have 3 files: foo, bar, baz.

We add 3 listeners, watch("./files/foo", listener) and the same for bar and baz.

Regardless of what you now do, whatever file system events you cause, listener will only get events for the file you told it to watch. The foo listener will get events for foo, the bar listener will get events for bar, etc.

Now add a listener for the directory that does nothing, watch("./files", noop).

Now deno (and not node) starts calling foo's listener with events which have nothing to do with foo! And the same with bar's listener. And baz.

Those sed events end up being passed to the foo listener. Which is bad, because we told deno to give us foo events

[lucastonelli]

I'm having a similar issue, but with Vite.

Downgrading to 2.1.1 solves the issue. In 2.1.2, the problem is there:

Video.mp4

Vite uses chokidar as well. It seems it might be related.

[43081j]

yep it isn't anything to do with vite or chokidar

deno seems to be misbehaving with fs watchers. i'll raise an issue on their end in the morning 👍

[lucastonelli]

That would be awesome!