cursedbelt 2.7.0 → 2.8.0

package/scripts/verify.ts

@@ -0,0 +1,292 @@
+#!/usr/bin/env bun
+/**
+ * `bun run verify` — every check this repo has, run as a dependency GRAPH instead of a
+ * six-link `&&` chain.
+ *
+ * ## Why this stopped being a chain
+ *
+ * Measured 2026-09-15 on an idle machine, stage by stage, with the chain in place:
+ *
+ *     paths 0.4s · typecheck 22.6s (three tsc projects) · demo:check 7.2s
+ *     · build 13.2s · test 67.6s · e2e 32.2s        →  142.0s end to end
+ *
+ * Five of those are single-threaded `tsc`/scan work that share nothing but the source tree,
+ * and they were queued behind one another on a fourteen-core machine. As a graph the same
+ * stages finish in roughly half the wall clock, and the saving grows with load: this repo's
+ * gate is two thirds of every gate second the generation has ever spent.
+ *
+ * 🔴 NOTHING HERE IS A SMALLER GATE. Every script the chain ran is still run, and
+ * `src/verifyGraph.spec.ts` fails if one is dropped or orphaned. This generation's third
+ * rule is that a repo's gate proves that repo — a gate that got faster by proving less is
+ * not faster, it is gone. There is deliberately no `verify:fast`: one gate, or the fast one
+ * becomes the one everybody runs and the slow one becomes the one nobody does.
+ *
+ * ## The edges, and why these are the only ones
+ *
+ * `build` regenerates `src/styles-static.css` and `src/styles-utilities.css` (its first two
+ * steps), and `stylesStaticMatches.spec.ts` and `stylesUtilitiesMatches.spec.ts` read those
+ * exact files and assert they are current. Run concurrently against a STALE stylesheet, one
+ * process writes the bytes the other is asserting on — a flake that appears only on the
+ * commit that changed a component, which is the worst possible day for it.
+ *
+ * So the generators are their own stage and everything that touches those bytes waits for
+ * it. Once `styles` has run, the same generators inside `build` find their output current
+ * and write nothing (they compare before writing) — which is what makes `build` safe to run
+ * beside `test` and `e2e` rather than in front of them.
+ *
+ * 🔴 `build` is a LEAF, not a prerequisite. No spec under `src` opens `dist/` — checked by
+ * `verifyGraph.spec.ts` rather than asserted here — and the demo resolves every
+ * `cursedbelt/…` specifier to SOURCE through the export map, so nothing in `test` or `e2e`
+ * can see the compiled output at all.
+ *
+ * ## What it prints
+ *
+ * Buffered per stage, never interleaved: six concurrent stages writing to one transcript is
+ * output nobody can read. The cost of buffering is silence, and silence is exactly what
+ * `autopilot/src/proc.ts` exists to prevent — so a heartbeat names what is still running and
+ * for how long. A reader can tell "thinking" from "dead" without knowing anything about the
+ * suite.
+ *
+ * 🔴 A failing stage's output is printed LAST, after the timing table. The runner keeps the
+ * final 4 KB of a gate as the evidence it files against the task (`worker.ts`), so whatever
+ * is at the tail is what a human reads first. The chain got this for free by stopping at the
+ * failure; a graph has to put it there on purpose.
+ */
+import { cpus } from "node:os";
+import { resolve } from "node:path";
+
+export interface Stage {
+	/**
+	 * The `package.json` script this stage runs. 🔴 A script name, never a command line —
+	 * `package.json` stays the one place every command is spelled, so this file cannot drift
+	 * from what `bun run <thing>` does.
+	 */
+	script: string;
+	/** Stages that must be GREEN before this one may start. */
+	needs?: readonly string[];
+	/** Why the edge exists. An edge nobody can explain is an edge nobody can safely remove. */
+	why?: string;
+}
+
+/**
+ * The gate. 🔴 Order in this list means nothing — `needs` is the only thing that sequences
+ * anything, and the scheduler starts whatever is ready.
+ */
+export const STAGES: readonly Stage[] = [
+	{ script: "paths" },
+	{ script: "typecheck:root" },
+	{ script: "typecheck:server" },
+	{ script: "typecheck:specs" },
+	{ script: "demo:check" },
+	{ script: "styles" },
+	{
+		script: "build",
+		needs: ["styles"],
+		why: "its first two steps are the same generators; two writers on one stylesheet is a race",
+	},
+	{
+		script: "test",
+		needs: ["styles"],
+		why: "stylesStaticMatches / stylesUtilitiesMatches read those two files and assert they are current",
+	},
+	{
+		script: "e2e",
+		needs: ["styles"],
+		why: "the demo bundle it drives is compiled from the same stylesheets",
+	},
+];
+
+/** The repo root — this file's own directory, one level up. Never a literal. */
+export const ROOT = resolve(import.meta.dir, "..");
+
+/**
+ * How many stages may run at once.
+ *
+ * 🔴 A THIRD of the cores, not all of them, and the reason is that a stage is not a process.
+ * `e2e` alone spawns seven Playwright workers and `build` spawns two `tsc` processes, so a
+ * cap of six stages is already twenty-odd processes. This Mac reached twenty-one concurrent
+ * `bun test` processes once and the machine-wide PreToolUse warning exists because of it.
+ * Parallelism never reduces the total CPU work; over-subscribing only converts it into
+ * thrash, and browser specs degrade worse than anything else under contention.
+ *
+ * An explicit `CURSEDBELT_VERIFY_JOBS` wins, including `1`, which is how a bisect gets the
+ * old serial behaviour back without a second gate script existing.
+ */
+export function jobLimit(env: NodeJS.ProcessEnv = process.env, cpuCount: number = cpus().length): number {
+	const asked = Number(env.CURSEDBELT_VERIFY_JOBS);
+	if (Number.isFinite(asked) && asked >= 1) return Math.floor(asked);
+	return Math.max(2, Math.min(6, Math.floor(cpuCount / 3)));
+}
+
+/**
+ * 🔴 Every stage reachable, and every `needs` naming a stage that exists.
+ *
+ * Both halves matter and they fail in opposite directions: a typo in `needs` would otherwise
+ * make a stage that can NEVER run (the scheduler would idle with work left, and "nothing
+ * failed" is not the same as "everything passed"), while a cycle would deadlock the same way.
+ * Checked before anything is spawned, so a broken graph costs a second rather than a gate.
+ */
+export function graphFault(stages: readonly Stage[] = STAGES): string | null {
+	const names = new Set(stages.map((s) => s.script));
+	if (names.size !== stages.length) return "two stages name the same script";
+	for (const stage of stages) {
+		for (const need of stage.needs ?? []) {
+			if (!names.has(need)) return `\`${stage.script}\` needs \`${need}\`, which is not a stage`;
+		}
+	}
+	// Kahn's algorithm: anything still unresolved when nothing more can be resolved is a cycle.
+	const done = new Set<string>();
+	for (;;) {
+		const ready = stages.filter((s) => !done.has(s.script) && (s.needs ?? []).every((n) => done.has(n)));
+		if (ready.length === 0) break;
+		for (const s of ready) done.add(s.script);
+	}
+	const stuck = stages.filter((s) => !done.has(s.script)).map((s) => s.script);
+	return stuck.length > 0 ? `these stages can never run (a cycle in \`needs\`): ${stuck.join(", ")}` : null;
+}
+
+export interface StageResult {
+	script: string;
+	ok: boolean;
+	ms: number;
+	output: string;
+	/** Not started, because something it needed failed or the run had already gone red. */
+	skipped?: boolean;
+}
+
+function secs(ms: number): string {
+	return `${(ms / 1000).toFixed(1)}s`;
+}
+
+/** The table every run ends with, green or red. Pure, so the shape of it is testable. */
+export function timingTable(results: readonly StageResult[], wallMs: number): string {
+	const width = Math.max(10, ...results.map((r) => r.script.length));
+	const cpu = results.reduce((a, r) => a + r.ms, 0);
+	const lines = [`  ${"stage".padEnd(width)}   elapsed  result`];
+	for (const r of [...results].sort((a, b) => b.ms - a.ms)) {
+		const verdict = r.skipped ? "skipped" : r.ok ? "ok" : "FAILED";
+		lines.push(`  ${r.script.padEnd(width)} ${secs(r.ms).padStart(9)}  ${verdict}`);
+	}
+	lines.push(
+		"",
+		`  ${secs(wallMs)} of wall clock; ${secs(cpu)} of stage time. ` +
+			`${cpu > wallMs ? `${(cpu / wallMs).toFixed(1)}× overlap.` : "No overlap — one stage at a time."}`,
+	);
+	return lines.join("\n");
+}
+
+async function runStage(stage: Stage): Promise<StageResult> {
+	const started = Date.now();
+	const child = Bun.spawn([process.execPath, "run", stage.script], {
+		cwd: ROOT,
+		stdout: "pipe",
+		// Merged rather than kept apart: a compiler writes diagnostics to one and progress to
+		// the other, and a reader needs them interleaved the way the stage wrote them.
+		stderr: "pipe",
+	});
+	const [out, err, code] = await Promise.all([
+		new Response(child.stdout).text(),
+		new Response(child.stderr).text(),
+		child.exited,
+	]);
+	return { script: stage.script, ok: code === 0, ms: Date.now() - started, output: `${out}${err}` };
+}
+
+/** Bytes of a failing stage's output that reach the tail. Enough for a stack, not a build log. */
+const FAILURE_TAIL = 12_000;
+
+export async function verify(stages: readonly Stage[] = STAGES): Promise<number> {
+	const fault = graphFault(stages);
+	if (fault) {
+		process.stdout.write(`\n🔴 the verify graph is broken: ${fault}\n`);
+		return 2;
+	}
+	const jobs = jobLimit();
+	const startedAt = Date.now();
+	process.stdout.write(`\n▸ verify — ${stages.length} stages, up to ${jobs} at once.\n\n`);
+
+	const results = new Map<string, StageResult>();
+	const running = new Map<string, number>();
+	let red = false;
+
+	// 🔴 Names what is STILL running, never a spinner. The question a reader has at minute
+	// four of a Playwright suite is "which stage, and how long has it been there" — a
+	// progress animation answers neither, and the transcript this lands in is a file.
+	const heartbeat = setInterval(() => {
+		if (running.size === 0) return;
+		const live = [...running.entries()]
+			.map(([script, at]) => `${script} ${secs(Date.now() - at)}`)
+			.sort()
+			.join(" · ");
+		process.stdout.write(`  ⧗ still running: ${live}\n`);
+	}, 30_000);
+	// Never hold the process open on the timer alone.
+	heartbeat.unref?.();
+
+	const inFlight = new Set<Promise<void>>();
+	const start = (stage: Stage): void => {
+		running.set(stage.script, Date.now());
+		process.stdout.write(`  ▶ ${stage.script}\n`);
+		const task = runStage(stage).then((result) => {
+			running.delete(stage.script);
+			results.set(result.script, result);
+			if (!result.ok) red = true;
+			process.stdout.write(`  ${result.ok ? "✔" : "✘"} ${result.script} ${secs(result.ms)}\n`);
+		});
+		inFlight.add(task);
+		void task.finally(() => inFlight.delete(task));
+	};
+
+	for (;;) {
+		// 🔴 Once anything is red, nothing NEW starts — the chain would never have reached it —
+		// but whatever is already running is left to finish. Killing an in-flight stage buys
+		// back seconds that are already spent and throws away a second, independent failure
+		// that would otherwise be in the same report.
+		const ready = red
+			? []
+			: stages.filter(
+					(s) =>
+						!results.has(s.script) &&
+						!running.has(s.script) &&
+						(s.needs ?? []).every((n) => results.get(n)?.ok === true),
+				);
+		while (ready.length > 0 && running.size < jobs) {
+			const next = ready.shift();
+			if (next) start(next);
+		}
+		if (inFlight.size === 0) break;
+		await Promise.race(inFlight);
+	}
+	clearInterval(heartbeat);
+
+	for (const stage of stages) {
+		if (!results.has(stage.script)) {
+			results.set(stage.script, { script: stage.script, ok: false, ms: 0, output: "", skipped: true });
+		}
+	}
+
+	const all = stages.map((s) => results.get(s.script) as StageResult);
+	const failed = all.filter((r) => !r.ok && !r.skipped);
+	const skipped = all.filter((r) => r.skipped);
+	const wall = Date.now() - startedAt;
+
+	process.stdout.write(`\n${timingTable(all, wall)}\n`);
+	if (skipped.length > 0) {
+		process.stdout.write(
+			`\n  ⏭ not run, because the gate was already red: ${skipped.map((r) => r.script).join(", ")}\n`,
+		);
+	}
+	if (failed.length === 0) {
+		process.stdout.write(`\n✅ verify green in ${secs(wall)}.\n`);
+		return 0;
+	}
+	// 🔴 LAST. `worker.ts` files the final 4 KB of this as the evidence against the task.
+	for (const r of failed) {
+		process.stdout.write(`\n\n${"═".repeat(72)}\n🔴 FAILED: bun run ${r.script}  (${secs(r.ms)})\n${"═".repeat(72)}\n`);
+		process.stdout.write(r.output.length > FAILURE_TAIL ? `…\n${r.output.slice(-FAILURE_TAIL)}` : r.output);
+	}
+	process.stdout.write(`\n\n🔴 verify FAILED in ${secs(wall)}: ${failed.map((r) => r.script).join(", ")}\n`);
+	return 1;
+}
+
+if (import.meta.main) process.exit(await verify());

