@blamejs/blamejs-shop 0.5.12 → 0.5.14

package/lib/vendor/blamejs/test/layer-0-primitives/watcher.test.js

@@ -308,6 +308,556 @@ async function run() {
   } finally {
     try { fs.rmSync(autoDir, { recursive: true, force: true }); } catch (_e) {}
   }
+
+  // ---- config-time validation: remaining bad-shape opts ----
+  // These surface at create() synchronously — no fs.watch priming needed.
+
+  // root points at a plain file, not a directory → root-not-dir.
+  var fileRootDir = fs.mkdtempSync(path.join(os.tmpdir(), "watcher-filroot-"));
+  try {
+    var fileRoot = path.join(fileRootDir, "iam-a-file.txt");
+    fs.writeFileSync(fileRoot, "not a dir");
+    var threwFR = null;
+    try { b.watcher.create({ root: fileRoot }); } catch (e) { threwFR = e; }
+    check("watcher.create: root that is a file throws root-not-dir",
+      threwFR && threwFR.code === "watcher/root-not-dir");
+  } finally {
+    try { fs.rmSync(fileRootDir, { recursive: true, force: true }); } catch (_e) {}
+  }
+
+  // pollMaxFiles must be a positive finite integer.
+  var threwPMF = null;
+  try { b.watcher.create({ root: os.tmpdir(), pollMaxFiles: 0 }); } catch (e) { threwPMF = e; }
+  check("watcher.create: pollMaxFiles < 1 throws bad-poll-max-files",
+    threwPMF && threwPMF.code === "watcher/bad-poll-max-files");
+
+  threwPMF = null;
+  try { b.watcher.create({ root: os.tmpdir(), pollMaxFiles: "lots" }); } catch (e) { threwPMF = e; }
+  check("watcher.create: non-number pollMaxFiles throws bad-poll-max-files",
+    threwPMF && threwPMF.code === "watcher/bad-poll-max-files");
+
+  // maxPending must be a positive finite number.
+  var threwMP = null;
+  try { b.watcher.create({ root: os.tmpdir(), maxPending: 0 }); } catch (e) { threwMP = e; }
+  check("watcher.create: maxPending < 1 throws bad-max-pending",
+    threwMP && threwMP.code === "watcher/bad-max-pending");
+
+  threwMP = null;
+  try { b.watcher.create({ root: os.tmpdir(), maxPending: Infinity }); } catch (e) { threwMP = e; }
+  check("watcher.create: non-finite maxPending throws bad-max-pending",
+    threwMP && threwMP.code === "watcher/bad-max-pending");
+
+  // onDelete + onError are validated the same way as onChange.
+  var threwHook = null;
+  try { b.watcher.create({ root: os.tmpdir(), onDelete: 42 }); } catch (e) { threwHook = e; }
+  check("watcher.create: non-function onDelete throws bad-hook",
+    threwHook && threwHook.code === "watcher/bad-hook");
+
+  threwHook = null;
+  try { b.watcher.create({ root: os.tmpdir(), onError: {} }); } catch (e) { threwHook = e; }
+  check("watcher.create: non-function onError throws bad-hook",
+    threwHook && threwHook.code === "watcher/bad-hook");
+
+  // ---- ignore-pattern parse-time guards ----
+
+  // A `*` glob whose literal pieces contain a path separator is refused
+  // (path separators only legal in the trailing dir/** prefix form).
+  var threwSep = null;
+  try { b.watcher.create({ root: os.tmpdir(), ignore: ["foo*/bar"] }); } catch (e) { threwSep = e; }
+  check("watcher.create: glob with mid-pattern path separator throws bad-ignore",
+    threwSep && threwSep.code === "watcher/bad-ignore");
+
+  // Pattern length cap.
+  var threwLen = null;
+  var longPat = new Array(300).join("a") + "*";
+  try { b.watcher.create({ root: os.tmpdir(), ignore: [longPat] }); } catch (e) { threwLen = e; }
+  check("watcher.create: over-long ignore pattern throws bad-ignore",
+    threwLen && threwLen.code === "watcher/bad-ignore");
+
+  // Wildcard-count cap (17 stars > MAX_IGNORE_STAR_COUNT of 16).
+  var threwStar = null;
+  try { b.watcher.create({ root: os.tmpdir(), ignore: [new Array(18).join("*") + "x"] }); }
+  catch (e) { threwStar = e; }
+  check("watcher.create: too-many-wildcard ignore pattern throws bad-ignore",
+    threwStar && threwStar.code === "watcher/bad-ignore");
+
+  // Non-string ignore entry (a number in the array) → bad-ignore.
+  var threwEntry = null;
+  try { b.watcher.create({ root: os.tmpdir(), ignore: [123] }); } catch (e) { threwEntry = e; }
+  check("watcher.create: non-string ignore entry throws bad-ignore",
+    threwEntry && threwEntry.code === "watcher/bad-ignore");
+
+  // ---- ignore-pattern matching across all three shapes (poll-driven,
+  // fully deterministic via _flushForTest — no fs.watch priming race) ----
+  var globDir = fs.mkdtempSync(path.join(os.tmpdir(), "watcher-glob-"));
+  try {
+    var globHits = [];
+    var gw = b.watcher.create({
+      root:           globDir,
+      mode:           "poll",
+      pollIntervalMs: 1000,
+      debounceMs:     5,
+      // basename glob (suffix), prefix glob, multi-star glob, exact match.
+      ignore:         ["*.tmp", "cache-*", "a*b*c.dat", "exact-ignore.txt"],
+      onChange:       function (e) { globHits.push(e.relativePath); },
+      audit:          false,
+    });
+    fs.writeFileSync(path.join(globDir, "keep.txt"), "x");           // not ignored → fires
+    fs.writeFileSync(path.join(globDir, "scratch.tmp"), "x");        // *.tmp
+    fs.writeFileSync(path.join(globDir, "cache-abc"), "x");          // cache-*
+    fs.writeFileSync(path.join(globDir, "aXXbYYc.dat"), "x");        // a*b*c.dat
+    fs.writeFileSync(path.join(globDir, "exact-ignore.txt"), "x");   // exact
+    fs.writeFileSync(path.join(globDir, "notcache.txt"), "x");       // NOT cache-* → fires
+    await helpers.waitUntil(function () {
+      gw._flushForTest();
+      return globHits.indexOf("keep.txt") !== -1;
+    }, { label: "watcher glob: keep.txt onChange" });
+
+    check("watcher ignore: non-matching file fires onChange",
+      globHits.indexOf("keep.txt") !== -1 && globHits.indexOf("notcache.txt") !== -1);
+    check("watcher ignore: *.tmp suffix glob suppresses",
+      globHits.indexOf("scratch.tmp") === -1);
+    check("watcher ignore: cache-* prefix glob suppresses",
+      globHits.indexOf("cache-abc") === -1);
+    check("watcher ignore: a*b*c.dat multi-star glob suppresses",
+      globHits.indexOf("aXXbYYc.dat") === -1);
+    check("watcher ignore: exact-match ignore suppresses (poll)",
+      globHits.indexOf("exact-ignore.txt") === -1);
+    gw.stop();
+  } finally {
+    try { fs.rmSync(globDir, { recursive: true, force: true }); } catch (_e) {}
+  }
+
+  // ---- poll: pre-existing files establish the baseline silently ----
+  // Files present at create() must NOT fire onChange on the first tick
+  // (matches fs.watch semantics — you observe changes after start).
+  var baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "watcher-base-"));
+  try {
+    fs.writeFileSync(path.join(baseDir, "pre-existing.txt"), "old");
+    var baseHits = [];
+    var bw = b.watcher.create({
+      root:           baseDir,
+      mode:           "poll",
+      pollIntervalMs: 1000,
+      debounceMs:     5,
+      onChange:       function (e) { baseHits.push(e.relativePath); },
+      audit:          false,
+    });
+    // One tick over an unchanged tree — no events for the baseline file.
+    bw._flushForTest();
+    check("watcher poll: pre-existing file does not fire on first tick",
+      baseHits.indexOf("pre-existing.txt") === -1);
+
+    // A brand-new file after start DOES fire.
+    fs.writeFileSync(path.join(baseDir, "fresh.txt"), "new");
+    await helpers.waitUntil(function () {
+      bw._flushForTest();
+      return baseHits.indexOf("fresh.txt") !== -1;
+    }, { label: "watcher poll: fresh.txt after baseline" });
+    check("watcher poll: post-start create fires onChange", baseHits.indexOf("fresh.txt") !== -1);
+    bw.stop();
+  } finally {
+    try { fs.rmSync(baseDir, { recursive: true, force: true }); } catch (_e) {}
+  }
+
+  // ---- poll: directory create emits type="dir"; nested delete + dir
+  // delete both surface via the snapshot diff ----
+  var dirDir = fs.mkdtempSync(path.join(os.tmpdir(), "watcher-dir-"));
+  try {
+    var dirChanges = [];
+    var dirDeletes = [];
+    var dw = b.watcher.create({
+      root:           dirDir,
+      mode:           "poll",
+      pollIntervalMs: 1000,
+      debounceMs:     5,
+      onChange:       function (e) { dirChanges.push(e); },
+      onDelete:       function (e) { dirDeletes.push(e.relativePath); },
+      audit:          false,
+    });
+    fs.mkdirSync(path.join(dirDir, "created-dir"));
+    fs.writeFileSync(path.join(dirDir, "created-dir", "child.txt"), "x");
+    await helpers.waitUntil(function () {
+      dw._flushForTest();
+      return dirChanges.some(function (e) { return e.relativePath === "created-dir" && e.type === "dir"; });
+    }, { label: "watcher poll: created-dir onChange(type=dir)" });
+    check("watcher poll: directory create fires onChange type='dir'",
+      dirChanges.some(function (e) { return e.relativePath === "created-dir" && e.type === "dir"; }));
+    check("watcher poll: nested child create fires onChange type='file'",
+      dirChanges.some(function (e) { return e.relativePath === "created-dir/child.txt" && e.type === "file"; }));
+
+    // Remove the whole directory subtree → onDelete for both entries.
+    fs.rmSync(path.join(dirDir, "created-dir"), { recursive: true, force: true });
+    await helpers.waitUntil(function () {
+      dw._flushForTest();
+      return dirDeletes.indexOf("created-dir") !== -1;
+    }, { label: "watcher poll: created-dir onDelete" });
+    check("watcher poll: directory delete fires onDelete", dirDeletes.indexOf("created-dir") !== -1);
+    check("watcher poll: nested child delete fires onDelete",
+      dirDeletes.indexOf("created-dir/child.txt") !== -1);
+    dw.stop();
+  } finally {
+    try { fs.rmSync(dirDir, { recursive: true, force: true }); } catch (_e) {}
+  }
+
+  // ---- poll: symlink entries are skipped in the tree walk (never
+  // follow an attacker-controlled link out of root). POSIX only ----
+  if (process.platform !== "win32") {
+    var symDir = fs.mkdtempSync(path.join(os.tmpdir(), "watcher-sym-"));
+    try {
+      var symHits = [];
+      var symW = b.watcher.create({
+        root:           symDir,
+        mode:           "poll",
+        pollIntervalMs: 1000,
+        debounceMs:     5,
+        onChange:       function (e) { symHits.push(e.relativePath); },
+        audit:          false,
+      });
+      var symlinkMade = false;
+      try {
+        fs.symlinkSync(os.tmpdir(), path.join(symDir, "link-out"));
+        symlinkMade = true;
+      } catch (_e) { /* some sandboxes refuse symlink even on POSIX */ }
+      // Also drop a real file so we have a positive control that the
+      // tick ran and delivered SOMETHING.
+      fs.writeFileSync(path.join(symDir, "real.txt"), "x");
+      await helpers.waitUntil(function () {
+        symW._flushForTest();
+        return symHits.indexOf("real.txt") !== -1;
+      }, { label: "watcher poll: real.txt control" });
+      if (symlinkMade) {
+        check("watcher poll: symlink entry skipped in walk",
+          symHits.indexOf("link-out") === -1);
+      } else {
+        check("watcher poll: symlink entry skipped (skipped — symlink unavailable)", true);
+      }
+      symW.stop();
+    } finally {
+      try { fs.rmSync(symDir, { recursive: true, force: true }); } catch (_e) {}
+    }
+  }
+
+  // ---- maxPending overflow: too many distinct pending paths trips the
+  // safety net → onError(watcher/overflow) + self-stop, dropping further
+  // events. Deterministic via the synchronous poll tick ----
+  var ovDir = fs.mkdtempSync(path.join(os.tmpdir(), "watcher-ov-"));
+  try {
+    var ovErrs = [];
+    var ovHits = [];
+    var ow = b.watcher.create({
+      root:           ovDir,
+      mode:           "poll",
+      pollIntervalMs: 1000,
+      debounceMs:     5,
+      maxPending:     2,
+      onChange:       function (e) { ovHits.push(e.relativePath); },
+      onError:        function (e) { ovErrs.push(e); },
+      audit:          false,
+    });
+    // Create more distinct new files than maxPending in a single tick.
+    for (var oi = 0; oi < 5; oi += 1) {
+      fs.writeFileSync(path.join(ovDir, "ov-" + oi + ".txt"), "x");
+    }
+    ow._flushForTest();   // one synchronous tick enqueues → overflow
+    check("watcher: maxPending overflow surfaces onError(watcher/overflow)",
+      ovErrs.some(function (e) { return e && e.code === "watcher/overflow"; }));
+
+    // Post-overflow the watcher self-stopped; a later change is dropped.
+    ovHits.length = 0;
+    fs.writeFileSync(path.join(ovDir, "after-stop.txt"), "x");
+    ow._flushForTest();
+    check("watcher: overflow self-stops — later events dropped",
+      ovHits.indexOf("after-stop.txt") === -1);
+    ow.stop();   // idempotent after self-stop
+  } finally {
+    try { fs.rmSync(ovDir, { recursive: true, force: true }); } catch (_e) {}
+  }
+
+  // ---- poll: running-tick pollMaxFiles overflow routes through onError
+  // (distinct from the create()-time initial-walk overflow tested above,
+  // which throws watcher/start-failed) ----
+  var tickCapDir = fs.mkdtempSync(path.join(os.tmpdir(), "watcher-tickcap-"));
+  try {
+    var tickErrs = [];
+    var tw = b.watcher.create({
+      root:           tickCapDir,   // starts empty → initial walk under cap
+      mode:           "poll",
+      pollIntervalMs: 1000,
+      pollMaxFiles:   1,
+      onChange:       function () {},
+      onError:        function (e) { tickErrs.push(e); },
+      audit:          false,
+    });
+    // Now blow past the cap so the NEXT tick's walk throws.
+    fs.writeFileSync(path.join(tickCapDir, "t1.txt"), "x");
+    fs.writeFileSync(path.join(tickCapDir, "t2.txt"), "x");
+    tw._flushForTest();
+    check("watcher poll: running-tick pollMaxFiles overflow surfaces onError(poll-overflow)",
+      tickErrs.some(function (e) { return e && e.code === "watcher/poll-overflow"; }));
+    tw.stop();
+  } finally {
+    try { fs.rmSync(tickCapDir, { recursive: true, force: true }); } catch (_e) {}
+  }
+
+  // ---- operator hooks that throw must not crash dispatch ----
+  var throwDir = fs.mkdtempSync(path.join(os.tmpdir(), "watcher-throw-"));
+  try {
+    var afterChange = [];
+    var thw = b.watcher.create({
+      root:           throwDir,
+      mode:           "poll",
+      pollIntervalMs: 1000,
+      debounceMs:     5,
+      onChange:       function (e) {
+        afterChange.push(e.relativePath);
+        throw new Error("operator onChange blew up");
+      },
+      onDelete:       function () { throw new Error("operator onDelete blew up"); },
+      audit:          false,
+    });
+    fs.writeFileSync(path.join(throwDir, "boom.txt"), "x");
+    await helpers.waitUntil(function () {
+      thw._flushForTest();
+      return afterChange.indexOf("boom.txt") !== -1;
+    }, { label: "watcher: throwing onChange still dispatched" });
+    check("watcher: throwing onChange hook does not crash dispatch",
+      afterChange.indexOf("boom.txt") !== -1);
+
+    // A second, distinct change still dispatches (proves dispatch loop
+    // survived the earlier throw).
+    fs.writeFileSync(path.join(throwDir, "boom2.txt"), "x");
+    await helpers.waitUntil(function () {
+      thw._flushForTest();
+      return afterChange.indexOf("boom2.txt") !== -1;
+    }, { label: "watcher: dispatch survives prior hook throw" });
+    check("watcher: dispatch continues after a hook throw",
+      afterChange.indexOf("boom2.txt") !== -1);
+
+    // Deleting the file drives the throwing onDelete — must not crash.
+    fs.unlinkSync(path.join(throwDir, "boom.txt"));
+    var delThrewCrash = false;
+    try {
+      await helpers.waitUntil(function () {
+        thw._flushForTest();
+        // We can't observe onDelete's arg (it throws), but reaching here
+        // without an unhandled exception is the assertion.
+        return true;
+      }, { label: "watcher: throwing onDelete tolerated", timeoutMs: 1000 });
+    } catch (_e) { delThrewCrash = true; }
+    check("watcher: throwing onDelete hook does not crash dispatch", !delThrewCrash);
+    thw.stop();
+  } finally {
+    try { fs.rmSync(throwDir, { recursive: true, force: true }); } catch (_e) {}
+  }
+
+  // ---- onError hook that itself throws must not crash the watcher ----
+  // Drive the overflow path with an onError that throws; _safeError wraps
+  // the operator callback in try/catch so the throw is swallowed.
+  var errThrowDir = fs.mkdtempSync(path.join(os.tmpdir(), "watcher-errthrow-"));
+  try {
+    var reachedAfter = false;
+    var ew = b.watcher.create({
+      root:           errThrowDir,
+      mode:           "poll",
+      pollIntervalMs: 1000,
+      debounceMs:     5,
+      maxPending:     1,
+      onChange:       function () {},
+      onError:        function () { throw new Error("operator onError blew up"); },
+      audit:          false,
+    });
+    fs.writeFileSync(path.join(errThrowDir, "e1.txt"), "x");
+    fs.writeFileSync(path.join(errThrowDir, "e2.txt"), "x");
+    fs.writeFileSync(path.join(errThrowDir, "e3.txt"), "x");
+    ew._flushForTest();   // overflow → _safeError → onError throws → swallowed
+    reachedAfter = true;
+    check("watcher: throwing onError hook does not crash the watcher", reachedAfter);
+    ew.stop();
+  } finally {
+    try { fs.rmSync(errThrowDir, { recursive: true, force: true }); } catch (_e) {}
+  }
+
+  // ---- debounce: one observed change produces exactly one dispatch, and
+  // a same-tick modification (size/mtime delta) re-fires on the next tick ----
+  var coalDir = fs.mkdtempSync(path.join(os.tmpdir(), "watcher-coal-"));
+  try {
+    var coalCount = 0;
+    var cw = b.watcher.create({
+      root:           coalDir,
+      mode:           "poll",
+      pollIntervalMs: 1000,
+      debounceMs:     5,
+      onChange:       function (e) { if (e.relativePath === "c.txt") coalCount += 1; },
+      audit:          false,
+    });
+    cw._flushForTest();          // baseline (empty tree)
+    coalCount = 0;
+
+    fs.writeFileSync(path.join(coalDir, "c.txt"), "one");
+    await helpers.waitUntil(function () {
+      cw._flushForTest();
+      return coalCount >= 1;
+    }, { label: "watcher debounce: c.txt first dispatch" });
+    check("watcher: a single observed change dispatches exactly one onChange",
+      coalCount === 1);
+
+    // No further change → no further dispatch across extra ticks (the
+    // snapshot diff is empty, so nothing re-enqueues).
+    cw._flushForTest();
+    cw._flushForTest();
+    check("watcher: an unchanged tree re-tick fires no onChange", coalCount === 1);
+
+    // A real modification (content grows → size + mtime differ) re-fires.
+    fs.writeFileSync(path.join(coalDir, "c.txt"), "one-two-three");
+    await helpers.waitUntil(function () {
+      cw._flushForTest();
+      return coalCount >= 2;
+    }, { label: "watcher debounce: c.txt modify re-dispatch" });
+    check("watcher: a subsequent modification re-fires onChange", coalCount === 2);
+    cw.stop();
+  } finally {
+    try { fs.rmSync(coalDir, { recursive: true, force: true }); } catch (_e) {}
+  }
+
+  // ---- #505: ignore-pattern caps are exported so a consumer pre-filtering
+  // operator patterns aligns with what create() enforces, instead of pinning
+  // hand-copied mirror constants that silently drift on an upstream refresh ----
+  check("watcher: MAX_IGNORE_PATTERN_LEN exported and matches the enforced cap",
+    typeof b.watcher.MAX_IGNORE_PATTERN_LEN === "number" &&
+    b.watcher.MAX_IGNORE_PATTERN_LEN === 256);
+  check("watcher: MAX_IGNORE_STAR_COUNT exported and matches the enforced cap",
+    typeof b.watcher.MAX_IGNORE_STAR_COUNT === "number" &&
+    b.watcher.MAX_IGNORE_STAR_COUNT === 16);
+  // The exported caps must actually gate create() (a pattern one under the cap
+  // is accepted; one over is refused) so a pre-filter that trusts them agrees.
+  var underCap = new Array(b.watcher.MAX_IGNORE_PATTERN_LEN).join("a") + "*"; // len = cap
+  var overCap  = new Array(b.watcher.MAX_IGNORE_PATTERN_LEN + 2).join("a") + "*";
+  var threwUnder = null, threwOver = null;
+  try { var uw = b.watcher.create({ root: os.tmpdir(), ignore: [underCap], onChange: function () {} }); uw.stop(); }
+  catch (e) { threwUnder = e; }
+  try { b.watcher.create({ root: os.tmpdir(), ignore: [overCap], onChange: function () {} }); }
+  catch (e) { threwOver = e; }
+  check("watcher: pattern at the exported length cap is accepted",
+    threwUnder === null);
+  check("watcher: pattern over the exported length cap is refused",
+    threwOver && threwOver.code === "watcher/bad-ignore");
+
+  // ---- #508: ignoreCaseFold folds the walk-prune identically to a
+  // case-insensitive consumer's own filter, so an on-disk 'Node_Modules' is
+  // pruned by a 'node_modules/**' ignore (else the walk stats the whole
+  // subtree toward pollMaxFiles and can overflow into the degraded state) ----
+  var cfDir = fs.mkdtempSync(path.join(os.tmpdir(), "watcher-casefold-"));
+  try {
+    var cfHits = [];
+    var cfW = b.watcher.create({
+      root:           cfDir,
+      mode:           "poll",
+      pollIntervalMs: 1000,
+      debounceMs:     5,
+      ignore:         ["node_modules/**", "*.log", "exact-ignore.txt"],
+      ignoreCaseFold: true,
+      onChange:       function (e) { cfHits.push(e.relativePath); },
+      audit:          false,
+    });
+    fs.mkdirSync(path.join(cfDir, "Node_Modules"));
+    fs.writeFileSync(path.join(cfDir, "Node_Modules", "pkg.js"), "x"); // prefix ignore, case-folded
+    fs.writeFileSync(path.join(cfDir, "App.LOG"), "x");                // glob ignore, case-folded
+    fs.writeFileSync(path.join(cfDir, "Exact-Ignore.TXT"), "x");       // exact ignore, case-folded
+    fs.writeFileSync(path.join(cfDir, "keep.txt"), "x");               // NOT ignored → fires (control)
+    await helpers.waitUntil(function () {
+      cfW._flushForTest();
+      return cfHits.indexOf("keep.txt") !== -1;
+    }, { label: "watcher casefold: keep.txt control" });
+    check("watcher ignoreCaseFold: case-different dir pruned by prefix ignore",
+      cfHits.indexOf("Node_Modules/pkg.js") === -1);
+    check("watcher ignoreCaseFold: case-different basename pruned by glob ignore",
+      cfHits.indexOf("App.LOG") === -1);
+    check("watcher ignoreCaseFold: case-different name pruned by exact ignore",
+      cfHits.indexOf("Exact-Ignore.TXT") === -1);
+    cfW.stop();
+  } finally {
+    try { fs.rmSync(cfDir, { recursive: true, force: true }); } catch (_e) {}
+  }
+  // ...and case-fold is opt-in: without it, a case-different name is NOT pruned
+  // (default stays case-sensitive so existing consumers are unaffected).
+  var csDir = fs.mkdtempSync(path.join(os.tmpdir(), "watcher-casesens-"));
+  try {
+    var csHits = [];
+    var csW = b.watcher.create({
+      root: csDir, mode: "poll", pollIntervalMs: 1000, debounceMs: 5,
+      ignore: ["node_modules/**"],
+      onChange: function (e) { csHits.push(e.relativePath); }, audit: false,
+    });
+    fs.mkdirSync(path.join(csDir, "Node_Modules"));
+    fs.writeFileSync(path.join(csDir, "Node_Modules", "pkg.js"), "x");
+    await helpers.waitUntil(function () {
+      csW._flushForTest();
+      return csHits.indexOf("Node_Modules/pkg.js") !== -1;
+    }, { label: "watcher case-sensitive default: Node_Modules NOT pruned" });
+    check("watcher: default (no ignoreCaseFold) stays case-sensitive",
+      csHits.indexOf("Node_Modules/pkg.js") !== -1);
+    csW.stop();
+  } finally {
+    try { fs.rmSync(csDir, { recursive: true, force: true }); } catch (_e) {}
+  }
+
+  // ---- #506: a lost ROOT (unmounted volume / deleted root) surfaces a
+  // DISTINCT root-lost signal, not an empty snapshot that diffs as a delete of
+  // every tracked entry (a mass-delete a consumer can't distinguish from a real
+  // rm -rf) ----
+  var rlDir = fs.mkdtempSync(path.join(os.tmpdir(), "watcher-rootlost-"));
+  var rlDeletes = [];
+  var rlErrs = [];
+  var rlW = b.watcher.create({
+    root:           rlDir,
+    mode:           "poll",
+    pollIntervalMs: 1000,
+    debounceMs:     5,
+    onChange:       function () {},
+    onDelete:       function (e) { rlDeletes.push(e.relativePath); },
+    onError:        function (e) { rlErrs.push(e); },
+    audit:          false,
+  });
+  fs.writeFileSync(path.join(rlDir, "one.txt"), "x");
+  fs.writeFileSync(path.join(rlDir, "two.txt"), "x");
+  rlW._flushForTest();          // baseline snapshot: one.txt, two.txt
+  rlDeletes.length = 0;
+  // Remove the ROOT out from under the watcher (models an unmounted volume).
+  fs.rmSync(rlDir, { recursive: true, force: true });
+  rlW._flushForTest();          // tick over an unreadable root
+  check("watcher: a lost root surfaces watcher/root-lost via onError",
+    rlErrs.some(function (e) { return e && e.code === "watcher/root-lost"; }));
+  check("watcher: a lost root does NOT mass-delete every tracked entry",
+    rlDeletes.indexOf("one.txt") === -1 && rlDeletes.indexOf("two.txt") === -1);
+  rlW.stop();
+
+  // ---- #507: a dead native FSWatcher handle (EPERM after the watched root is
+  // deleted/recreated on Windows) is classified FATAL, so a wrapper can tell
+  // change detection has permanently stopped rather than treating it as a
+  // transient blip ----
+  var hdDir = fs.mkdtempSync(path.join(os.tmpdir(), "watcher-handledead-"));
+  try {
+    var hdErrs = [];
+    var hdW = b.watcher.create({
+      root:     hdDir,
+      mode:     "fs",
+      onChange: function () {},
+      onError:  function (e) { hdErrs.push(e); },
+      audit:    false,
+    });
+    // Drive the native-backend error path via the test seam (the real trigger —
+    // the OS killing the handle — isn't deterministically reproducible).
+    var eperm = new Error("EPERM: operation not permitted, watch"); eperm.code = "EPERM";
+    hdW._simulateBackendErrorForTest(eperm);
+    check("watcher: a handle-dead backend error is classified fatal for consumers",
+      hdErrs.some(function (e) { return e && e.fatal === true && e.code === "watcher/handle-dead"; }));
+    check("watcher: the classified handle-dead error carries the underlying cause",
+      hdErrs.some(function (e) { return e && e.cause && e.cause.code === "EPERM"; }));
+    hdW.stop();
+  } finally {
+    try { fs.rmSync(hdDir, { recursive: true, force: true }); } catch (_e) {}
+  }
 }
 
 module.exports = { run: run };