@@ -38,12 +38,17 @@ import { waitFor } from './fixtures/waitFor';
  * off the machine — the store takes it from the root's own spelling (separatorOf). A root spelled `\cmp-root`,
  * with no drive, as `path.join(path.sep, …)` spells it on Windows, is no Windows scan's root: separatorOf reads it
  * as a POSIX path, the store joins its children with "/", and no child spelled with "\" is found in it (the
- * Windows leg of 25 Oct 2026 failed every test here with "PackedScanStore: no node -1").
+ * Windows leg of 25 Oct 2026 failed each test here that looks a path up, with "PackedScanStore: no node -1").
+ * A scan of a whole drive, or of a Windows share, is rooted at a path that already ends in its separator, which the
+ * store joins without adding another: those roots are spelled here too.
  */
 interface Spelling { name: string; p: path.PlatformPath; root: string }
 const SPELLINGS: readonly Spelling[] = [
   { name: 'spelled as a Mac or Linux scan spells it', p: path.posix, root: '/cmp-root' },
   { name: 'spelled as a Windows scan spells it', p: path.win32, root: 'C:\\cmp-root' },
+  { name: 'a Mac or Linux scan of the whole drive', p: path.posix, root: '/' },
+  { name: 'a Windows scan of a whole drive', p: path.win32, root: 'C:\\' },
+  { name: 'a Windows scan of a share', p: path.win32, root: '\\\\srv\\share\\' },
 ];
 
 /** A complete scan of the spelling's root holding `tree` (relative path → bytes, a trailing / for a folder). */