package/src/core/file-tree/fileTreeModel.spec.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from 'bun:test';
 import {
+  accessMarkCopy,
   descendantIdsOf,
   type FileTreeDrop,
   type FileTreeNode,
@@ -460,3 +461,25 @@ describe('describeDrop', () => {
     expect(describeDrop(TREE, { kind: 'into', parentId: 'gone' })).toBe('Into this folder');
   });
 });
+
+describe('accessMarkCopy', () => {
+  test('defaults speak collections — hiddenness, per state', () => {
+    expect(accessMarkCopy('locked')).toBe('Hidden — unlock to see what is in here');
+    expect(accessMarkCopy('private')).toContain('hidden from a locked page');
+  });
+
+  test('🔴 a consumer with its own privacy vocabulary overrides the words', () => {
+    // The vault's protected folders wear the same padlock meaning "needs the master
+    // password" — a claim of hiddenness would be FALSE there (rows visible, secrets
+    // sealed), which is why the words are an argument and not a constant.
+    const copy = { private: 'Protected — everything in here needs the master password' };
+    expect(accessMarkCopy('private', copy)).toBe(copy.private);
+    // An override for one state leaves the other's default standing.
+    expect(accessMarkCopy('locked', copy)).toBe('Hidden — unlock to see what is in here');
+  });
+
+  test('normal (and absent) access has nothing to say', () => {
+    expect(accessMarkCopy('normal')).toBe('');
+    expect(accessMarkCopy(undefined)).toBe('');
+  });
+});

