cursedbelt 5.46.2 → 5.47.0

package/src/react/file-tree/FolderViewMenus.tsx

@@ -72,7 +72,9 @@ export function folderTargets(
 }
 
 /**
- * "Hide folder" and "Tags…" for a folder — the row's half of the feature, as menu items.
+ * "Hide on this device", "Hide everywhere" and "Tags…" for a folder — the row's half of the
+ * feature, as menu items. With no device half kept (`useFolderView({ device: 'memory' })`) the
+ * two hides are one "Hide folder", which means everywhere.
  *
  * Exported so an app's own ⋯ menu offers exactly what the right-click does: spread it into
  * the list you hand `DropdownMenu`. `ids` is the folders it acts on (see {@link folderTargets});
@@ -82,24 +84,47 @@ export function folderViewMenuItems(
   view: FolderView,
   node: FileTreeNode,
   ids: readonly string[] = [node.id],
-  hiddenState: 'self' | 'inherited' | null = view.marks.hidden.includes(node.id) ? 'self' : null,
+  hiddenState: 'self' | 'inherited' | null = view.hiddenIn(node.id) ? 'self' : null,
 ): FileTreeMenuItem[] {
   if (node.kind !== 'folder') return [];
   const many = ids.length > 1;
   const what = many ? `${ids.length} folders` : `“${node.name}”`;
   const items: FileTreeMenuItem[] = [];
+  const everywhere = () => {
+    view.hide(ids);
+    said(`Hid ${what}, on every device`, () => view.unhide(ids, { scope: 'everywhere' }), many ? '“Show hidden folders” (⇧⌘.) shows them again' : '“Show hidden folders” (⇧⌘.) shows it again');
+  };
   if (hiddenState === 'self') {
-    items.push({
-      key: 'fv-unhide',
-      label: many ? `Unhide ${ids.length} folders` : 'Unhide folder',
-      title: `Show ${what} in the tree again, on every device`,
-      onClick: () => {
-        view.unhide(ids);
-        said(`${many ? `${ids.length} folders are` : `${what} is`} back in the tree, on every device`, () =>
-          view.hide(ids),
-        );
-      },
-    });
+    // Which list holds it decides the words: "Unhide" alone would not say where it comes back.
+    const scope = ids.length === 1 ? view.hiddenIn(node.id) : null;
+    const inDevice = scope === 'device' || scope === 'both' || (scope === null && ids.some((id) => view.local.hidden.includes(id)));
+    const inEverywhere = scope === 'everywhere' || scope === 'both' || (scope === null && ids.some((id) => view.marks.hidden.includes(id)));
+    if (inDevice)
+      items.push({
+        key: 'fv-unhide-device',
+        label: many ? `Unhide ${ids.length} folders on this device` : 'Unhide on this device',
+        title: inEverywhere
+          ? `Take ${what} off this device's list — it stays hidden everywhere until that is undone too`
+          : `Show ${what} in the tree on this device again`,
+        onClick: () => {
+          view.unhide(ids, { scope: 'device' });
+          said(`${many ? `${ids.length} folders are` : `${what} is`} back on this device`, () =>
+            view.hide(ids, { scope: 'device' }),
+          );
+        },
+      });
+    if (inEverywhere)
+      items.push({
+        key: 'fv-unhide',
+        label: many ? `Unhide ${ids.length} folders everywhere` : 'Unhide everywhere',
+        title: `Show ${what} in the tree again, on every device`,
+        onClick: () => {
+          view.unhide(ids, { scope: 'everywhere' });
+          said(`${many ? `${ids.length} folders are` : `${what} is`} back in the tree, on every device`, () =>
+            view.hide(ids),
+          );
+        },
+      });
   } else if (hiddenState === 'inherited') {
     items.push({
       key: 'fv-unhide',
@@ -107,15 +132,30 @@ export function folderViewMenuItems(
       disabled: true,
       title: 'It is inside a hidden folder — unhide that folder to bring this one back',
     });
+  } else if (view.deviceHiding) {
+    items.push(
+      {
+        key: 'fv-hide-device',
+        label: many ? `Hide ${ids.length} folders on this device` : 'Hide on this device',
+        title: `Leave ${what} out of the tree in this browser only. “Show hidden folders” (⇧⌘.) brings it back.`,
+        onClick: () => {
+          view.hide(ids, { scope: 'device' });
+          said(`Hid ${what}, on this device`, () => view.unhide(ids, { scope: 'device' }), '“Show hidden folders” (⇧⌘.) shows it again');
+        },
+      },
+      {
+        key: 'fv-hide',
+        label: many ? `Hide ${ids.length} folders everywhere` : 'Hide everywhere',
+        title: `Leave ${what} out of the tree on every device. “Show hidden folders” (⇧⌘.) brings it back.`,
+        onClick: everywhere,
+      },
+    );
   } else {
     items.push({
       key: 'fv-hide',
       label: many ? `Hide ${ids.length} folders` : 'Hide folder',
       title: `Leave ${what} out of the tree on every device. “Show hidden folders” (⇧⌘.) brings it back.`,
-      onClick: () => {
-        view.hide(ids);
-        said(`Hid ${what}, on every device`, () => view.unhide(ids), many ? '“Show hidden folders” (⇧⌘.) shows them again' : '“Show hidden folders” (⇧⌘.) shows it again');
-      },
+      onClick: everywhere,
     });
   }
   const current = view.marks.tags[node.id] ?? [];

package/src/react/file-tree/folderView.spec.ts

@@ -6,9 +6,11 @@ import {
   EMPTY_FOLDER_VIEW,
   type FolderMarks,
   type FolderViewLocal,
+  hiddenScope,
   normalizeTag,
   parseFolderMarks,
   parseFolderViewLocal,
+  remapFolderMarks,
   serializeFolderMarks,
   setHidden,
   setTagFilter,
@@ -94,6 +96,41 @@ describe('hiding a folder', () => {
   });
 });
 
+describe('hidden on THIS device only', () => {
+  test('🔴 a folder in the device list is gone from the tree, subtree and all, like an everywhere one', () => {
+    const out = applyFolderView(TREE, MARKS, view({ hidden: ['work'] }));
+    expect(ids(out.nodes)).not.toContain('work');
+    expect(ids(out.nodes)).not.toContain('dynatrace');
+    expect(out.hiddenCount).toBe(1);
+  });
+
+  test('"show hidden" draws a device-hidden folder back, marked `self`', () => {
+    const out = applyFolderView(TREE, MARKS, view({ hidden: ['work'], showHidden: true }));
+    expect(out.hiddenMarks.get('work')).toBe('self');
+    expect(out.hiddenMarks.get('dynatrace')).toBe('inherited');
+  });
+
+  test('one folder in both lists counts once', () => {
+    const out = applyFolderView(TREE, { ...MARKS, hidden: ['work'] }, view({ hidden: ['work'] }));
+    expect(out.hiddenCount).toBe(1);
+  });
+
+  test('hiddenScope names which list holds a folder', () => {
+    const marks = { ...MARKS, hidden: ['work', 'home'] };
+    const local = view({ hidden: ['home', 'code'] });
+    expect(hiddenScope(marks, local, 'work')).toBe('everywhere');
+    expect(hiddenScope(marks, local, 'code')).toBe('device');
+    expect(hiddenScope(marks, local, 'home')).toBe('both');
+    expect(hiddenScope(marks, local, 'scratch')).toBeNull();
+  });
+
+  test('setHidden works on the device list too', () => {
+    const local = setHidden(EMPTY_FOLDER_VIEW, ['work'], true);
+    expect(local.hidden).toEqual(['work']);
+    expect(local.showHidden).toBe(false);
+  });
+});
+
 describe('filtering by tag (this device)', () => {
   test('"only home + code" keeps those folders WITH their subtrees, and the path to a nested one', () => {
     const out = applyFolderView(TREE, MARKS, view({ only: ['home', 'code'] }));
@@ -159,6 +196,30 @@ describe('tags', () => {
   });
 });
 
+describe('remapFolderMarks — a path-keyed tree renamed a folder', () => {
+  const marks: FolderMarks = {
+    hidden: ['a/b', 'c'],
+    tags: { 'a/b': ['work'], 'a/b/d': ['home'], c: ['code'] },
+  };
+  const rename = (id: string) => (id === 'a/b' || id.startsWith('a/b/') ? `x${id.slice(3)}` : id);
+
+  test('🔴 hidden and tags follow the folder and everything under it', () => {
+    const out = remapFolderMarks(marks, rename);
+    expect(out.hidden).toEqual(['x', 'c']);
+    expect(out.tags).toEqual({ x: ['work'], 'x/d': ['home'], c: ['code'] });
+  });
+
+  test('null forgets a mark — a deleted folder', () => {
+    const out = remapFolderMarks(marks, (id) => (id === 'c' ? null : id));
+    expect(out.hidden).toEqual(['a/b']);
+    expect(out.tags.c).toBeUndefined();
+  });
+
+  test('nothing moved → the same value back', () => {
+    expect(remapFolderMarks(marks, (id) => id)).toBe(marks);
+  });
+});
+
 describe('storage', () => {
   test('marks round-trip, and empty marks store as nothing so the key can be forgotten', () => {
     const marks: FolderMarks = { hidden: ['a'], tags: { b: ['home'] } };
@@ -169,6 +230,7 @@ describe('storage', () => {
   test('🔴 a corrupt value reads as NOTHING rather than throwing — it must never cost the tree', () => {
     expect(parseFolderMarks('{not json')).toEqual(EMPTY_FOLDER_MARKS);
     expect(parseFolderMarks('{"hidden":"x","tags":[1]}')).toEqual({ hidden: [], tags: {} });
-    expect(parseFolderViewLocal('[]')).toEqual({ showHidden: false, only: [], hide: [] });
+    expect(parseFolderViewLocal('[]')).toEqual({ showHidden: false, only: [], hide: [], hidden: [] });
+    expect(parseFolderViewLocal('{"hidden":["a",1,"a",""]}').hidden).toEqual(['a']);
   });
 });

package/src/react/file-tree/folderView.ts

@@ -13,8 +13,11 @@
  *     folder, so it follows the person to every device (the app syncs it — see
  *     `useFolderView`, which announces it on the preference bus like every other synced key).
  *   · {@link FolderViewLocal} — HOW this device is looking: whether hidden folders are drawn,
- *     and which tags it is narrowed to. *"viewing the 'home' tag at home doesn't change my
- *     work computer"*, so this is never announced and never leaves the browser.
+ *     which tags it is narrowed to, and the folders hidden on THIS device only. *"viewing the
+ *     'home' tag at home doesn't change my work computer"*, so this is never announced and
+ *     never leaves the browser. The device-only list is desk's owner request, 2026-09-30:
+ *     *"a way to hide on the current device or to hide everywhere … and unhide them on just
+ *     the device or unhide them everywhere"* — a folder hidden by either list is hidden.
  *
  * Hiding a folder in general and filtering by tag are therefore different verbs on purpose:
  * one is a decision about the folder, the other is a lens on the tree.
@@ -50,6 +53,8 @@ export interface FolderViewLocal {
   only: readonly string[];
   /** Leave out folders carrying any of these. Wins over {@link only}. */
   hide: readonly string[];