@@ -73,8 +78,14 @@ function scanOf(s: Spelling, tree: Record<string, number>, unlisted: string[] =
 
 const MAIL = { 'Mail/': 0, 'Mail/msg-0.emlx': 4000, 'Mail/msg-1.emlx': 4000, 'Mail/msg-2.emlx': 4000 };
 /** Each entry as "<path under the root, with / between names> <change>", whatever separator the scan spelled it with. */
-const rows = (s: Spelling, r: { entries: { path: string; change: string }[] }): string[] =>
-  r.entries.map((e) => `${s.p.relative(s.root, e.path).split(s.p.sep).join('/')} ${e.change}`).sort();
+const rows = (s: Spelling, r: { entries: { path: string; change: string }[] }): string[] => {
+  // Read off each path exactly as the store spelled it: path.relative would read a doubled separator away.
+  const base = s.root.endsWith(s.p.sep) ? s.root : s.root + s.p.sep;
+  return r.entries.map((e) => {
+    assert.ok(e.path.startsWith(base), `${s.name}: ${e.path} is spelled under ${base}`);
+    return `${e.path.slice(base.length).split(s.p.sep).join('/')} ${e.change}`;
+  }).sort();
+};
 
 test('files in a folder the newer scan could not list are not called removed, and the folder is counted', () => {
   for (const s of SPELLINGS) {
 
@@ -2078,7 +2078,10 @@ const noop = () => {};
  * `real`, each one's own object lifted, its mount and unmount with it — and `standIns`, which mount nothing and have
  * no unmount. Each view's section holds its live regions as the markup has them; every other live region stands in
  * the page's main part, on screen. Every view starts hidden. `decls`, `given` and `missing` as page() takes them; a
- * frame as waitingPage runs one.
+ * frame as waitingPage runs one. Every switch and every frame checks that the registry caught nothing from a view's
+ * own mount, unmount or onScanChange: it logs such an error and goes on (020), so a name the harness did not give
+ * threw there unseen and the rest of that view's code never ran (the Treemap view's unmount, until 25 Oct 2026,
+ * stopped at `tmLoadSeq++` on every leg of CI).
  */
 function viewsPage(real: string[], standIns: string[], decls: string[] = [], given: Record<string, unknown> = {}, missing: string[] = []) {
   const ro = resizeObservers();
@@ -2091,12 +2094,31 @@ function viewsPage(real: string[], standIns: string[], decls: string[] = [], giv
     ...real.map((id) => `VIEW_BY_ID.set('${id}', ${viewSrc(id)});`),
     ...standIns.map((id) => `VIEW_BY_ID.set('${id}', { id: '${id}', label: '${id}', icon: 'x', needsScan: false, mount() {} });`),
   ];
+  const caught: string[] = [];
+  const pageConsole = {
+    ...console,
+    error: (...args: unknown[]) => {
+      const line = args.map(String).join(' ');
+      if (/^\[treemap\] (?:unmount of|mount of|onScanChange for) "/.test(line)) caught.push(line);
+      else console.error(...args);
+    },
+  };
   const p = page([...WAIT, ...SWITCH, ...decls], {
     ResizeObserver: ro.ResizeObserver, MutationObserver: mo.MutationObserver,
     document: { body, activeElement: null, querySelectorAll: (sel: string) => (sel === '.view' ? sections : []) },
     tabs: [], hideTooltip: noop, hideCtxMenu: noop, selectionBarFollowView: noop, renderEmptyState: noop,
-    fxEmptyCtaSync: noop, fxScanHeroSync: noop, renderCapabilityNotice: noop, fxViewEnter: noop, toast: noop, ...given,
+    fxEmptyCtaSync: noop, fxScanHeroSync: noop, renderCapabilityNotice: noop, fxViewEnter: noop, toast: noop,
+    console: pageConsole, ...given,
   }, missing, run);
+  const nothingCaught = (when: string): void => {
+    assert.deepEqual(caught.splice(0), [], `control, ${when}: the registry caught nothing from a view's own code`);
+  };
+  const switchView = p.fns.switchView;
+  p.fns.switchView = (...args: unknown[]) => {
+    const out = switchView(...args);
+    nothingCaught(`switching to ${String(args[0])}`);
+    return out;
+  };
   for (const id of [...real, ...standIns]) {
     const section = p.$(`view-${id}`);
     section.id = `view-${id}`;
@@ -2112,7 +2134,7 @@ function viewsPage(real: string[], standIns: string[], decls: string[] = [], giv
     if (!live.parent) Object.assign(live, { id: r, parent: main });
     p.fns.aloudKnow(live);
   }
-  const frame = () => { mo.microtasks(); p.frame(mo.microtasks); ro.layout(); mo.microtasks(); };
+  const frame = () => { mo.microtasks(); p.frame(mo.microtasks); ro.layout(); mo.microtasks(); nothingCaught('in a frame'); };
   frame();
   return { ...p, frame };
 }
@@ -2560,20 +2582,21 @@ test('the notes over and under the map are taken back as the Treemap view goes
     treemap: { rootPath: '/r', altNote: '', altZoomRaf: 0, altZoom: null as unknown, cells: [] as unknown[] },
   };
   const map: { draw: () => void } = { draw: noop };
-  // What the registry caught from the view's own mount or unmount (020: it logs the error and goes on). A name the
-  // harness did not give threw there unseen: the unmount stopped at `tmLoadSeq++`, and the rest of its teardown never ran.
-  const caught: string[] = [];
+  // The unmount's last step turns the mode pills' rings off (fxTmPillBeamsSync(false)): one more of those per visit away
+  // is the unmount reaching its end, counted, not inferred from the registry catching nothing (viewsPage checks that).
+  let pillsOff = 0;
   const p = viewsPage(['treemap'], ['elsewhere'], ['function tmSetEmpty(', 'function renderAltNote(', 'function altRefiningNote('], {
     state: st, tmAnimFrame: 0, tmResizeDeb: 0, tmLoadSeq: 0, treeScanId: () => 's1',
-    console: { ...console, error: (...args: unknown[]) => { caught.push(args.map(String).join(' ')); } },
     // Its unmount's teardown, and its mount's loads, the map's own landing (draw, below) among them.
     tmCancelQueries: noop, tmCloseHints: noop, tmClearHits: noop, nlClose: noop, exitCartPreview: noop, tmSetQueryMessage: noop, disableLive: noop,
-    altRefineCancel: noop, lapseStop: noop, lassoCancel: noop, fxTmPillBeamsSync: noop, loadSavedViews: noop, refreshDock: noop, tmRejudgeQuery: noop,
+    altRefineCancel: noop, lapseStop: noop, lassoCancel: noop, loadSavedViews: noop, refreshDock: noop, tmRejudgeQuery: noop,
+    fxTmPillBeamsSync: (on: boolean) => { if (on === false) pillsOff += 1; },
     tmStopMorph: noop, loadTreemap: () => map.draw(),
   });
   const leave = (what: string): void => {
+    const before = pillsOff;
     p.fns.switchView('elsewhere');
-    assert.deepEqual(caught, [], `${what}: control, the Treemap view's own unmount ran to its end — the registry caught nothing from it`);
+    assert.equal(pillsOff, before + 1, `${what}: control, the Treemap view's own unmount ran to its last step, once`);
   };
   const empty = 'This folder is empty.';
   const cap = 'The map holds at most 250,000 items, and this folder reached that: 1.2 GB has no rectangle here — drill in, or open the Grid view, to see the rest.';
 
@@ -630,10 +630,11 @@ test("outside a test runner, emptying the Trash goes ahead: to the machine's own
     return;
   }
   // On Linux, with gio not run, the freedesktop fallback empties the Trash folders itself, and the disarmed machine
-  // refuses it the first of them, the home folder's. The answer names that folder, and only what the fallback could
-  // not clear: once the fallback ran, gio's absence is no reason the Trash stayed full (runTrashEmptiers).
+  // refuses it the home folder's. The answer names that folder, and only what the fallback could not clear: once the
+  // fallback ran, gio's absence is no reason the Trash stayed full (runTrashEmptiers). Not necessarily first: a Trash
+  // folder on another drive the fallback could not look at would be named before it (clearFreedesktopTrash).
   const homeTrash = path.join(child.home, '.local', 'share', 'Trash', 'files');
-  assert.equal(result.failed[0]?.location, homeTrash, `and the answer names the Trash folder the fallback could not clear: ${JSON.stringify(value)}`);
+  assert.ok(result.failed.some((f) => f.location === homeTrash), `and the answer names the Trash folder the fallback could not clear: ${JSON.stringify(value)}`);
   assert.ok(!result.failed.some((f) => f.location === cmd), `and not gio, which the fallback stood in for: ${JSON.stringify(value)}`);
 });
 
 
@@ -22,7 +22,9 @@ import type { FileNode, Snapshot } from '../src/models/types';
  * one missing from a list that holds every item is removed or new, as before.
  */
 
-const ROOT = path.join(path.sep, 'snap-root');
+// On its drive, as every Windows scan's root is: path.join(path.sep, …) gives Windows the drive-less "\snap-root",
+// which no Windows scan has (the spelling compareUnlisted's fixtures failed with there).
+const ROOT = path.resolve(path.sep, 'snap-root');
 
 function scanWith(children: { name: string; size: number; dir?: boolean }[]) {
   const nodes: FileNode[] = children.map((c) => ({