package/src/core/file-tree/fileTreeModel.ts

@@ -464,6 +464,39 @@ export function describeDrop(nodes: readonly FileTreeNode[], drop: FileTreeDrop
   return sibling ? `${where} ${sibling.name}` : `${where} this row`;
 }
 
+/** The consumer's own words for the 🔒 access mark, per state. See {@link accessMarkCopy}. */
+export interface AccessMarkCopy {
+  private?: string;
+  locked?: string;
+}
+
+/**
+ * What the access mark's tooltip SAYS for a given access state.
+ *
+ * 🔴 The defaults speak collections' vocabulary — "hidden from a locked page" — because
+ * that is the app the mark was built for. The mark itself is generic and the words are
+ * not: the vault's protected folders wear the same padlock meaning "everything in here
+ * needs the master password", and a claim of hiddenness would be false there (the rows
+ * are visible; their SECRETS are sealed). So the words are an argument with a default,
+ * resolved here rather than inline, where they can be tested without simulating a hover.
+ *
+ * Empty string for `normal` — a row with no mark has nothing to say.
+ */
+export function accessMarkCopy(
+  access: FileTreeAccess | undefined,
+  copy?: AccessMarkCopy,
+): string {
+  if (access === 'locked') return copy?.locked ?? 'Hidden — unlock to see what is in here';
+  if (access === 'private') {
+    // Deliberately "this or what is in it": a consumer sets `private` both for a row that
+    // is itself private and for a public folder holding private children (collections does
+    // exactly that), and a wording that claimed only the first would be false on half the
+    // rows it marks.
+    return copy?.private ?? 'Private — this, or something in it, is hidden from a locked page';
+  }
+  return '';
+}
+
 /**
  * The next row whose name starts with `query`, searching from `fromIndex` and wrapping.
  *

package/src/demoFixture.spec.ts

@@ -12,6 +12,7 @@ import {
 } from '../demo/devServer';
 import { DEMO_TSCONFIG, derivePaths, readDemoTsconfig, renderPathsBlock } from '../demo/generatePaths';
 import pkg from '../package.json';
+import { STAGES } from '../scripts/verify';
 
 /**
  * 🔴 The e2e suite must never be able to sit green while it drives nothing.
@@ -101,7 +102,16 @@ describe('the e2e fixture exists', () => {
 		// Everything above proves the fixture resolves. Only this proves anybody looks:
 		// without it, `e2e` drops back out of the gate and this whole file becomes a
 		// comment about a suite nothing runs.
-		expect(pkg.scripts.verify, '`verify` must end in the e2e suite').toInclude('bun run e2e');
+		//
+		// 🔴 `verify` stopped being an `&&` chain on 2026-09-15 and became a dependency
+		// graph (`scripts/verify.ts`), so "the script mentions e2e" is no longer where the
+		// answer lives. Asking the graph is strictly stronger than asking the string was:
+		// `verifyGraph.spec.ts` additionally pins that every OTHER stage of the old chain
+		// is still in it, which the `toInclude` never checked for any of them.
+		expect(
+			STAGES.map((s) => s.script),
+			'`verify` must still run the e2e suite',
+		).toContain('e2e');
 		expect(pkg.scripts.e2e).toInclude('e2e/playwright.config.ts');
 	});
 });

package/src/react/components/TagsInput.spec.tsx

@@ -71,3 +71,37 @@ describe('TagsInput', () => {
     expect(json(container)).toEqual(['late']);
   });
 });
+
+describe('suggestions', () => {
+  test('offers a datalist of suggestions, minus what is already committed', () => {
+    const { container } = render(
+      <TagsInput value={['work']} onChange={() => undefined} suggestions={['work', 'bank']} />,
+    );
+    const input = container.querySelector('input') as HTMLInputElement;
+    const list = container.querySelector('datalist') as HTMLDataListElement;
+    expect(list).not.toBeNull();
+    expect(input.getAttribute('list')).toBe(list.id);
+    const offered = [...list.querySelectorAll('option')].map((o) => o.getAttribute('value'));
+    expect(offered).toEqual(['bank']);
+  });
+
+  test('🔴 suppression is case-insensitive — "Bank" committed hides the suggestion "bank"', () => {
+    // mergeTags dedupes case-SENSITIVELY, so offering "bank" back beside a committed
+    // "Bank" would commit a second, differently-spelled chip — the exact drift a
+    // suggestion list exists to prevent.
+    const { container } = render(
+      <TagsInput value={['Bank']} onChange={() => undefined} suggestions={['bank', 'tax']} />,
+    );
+    const offered = [...container.querySelectorAll('datalist option')].map((o) =>
+      o.getAttribute('value'),
+    );
+    expect(offered).toEqual(['tax']);
+  });
+
+  test('no suggestions → no datalist and no dangling list attribute', () => {
+    const { container } = render(<TagsInput value={[]} onChange={() => undefined} />);
+    expect(container.querySelector('datalist')).toBeNull();
+    const input = container.querySelector('input') as HTMLInputElement;
+    expect(input.getAttribute('list')).toBeNull();
+  });
+});

package/src/react/components/TagsInput.tsx

@@ -1,5 +1,5 @@
 import { X } from 'lucide-react';
-import { type KeyboardEvent, useState } from 'react';
+import { type KeyboardEvent, useId, useState } from 'react';
 import { cn } from '../lib/cn';
 import { CONTROL_MIN_HEIGHT_CLASS, type ControlSize } from '../lib/field';
 import { IconButton } from './IconButton';
@@ -14,6 +14,13 @@ export interface TagsInputProps {
   disabled?: boolean;
   /** Cap the number of tags; the input hides once reached. */
   maxTags?: number;
