Method watchTree

src/sync/watcher.ts:434–498

* Add an inotify watch for `dir` and recurse into its non-ignored * subdirectories. When `markExisting` is true (a directory that appeared * AFTER startup), the source files already inside it are recorded as pending * — this closes the `mkdir + write` race where files created before the new

(dir: string, markExisting: boolean)

   * sync owns the baseline).
   */
  private watchTree(dir: string, markExisting: boolean): void {
    // A degrade() mid-walk (exhaustion on an earlier directory) calls stop(),
    // which sets `stopped`; bail so the recursion unwinds without adding more
    // watches to a watcher that is shutting down. `inotifyLimitWarned` does the
    // same after ENOSPC — the kernel budget is gone, so stop trying the rest of
    // the tree (every add would fail) while keeping the watches already set.
    if (this.stopped || this.degradedReason || this.inotifyLimitWarned) return;
    if (this.dirWatchers.has(dir)) return;
    if (this.dirWatchers.size >= maxDirWatches()) {
      if (!this.dirCapWarned) {
        this.dirCapWarned = true;
        logWarn('File watcher hit directory-watch cap; remaining subtrees rely on manual/periodic sync', {
          cap: maxDirWatches(),
        });
      }
      return;
    }

    let w: fs.FSWatcher;
    try {
      w = watchImpl(dir, { persistent: true }, (_event, filename) =>
        this.handleDirEvent(dir, filename)
      );
    } catch (err) {
      // EMFILE/ENFILE means the PROCESS is out of descriptors — every further
      // directory would fail too, so degrade the whole watcher rather than
      // limping along with a partial watch set.
      if (isWatchResourceExhaustion(err)) {
        this.degrade(EXHAUSTION_REASON, { error: String(err), dir });
      } else if (isInotifyWatchExhaustion(err)) {
        // ENOSPC = inotify watch budget exhausted. NON-fatal: keep the watches
        // we have and tell the user the knob to raise (warn once).
        this.warnInotifyLimit({ error: String(err), dir });
      }
      // ENOENT / EACCES on a single directory stays non-fatal: skip it quietly.
      return;
    }
    w.on('error', (err: unknown) => {
      if (isWatchResourceExhaustion(err)) {
        this.degrade(EXHAUSTION_REASON, { error: String(err), dir });
        return;
      }
      if (isInotifyWatchExhaustion(err)) {
        this.warnInotifyLimit({ error: String(err), dir });
      }
      this.unwatchDir(dir);
    });
    this.dirWatchers.set(dir, w);

    let entries: fs.Dirent[];
    try {
      entries = fs.readdirSync(dir, { withFileTypes: true });
    } catch {
      return;
    }
    for (const entry of entries) {
      const child = path.join(dir, entry.name);
      if (entry.isDirectory()) {