+  /** Folders hidden on this device only — {@link FolderMarks.hidden}'s per-device twin. */
+  hidden: readonly string[];
 }
 
 export const EMPTY_FOLDER_MARKS: FolderMarks = Object.freeze({
@@ -61,6 +66,7 @@ export const EMPTY_FOLDER_VIEW: FolderViewLocal = Object.freeze({
   showHidden: false,
   only: Object.freeze([]) as readonly string[],
   hide: Object.freeze([]) as readonly string[],
+  hidden: Object.freeze([]) as readonly string[],
 });
 
 /** Longest tag kept. A tag is a word or two; anything longer is a sentence in the wrong field. */
@@ -120,25 +126,69 @@ export function serializeFolderMarks(marks: FolderMarks): string | null {
 export function parseFolderViewLocal(raw: string | null | undefined): FolderViewLocal {
   if (!raw) return EMPTY_FOLDER_VIEW;
   try {
-    const value = JSON.parse(raw) as { showHidden?: unknown; only?: unknown; hide?: unknown };
+    const value = JSON.parse(raw) as { showHidden?: unknown; only?: unknown; hide?: unknown; hidden?: unknown };
     return {
       showHidden: value.showHidden === true,
       only: Array.isArray(value.only) ? uniqueTags(value.only as string[]) : [],
       hide: Array.isArray(value.hide) ? uniqueTags(value.hide as string[]) : [],
+      hidden: Array.isArray(value.hidden)
+        ? [...new Set(value.hidden.filter((id): id is string => typeof id === 'string' && id !== ''))]
+        : [],
     };
   } catch {
     return EMPTY_FOLDER_VIEW;
   }
 }
 
-/** Hide or unhide these ids — a new value; the input is never touched. */
-export function setHidden(marks: FolderMarks, ids: readonly string[], hidden: boolean): FolderMarks {
+/**
+ * Hide or unhide these ids in either list — {@link FolderMarks} (everywhere) or
+ * {@link FolderViewLocal} (this device). A new value; the input is never touched, and an
+ * unchanged list hands the input back so a caller can tell nothing happened.
+ */
+export function setHidden<T extends { hidden: readonly string[] }>(
+  holder: T,
+  ids: readonly string[],
+  hidden: boolean,
+): T {
   const next = hidden
-    ? [...marks.hidden, ...ids.filter((id) => !marks.hidden.includes(id))]
-    : marks.hidden.filter((id) => !ids.includes(id));
-  return next.length === marks.hidden.length && next.every((id, i) => id === marks.hidden[i])
-    ? marks
-    : { ...marks, hidden: next };
+    ? [...holder.hidden, ...ids.filter((id) => !holder.hidden.includes(id))]
+    : holder.hidden.filter((id) => !ids.includes(id));
+  return next.length === holder.hidden.length && next.every((id, i) => id === holder.hidden[i])
+    ? holder
+    : { ...holder, hidden: next };
+}
+
+/**
+ * Re-key the marks after folders were renamed, moved or deleted — for a tree whose folder ids
+ * are PATHS (music, vault), where a rename hands the folder and everything under it a new id.
+ * `move(id)` answers each marked id with its new id, the same id to keep it, or `null` to forget
+ * it. Hidden and tags both follow; the input comes back untouched when nothing moved.
+ */
+export function remapFolderMarks(marks: FolderMarks, move: (id: string) => string | null): FolderMarks {
+  let changed = false;
+  const hidden: string[] = [];
+  for (const id of marks.hidden) {
+    const to = move(id);
+    if (to !== id) changed = true;
+    if (to !== null && !hidden.includes(to)) hidden.push(to);
+  }
+  const tags: Record<string, readonly string[]> = {};
+  for (const [id, list] of Object.entries(marks.tags)) {
+    const to = move(id);
+    if (to !== id) changed = true;
+    if (to === null) continue;
+    tags[to] = tags[to] ? uniqueTags([...tags[to], ...list]) : list;
+  }
+  return changed ? { hidden, tags } : marks;
+}
+
+/** Where a folder is hidden, if it is: which of the two lists name it. */
+export type HiddenScope = 'everywhere' | 'device' | 'both';
+
+export function hiddenScope(marks: FolderMarks, local: FolderViewLocal, id: string): HiddenScope | null {
+  const everywhere = marks.hidden.includes(id);
+  const device = local.hidden.includes(id);
+  return everywhere && device ? 'both' : everywhere ? 'everywhere' : device ? 'device' : null;
 }
 
 /** Replace one folder's tags. An empty list forgets the folder entirely. */
@@ -242,9 +292,10 @@ export function applyFolderView(
 ): FolderViewResult {
   const hiddenMarks = new Map<string, 'self' | 'inherited'>();
   const filtering = tagFilterActive(local);
-  if (marks.hidden.length === 0 && !filtering) return { nodes, hiddenMarks, hiddenCount: 0 };
+  if (marks.hidden.length === 0 && local.hidden.length === 0 && !filtering)
+    return { nodes, hiddenMarks, hiddenCount: 0 };
 
-  const hiddenSet = new Set(marks.hidden);
+  const hiddenSet = new Set([...marks.hidden, ...local.hidden]);
   const only = new Set(local.only);
   const hide = new Set(local.hide);
   let hiddenCount = 0;

package/src/react/file-tree/folderViewTree.spec.tsx

@@ -1,10 +1,11 @@
 import { afterEach, beforeAll, beforeEach, describe, expect, spyOn, test } from 'bun:test';
 import { act, cleanup, fireEvent, render, screen } from '@testing-library/react';
+import { useState } from 'react';
 import type { FileTreeNode } from 'cursedbelt-core/file-tree/file-tree-model';
 import { onPreferenceWrite } from '../media-gallery/preferenceBus.js';
 import { toast } from '../Toast.js';
 import { FileTree, type FileTreeProps, preloadFileTreePanels } from './FileTree.js';
-import { useFolderView } from './useFolderView.js';
+import { type UseFolderViewOptions, useFolderView } from './useFolderView.js';
 
 /**
  * Hidden folders and folder tags, through the gestures the owner named: right-click a folder,
@@ -27,8 +28,8 @@ const TREE: FileTreeNode[] = [
   { id: 'readme', name: 'readme.md', kind: 'file' },
 ];
 
-function Harness(props: Partial<FileTreeProps>) {
-  const folderView = useFolderView({ key: KEY });
+function Harness({ options, ...props }: Partial<FileTreeProps> & { options?: Partial<UseFolderViewOptions> }) {
+  const folderView = useFolderView({ key: KEY, ...options });
   return (
     <div>
       {/* biome-ignore lint/a11y/noStaticElementInteractions: stands in for an app's header bar, whose right-click is exactly what is under test. */}
@@ -66,10 +67,10 @@ beforeEach(() => globalThis.localStorage.clear());
 afterEach(cleanup);
 
 describe('hiding a folder', () => {
-  test('🔴 right-click a folder → Hide folder → it and its contents leave the tree', () => {
+  test('🔴 right-click a folder → Hide everywhere → it and its contents leave the tree', () => {
     render(<Harness />);
     fireEvent.contextMenu(row('Work'), { clientX: 10, clientY: 10 });
-    fireEvent.click(item('Hide folder'));
+    fireEvent.click(item('Hide everywhere'));
     expect(screen.queryByText('Work')).toBeNull();
     expect(screen.queryByText('Dynatrace')).toBeNull();
     expect(screen.getByText('Home')).toBeDefined();
@@ -87,17 +88,17 @@ describe('hiding a folder', () => {
     try {
       render(<Harness />);
       fireEvent.contextMenu(row('Work'));
-      fireEvent.click(item('Hide folder'));
+      fireEvent.click(item('Hide everywhere'));
       expect(said.map((s) => s.message)).toEqual(['Hid “Work”, on every device']);
       expect(screen.queryByText('Work')).toBeNull();
       act(() => said[0]?.undo());
       expect(screen.getByText('Work')).toBeDefined();
 
       fireEvent.contextMenu(row('Work'));
-      fireEvent.click(item('Hide folder'));
+      fireEvent.click(item('Hide everywhere'));
       fireEvent.keyDown(row('Home'), { key: '.', code: 'Period', shiftKey: true, metaKey: true });
       fireEvent.contextMenu(row('Work'));
-      fireEvent.click(item('Unhide folder'));
+      fireEvent.click(item('Unhide everywhere'));
       expect(said.at(-1)?.message).toBe('“Work” is back in the tree, on every device');
       expect(row('Work').getAttribute('data-hidden')).toBeNull();
       act(() => said.at(-1)?.undo());
@@ -110,7 +111,7 @@ describe('hiding a folder', () => {
   test('🔴 "Show hidden folders" draws them back — the hidden one italic-marked, its contents faded-marked', () => {
     render(<Harness />);
     fireEvent.contextMenu(row('Work'));
-    fireEvent.click(item('Hide folder'));
+    fireEvent.click(item('Hide everywhere'));
     fireEvent.contextMenu(blank(), { clientX: 5, clientY: 300 });
     fireEvent.click(item(/Show hidden folders \(1\)/));
     expect(row('Work').getAttribute('data-hidden')).toBe('self');
@@ -121,14 +122,14 @@ describe('hiding a folder', () => {
     // Still hideable — the owner's "showing hidden folders still keeps them hideable": its own
     // menu now offers the way back.
     fireEvent.contextMenu(row('Work'));
-    fireEvent.click(item('Unhide folder'));
+    fireEvent.click(item('Unhide everywhere'));
     expect(row('Work').getAttribute('data-hidden')).toBeNull();
   });
 
   test('the strip says hidden folders are showing, and its button leaves them out again', () => {
     render(<Harness />);
     fireEvent.contextMenu(row('Work'));
-    fireEvent.click(item('Hide folder'));
+    fireEvent.click(item('Hide everywhere'));
     fireEvent.contextMenu(blank());
     fireEvent.click(item(/Show hidden folders/));
     expect(screen.getByText('Showing hidden')).toBeDefined();
@@ -140,7 +141,7 @@ describe('hiding a folder', () => {
   test('⇧⌘. on a row toggles hidden folders — Finder\'s chord', () => {
     render(<Harness />);
     fireEvent.contextMenu(row('Work'));
-    fireEvent.click(item('Hide folder'));
+    fireEvent.click(item('Hide everywhere'));
     fireEvent.keyDown(row('Home'), { key: '>', code: 'Period', shiftKey: true, metaKey: true });
     expect(row('Work').getAttribute('data-hidden')).toBe('self');
     fireEvent.keyDown(row('Home'), { key: '>', code: 'Period', shiftKey: true, metaKey: true });
@@ -223,7 +224,7 @@ describe('🔴 what reaches other devices, and what does not', () => {
     try {
       render(<Harness />);
       fireEvent.contextMenu(row('Work'));
-      fireEvent.click(item('Hide folder'));
+      fireEvent.click(item('Hide everywhere'));
       expect(heard).toEqual([KEY]);
       fireEvent.contextMenu(blank());
       fireEvent.click(item(/Show hidden folders/));
@@ -235,7 +236,100 @@ describe('🔴 what reaches other devices, and what does not', () => {
   });
 });
 
+describe('🔴 hidden on THIS device only — desk\'s two lists, in the belt', () => {
+  test('Hide on this device leaves the tree, is never announced, and is stored on this device', () => {
+    const heard: string[] = [];
+    const stop = onPreferenceWrite((key) => heard.push(key));
+    try {
+      render(<Harness />);
+      fireEvent.contextMenu(row('Work'));
+      fireEvent.click(item('Hide on this device'));
+      expect(screen.queryByText('Work')).toBeNull();
+      expect(heard).toEqual([]);
+      expect(globalThis.localStorage.getItem(KEY)).toBeNull();
+      expect(globalThis.localStorage.getItem(`${KEY}:device`)).toContain('"hidden":["work"]');
+    } finally {
+      stop();
+    }
+  });
+
+  test('under Show hidden, the menu says WHICH list a folder is in, and unhides from that one', () => {
+    render(<Harness />);
+    fireEvent.contextMenu(row('Work'));
+    fireEvent.click(item('Hide on this device'));
+    fireEvent.contextMenu(row('Home'));
+    fireEvent.click(item('Hide everywhere'));
+    fireEvent.keyDown(row('readme.md'), { key: '>', code: 'Period', shiftKey: true, metaKey: true });
+
+    fireEvent.contextMenu(row('Work'));
+    expect(() => item('Unhide everywhere')).toThrow();
+    fireEvent.click(item('Unhide on this device'));
+    expect(row('Work').getAttribute('data-hidden')).toBeNull();
+
+    fireEvent.contextMenu(row('Home'));
+    expect(() => item('Unhide on this device')).toThrow();
+    fireEvent.click(item('Unhide everywhere'));
+    expect(row('Home').getAttribute('data-hidden')).toBeNull();
+  });
+});
+
+describe('🔴 the marks kept by the app — `store` and `device: \'memory\'`', () => {
+  test('with a store, a hide goes to the store and NOTHING touches localStorage or the bus', () => {
+    const written: (string | null)[] = [];
+    const heard: string[] = [];
+    const stop = onPreferenceWrite((key) => heard.push(key));
+    try {
+      function Kept() {
+        const [marks, setMarks] = useState<string | null>(null);
+        return (
+          <Harness
+            options={{
+              store: {
+                marks,
+                write: (next) => {
+                  written.push(next);
+                  setMarks(next);
+                },
+              },
+              device: 'memory',
+            }}
+          />
+        );
+      }
+      render(<Kept />);
+      fireEvent.contextMenu(row('Work'));
+      // No device half kept → one hide, which means everywhere.
+      expect(() => item('Hide on this device')).toThrow();
+      fireEvent.click(item('Hide folder'));
+      expect(screen.queryByText('Work')).toBeNull();
+      expect(written).toHaveLength(1);
+      expect(written[0]).toContain('"hidden":["work"]');
+      fireEvent.keyDown(row('Home'), { key: '>', code: 'Period', shiftKey: true, metaKey: true });
+      expect(row('Work').getAttribute('data-hidden')).toBe('self');
+      expect(globalThis.localStorage.length).toBe(0);
+      expect(heard).toEqual([]);
+    } finally {
+      stop();
+    }
+  });
+
+  test('the store is the truth: a value it hands in is what the tree draws', () => {
+    render(<Harness options={{ store: { marks: '{"hidden":["home"],"tags":{}}', write: () => undefined } }} />);
+    expect(screen.queryByText('Home')).toBeNull();
+    expect(screen.getByText('Work')).toBeDefined();
+  });
+});
+
 describe('a row menu of the app\'s own', () => {
+  test('🔴 with onRowMenu and no rowMenu, right-click opens the APP\'s menu at the pointer', () => {
+    const opened: { id: string; x: number; y: number }[] = [];
+    render(<Harness onRowMenu={(node, at) => opened.push({ id: node.id, ...at })} />);
+    expect(fireEvent.contextMenu(row('readme.md'), { clientX: 40, clientY: 50 })).toBe(false);
+    expect(opened).toEqual([{ id: 'readme', x: 40, y: 50 }]);
+    // The tree drew no menu of its own over the app's.
+    expect(items()).toHaveLength(0);
+  });
+
   test('rowMenu items open on right-click, with Hide and Tags… after them on a folder', () => {
     let renamed = '';
     render(
@@ -246,7 +340,7 @@ describe('a row menu of the app\'s own', () => {
     fireEvent.contextMenu(row('Home'));
     const labels = items().map((el) => el.textContent);
     expect(labels[0]).toBe('Rename');
-    expect(labels.some((l) => l?.startsWith('Hide folder'))).toBe(true);
+    expect(labels.some((l) => l?.startsWith('Hide everywhere'))).toBe(true);
     fireEvent.click(item('Rename'));
     expect(renamed).toBe('home');
   });
@@ -264,7 +358,8 @@ describe('a row menu of the app\'s own', () => {
     fireEvent.contextMenu(row('Home'));
     expect(items().map((el) => el.querySelector('.truncate')?.textContent)).toEqual([
       'Rename',
-      'Hide folder',
+      'Hide on this device',
+      'Hide everywhere',
       'Tags…',
       'Delete folder',
     ]);
@@ -274,7 +369,7 @@ describe('a row menu of the app\'s own', () => {
     render(<Harness />);
     act(() => row('Home').focus());
     fireEvent.keyDown(row('Home'), { key: 'F10', shiftKey: true });
-    expect(item('Hide folder')).toBeDefined();
+    expect(item('Hide everywhere')).toBeDefined();
   });
 
   test('a tree with neither rowMenu nor folderView leaves right-click to the browser', () => {

package/src/react/file-tree/index.ts

@@ -65,4 +65,18 @@ export {
   folderViewMenuItems,
   withFolderItems,
 } from './FolderViewMenus.js';
-export { type FolderView, type UseFolderViewOptions, useFolderView } from './useFolderView.js';
+export {
+  type FolderMarks,
+  type FolderViewLocal,
+  type HiddenScope,
+  parseFolderMarks,
+  remapFolderMarks,
+  serializeFolderMarks,
+} from './folderView.js';
+export {
+  type FolderMarksStore,
+  type FolderView,
+  type HideScope,
+  type UseFolderViewOptions,
+  useFolderView,
+} from './useFolderView.js';