+  /**
+   * Tags to offer as you type — the vocabulary already in use, so a re-tag matches
+   * the first spelling instead of minting "Bank"/"bank"/"banking" three ways. A
+   * native `<datalist>` (the browser owns the dropdown and its accessibility), and
+   * tags already committed on this value are not re-offered. Omit for none.
+   */
+  suggestions?: readonly string[];
   id?: string;
   name?: string;
   'aria-invalid'?: true | undefined;
@@ -54,6 +61,7 @@ export function TagsInput({
   maxTags,
   id,
   name,
+  suggestions,
   'aria-invalid': ariaInvalid,
   'aria-label': ariaLabel,
   'aria-describedby': ariaDescribedBy,
@@ -61,7 +69,13 @@ export function TagsInput({
   size = 'md',
 }: TagsInputProps) {
   const [draft, setDraft] = useState('');
+  const listId = useId();
   const atMax = maxTags != null && value.length >= maxTags;
+  // Case-insensitive: a committed "Bank" must suppress the suggestion "bank" —
+  // offering it back commits nothing (mergeTags dedupes case-sensitively, so it
+  // WOULD land as a second chip) and reads as the field suggesting a duplicate.
+  const committed = new Set(value.map((tag) => tag.toLowerCase()));
+  const offered = (suggestions ?? []).filter((tag) => !committed.has(tag.toLowerCase()));
 
   const commit = (raw: string) => {
     const next = mergeTags(value, [raw]);
@@ -121,6 +135,7 @@ export function TagsInput({
           aria-label={ariaLabel}
           aria-describedby={ariaDescribedBy}
           autoComplete='off'
+          list={offered.length > 0 ? listId : undefined}
           onChange={(e) => {
             const v = e.target.value;
             if (v.includes(',')) {
@@ -141,6 +156,13 @@ export function TagsInput({
           className='min-w-24 flex-1 bg-transparent py-0.5 text-base text-field-fg outline-none placeholder:text-field-placeholder sm:text-sm'
         />
       ) : null}
+      {offered.length > 0 ? (
+        <datalist id={listId}>
+          {offered.map((tag) => (
+            <option key={tag} value={tag} />
+          ))}
+        </datalist>
+      ) : null}
     </div>
   );
 }

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

@@ -68,6 +68,8 @@ import type {
 } from 'react';
 import { Fragment, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import {
+  type AccessMarkCopy,
+  accessMarkCopy,
   describeDrop,
   descendantIdsOf,
   type DropOffer,
@@ -225,6 +227,19 @@ export interface FileTreeProps {
   /** Whether an in-flight external drag is one this tree wants. Default: any drag. */
   acceptsExternalDrag?: (event: ReactDragEvent) => boolean;
 
+  /**
+   * What the 🔒 access mark SAYS, per access state — hover text on the mark a row
+   * with `access: 'private' | 'locked'` draws.
+   *
+   * 🔴 The defaults speak collections' vocabulary ("hidden from a locked page"),
+   * because that is the app the mark was built for — but the mark itself is generic
+   * and the words are not. The vault's protected folders wear the same padlock
+   * meaning "everything in here needs the master password", and a tooltip claiming
+   * they are hidden would be false: the rows are visible, their SECRETS are sealed.
+   * An app whose privacy model has its own name passes its own words.
+   */
+  accessCopy?: AccessMarkCopy;
+
   /** Narrow the tree to matching rows, keeping the folders on the way to each. */
   filter?: string;
   /** What to show when there are no rows — differs between "nothing here" and "no match". */
@@ -331,6 +346,7 @@ export function FileTree({
   renderAccessory,
   onDropExternal,
   acceptsExternalDrag,
+  accessCopy,
   filter,
   empty = 'Nothing here yet.',
   ariaLabel = 'Files',
@@ -1255,18 +1271,10 @@ export function FileTree({
                   is the twisty's, and a folder losing its arrow would lose the control that
                   opens it) and never moves with how many actions a consumer wired up.
                 */}
+                {/* The mark's words are the consumer's when it has its own privacy
+                    vocabulary — see accessMarkCopy for why the defaults are collections'. */}
                 {node.access === 'private' || node.access === 'locked' ? (
-                  <Tooltip
-                    content={
-                      node.access === 'locked'
-                        ? 'Hidden — unlock to see what is in here'
-                        : // Deliberately "this or what is in it": a consumer sets `private` both
-                          // for a row that is itself private and for a public folder holding
-                          // private children (collections does exactly that), and a wording that
-                          // claimed only the first would be false on half the rows it marks.
-                          'Private — this, or something in it, is hidden from a locked page'
-                    }
-                  >
+                  <Tooltip content={accessMarkCopy(node.access, accessCopy)}>
                     {/* Not `aria-hidden`: this is the one thing on the row a screen reader
                         cannot work out from anything else, and the name alone would announce a
                         private folder identically to a public one. */}

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

@@ -13,6 +13,8 @@
 //
 // Its own subpath so an app with a flat list never pulls the gesture in.
 export {
+  type AccessMarkCopy,
+  accessMarkCopy,
   descendantIdsOf,
   type DropOffer,
   type FileTreeAccess,