cursedbelt 3.0.2 → 4.1.0

package/dist/react/components/ListToolbar.d.ts

@@ -0,0 +1,94 @@
+import type { ReactNode } from 'react';
+import { type ChipOption } from './ChipFilterStrip';
+export interface ListToolbarProps {
+    /**
+     * The search text. The box renders only when BOTH this and `onSearchChange`
+     * are given — a search input nobody is listening to is worse than none.
+     */
+    search?: string;
+    onSearchChange?: (value: string) => void;
+    /** What the reader can type, in the reader's terms — `'file name, repo or title'`. */
+    searchPlaceholder?: string;
+    /**
+     * The box's accessible name. Say WHAT is being searched (*"Search the queue"*),
+     * because a page with two lists gives a screen reader two boxes called "Search".
+     * Falls back to the placeholder, then to `'Search'`.
+     */
+    searchLabel?: string;
+    /**
+     * The filter chips — one dimension of the list, as data. An EMPTY array renders
+     * nothing at all: {@link ChipFilterStrip} always draws its "All" pill, and a lone
+     * "All" chip filtering nothing is noise on the line (`ConsoleView` filters its
+     * bucket chips down to the buckets that have rows, and can reach zero).
+     */
+    chips?: readonly ChipOption[];
+    /** Selected chip(s). `null` / `[]` is the "All" state. Default `null`. */
+    chipValue?: string | string[] | null;
+    onChipChange?: (value: string | string[] | null) => void;
+    /** Let more than one chip be active at once. Default `false`. */
+    multiChips?: boolean;
+    /** Label for the chips' clear-all pill. Default `'All'`. */
+    chipsAllLabel?: string;
+    /** Any further FILTER controls — they sit left, after the chips. */
+    filters?: ReactNode;
+    /** The sort control (a `NativeSelect`, a `ChoiceMenu`, …). Right-hand cluster. */
+    sort?: ReactNode;
+    /** The density/view-mode control — normally a `TableViewToggle`. Right-hand cluster. */
+    view?: ReactNode;
+    /** The far right: the one thing this page DOES. */
+    actions?: ReactNode;
+    className?: string;
+}
+/**
+ * The toolbar above a list: ONE line, filters left, view controls and actions right.
+ *
+ * DESIGN.md §2, quoted because this component is nothing but that paragraph:
+ * *"Never scatter operational controls or filter tabs across multi-row lines. Merge
+ * navigation filters, search boxes, query parameters, execution buttons, and
+ * destructive triggers into a single cohesive layout line. Position filters to the
+ * left/center and main execution actions to the far right."*
+ *
+ * ── Why this is in the design system, not in the app ───────────────────────
+ * `apps/station` composed exactly this shape inline on BOTH of its lists — the queue
+ * (`ConsoleView`) and the intake (`IdeasView`) — about thirty identical lines each,
+ * differing only in their options. The retired `cursed-satellites` station had already
+ * met that fork and said so in `BoardChrome.tsx`'s header: two boards with the same
+ * INTERACTION built twice give you *"two toolbars that drift apart on the first change
+ * to either"*. Task `183` was right to forbid a station-local component and `184` is
+ * the consequence: the shape belongs to every app's list, so it lives here.
+ *
+ * ── Layout only. It has no memory ─────────────────────────────────────────
+ * 🔴 Search text, the chosen chips, the sort key and the view mode are all the
+ * caller's state, and one of them is already solved elsewhere: `useTableViewMode`
+ * persists rows ⇄ cards per account, server-side. A toolbar that grew its own
+ * storage would either fight that hook or quietly become a second, local, worse copy
+ * of it. `sort`/`view`/`actions` are SLOTS for the same reason — this one must work
+ * for `MasterDetail` pages and card grids, which is why it is not {@link TableToolbar}
+ * (that one reads everything off a TanStack `table` and cannot exist without one).
+ *
+ * ── `flex-wrap`, and no `role='toolbar'` ──────────────────────────────────
+ * Wrapping, not a grid and not a breakpoint swap: the console runs at 1440 on a desk
+ * and 390 on a phone, and wrapping is the one behaviour that keeps DESIGN.md §5's 44px
+ * targets at both widths without a second layout. `ml-auto` on the right-hand cluster
+ * keeps the controls right when everything fits on one line and lets them ride down as
+ * a group when it does not.
+ *
+ * No `role='toolbar'`: that role promises arrow-key roving focus between its controls,
+ * which would take the arrow keys away from the text box and the native `<select>`
+ * that live on this line. Tab order is the correct affordance here.
+ *
+ * @example
+ * <ListToolbar
+ *   search={search}
+ *   onSearchChange={setSearch}
+ *   searchPlaceholder='file name, repo or title'
+ *   searchLabel='Search the queue'
+ *   chips={buckets}
+ *   chipValue={filter}
+ *   onChipChange={(v) => setFilter(typeof v === 'string' ? v : null)}
+ *   sort={<NativeSelect size='sm' aria-label='Sort the queue' … />}
+ *   view={<TableViewToggle value={view.mode} onChange={view.setMode} />}
+ * />
+ */
+export declare function ListToolbar({ search, onSearchChange, searchPlaceholder, searchLabel, chips, chipValue, onChipChange, multiChips, chipsAllLabel, filters, sort, view, actions, className, }: ListToolbarProps): import("react").JSX.Element;
+//# sourceMappingURL=ListToolbar.d.ts.map

package/dist/react/components/ListToolbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ListToolbar.d.ts","sourceRoot":"","sources":["../../../src/react/components/ListToolbar.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGrE,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,sFAAsF;IACtF,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IAC9B,0EAA0E;IAC1E,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CAAC;IACrC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,KAAK,IAAI,CAAC;IACzD,iEAAiE;IACjE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,4DAA4D;IAC5D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,oEAAoE;IACpE,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,kFAAkF;IAClF,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,wFAAwF;IACxF,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,mDAAmD;IACnD,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,WAAW,CAAC,EAC1B,MAAM,EACN,cAAc,EACd,iBAAiB,EACjB,WAAW,EACX,KAAK,EACL,SAAgB,EAChB,YAAY,EACZ,UAAkB,EAClB,aAAa,EACb,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,OAAO,EACP,SAAS,GACV,EAAE,gBAAgB,+BAuClB"}

package/dist/react/components/ListToolbar.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from '../lib/cn';
+import { ChipFilterStrip } from './ChipFilterStrip';
+import { Input } from './Input';
+/**
+ * The toolbar above a list: ONE line, filters left, view controls and actions right.
+ *
+ * DESIGN.md §2, quoted because this component is nothing but that paragraph:
+ * *"Never scatter operational controls or filter tabs across multi-row lines. Merge
+ * navigation filters, search boxes, query parameters, execution buttons, and
+ * destructive triggers into a single cohesive layout line. Position filters to the
+ * left/center and main execution actions to the far right."*
+ *
+ * ── Why this is in the design system, not in the app ───────────────────────
+ * `apps/station` composed exactly this shape inline on BOTH of its lists — the queue
+ * (`ConsoleView`) and the intake (`IdeasView`) — about thirty identical lines each,
+ * differing only in their options. The retired `cursed-satellites` station had already
+ * met that fork and said so in `BoardChrome.tsx`'s header: two boards with the same
+ * INTERACTION built twice give you *"two toolbars that drift apart on the first change
+ * to either"*. Task `183` was right to forbid a station-local component and `184` is
+ * the consequence: the shape belongs to every app's list, so it lives here.
+ *
+ * ── Layout only. It has no memory ─────────────────────────────────────────
+ * 🔴 Search text, the chosen chips, the sort key and the view mode are all the
+ * caller's state, and one of them is already solved elsewhere: `useTableViewMode`
+ * persists rows ⇄ cards per account, server-side. A toolbar that grew its own
+ * storage would either fight that hook or quietly become a second, local, worse copy
+ * of it. `sort`/`view`/`actions` are SLOTS for the same reason — this one must work
+ * for `MasterDetail` pages and card grids, which is why it is not {@link TableToolbar}
+ * (that one reads everything off a TanStack `table` and cannot exist without one).
+ *
+ * ── `flex-wrap`, and no `role='toolbar'` ──────────────────────────────────
+ * Wrapping, not a grid and not a breakpoint swap: the console runs at 1440 on a desk
+ * and 390 on a phone, and wrapping is the one behaviour that keeps DESIGN.md §5's 44px
+ * targets at both widths without a second layout. `ml-auto` on the right-hand cluster
+ * keeps the controls right when everything fits on one line and lets them ride down as
+ * a group when it does not.
+ *
+ * No `role='toolbar'`: that role promises arrow-key roving focus between its controls,
+ * which would take the arrow keys away from the text box and the native `<select>`
+ * that live on this line. Tab order is the correct affordance here.
+ *
+ * @example
+ * <ListToolbar
+ *   search={search}
+ *   onSearchChange={setSearch}
+ *   searchPlaceholder='file name, repo or title'
+ *   searchLabel='Search the queue'
+ *   chips={buckets}
+ *   chipValue={filter}
+ *   onChipChange={(v) => setFilter(typeof v === 'string' ? v : null)}
+ *   sort={<NativeSelect size='sm' aria-label='Sort the queue' … />}
+ *   view={<TableViewToggle value={view.mode} onChange={view.setMode} />}
+ * />
+ */
+export function ListToolbar({ search, onSearchChange, searchPlaceholder, searchLabel, chips, chipValue = null, onChipChange, multiChips = false, chipsAllLabel, filters, sort, view, actions, className, }) {
+    const showSearch = search !== undefined && onSearchChange !== undefined;
+    const showChips = chips !== undefined && chips.length > 0 && onChipChange !== undefined;
+    const showRight = Boolean(sort) || Boolean(view) || Boolean(actions);
+    return (_jsxs("div", { className: cn('flex flex-wrap items-center gap-x-3 gap-y-2', className), children: [showSearch ? (_jsx(Input, { type: 'search', value: search, onChange: (e) => onSearchChange(e.currentTarget.value), placeholder: searchPlaceholder, "aria-label": searchLabel ?? searchPlaceholder ?? 'Search', 
+                // Full width on a phone (the chips then wrap beneath it, still tappable);
+                // a fixed, modest column from `sm:` so the chips share the line rather than
+                // being pushed off it by a box that grows with the container.
+                className: 'w-full min-w-40 sm:w-56' })) : null, showChips ? (_jsx(ChipFilterStrip, { options: [...chips], value: chipValue, onChange: onChipChange, multi: multiChips, ...(chipsAllLabel === undefined ? {} : { allLabel: chipsAllLabel }) })) : null, filters, showRight ? (_jsxs("span", { className: 'ml-auto flex flex-wrap items-center gap-2', children: [sort, view, actions] })) : null] }));
+}
+//# sourceMappingURL=ListToolbar.js.map

package/dist/react/components/ListToolbar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ListToolbar.js","sourceRoot":"","sources":["../../../src/react/components/ListToolbar.tsx"],"names":[],"mappings":";AACA,OAAO,EAAE,EAAE,EAAE,MAAM,WAAW,CAAC;AAC/B,OAAO,EAAE,eAAe,EAAmB,MAAM,mBAAmB,CAAC;AACrE,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AA0ChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,MAAM,UAAU,WAAW,CAAC,EAC1B,MAAM,EACN,cAAc,EACd,iBAAiB,EACjB,WAAW,EACX,KAAK,EACL,SAAS,GAAG,IAAI,EAChB,YAAY,EACZ,UAAU,GAAG,KAAK,EAClB,aAAa,EACb,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,OAAO,EACP,SAAS,GACQ;IACjB,MAAM,UAAU,GAAG,MAAM,KAAK,SAAS,IAAI,cAAc,KAAK,SAAS,CAAC;IACxE,MAAM,SAAS,GAAG,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,YAAY,KAAK,SAAS,CAAC;IACxF,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAErE,OAAO,CACL,eAAK,SAAS,EAAE,EAAE,CAAC,6CAA6C,EAAE,SAAS,CAAC,aACzE,UAAU,CAAC,CAAC,CAAC,CACZ,KAAC,KAAK,IACJ,IAAI,EAAC,QAAQ,EACb,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC,aAAa,CAAC,KAAK,CAAC,EACtD,WAAW,EAAE,iBAAiB,gBAClB,WAAW,IAAI,iBAAiB,IAAI,QAAQ;gBACxD,0EAA0E;gBAC1E,4EAA4E;gBAC5E,8DAA8D;gBAC9D,SAAS,EAAC,yBAAyB,GACnC,CACH,CAAC,CAAC,CAAC,IAAI,EACP,SAAS,CAAC,CAAC,CAAC,CACX,KAAC,eAAe,IACd,OAAO,EAAE,CAAC,GAAG,KAAK,CAAC,EACnB,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,UAAU,KACb,CAAC,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,aAAa,EAAE,CAAC,GACpE,CACH,CAAC,CAAC,CAAC,IAAI,EACP,OAAO,EACP,SAAS,CAAC,CAAC,CAAC,CACX,gBAAM,SAAS,EAAC,2CAA2C,aACxD,IAAI,EACJ,IAAI,EACJ,OAAO,IACH,CACR,CAAC,CAAC,CAAC,IAAI,IACJ,CACP,CAAC;AACJ,CAAC"}

package/dist/react/file-tree/FileTree.d.ts

@@ -26,7 +26,8 @@
  * graduation. They are here now and each says so where it lives:
  *
  *   1. **Reveal** — the selected row is scrolled into view, and a shut folder holding it is
- *      marked and scrolled to instead of being forced open (see the effect below).
+ *      marked and scrolled to rather than forced open unless `expandOnReveal` says otherwise
+ *      (see the effect below, and the section on it).
  *   2. **The path is marked** — `data-ancestor` on the folders between the root and the
  *      selection, `data-holds-open` on the shut one holding it (`openPath`).
  *   3. **Escape cancels a drag** (`beginDrag`), which `pointercancel` never did.
@@ -45,6 +46,100 @@
  * needs and a design system should not have is an argument for a prop, not for a copy: the
  * three claimants collapse into one `selectedId`, and a kind-specific glyph is `renderIcon`.
  *
+ * ── 🔴 Multi-select, 2026-09-15 — and why `selectedId` did not move ─────────────────────
+ * Owner, `ideas/file-tree.md` item 2: shift-click a range, ⌘-click to add one, drag the whole
+ * selection to another folder or to the root, ⌘⌫ the lot, and ⌘X/⌘C/⌘V to move or copy them.
+ * Three apps were waiting on it and none of them forked the component to get it.
+ *
+ * Every one of those is a change to this SHARED contract, and the trap in it is that
+ * `selectedId: string | null` is load-bearing in all three: it is the row the main pane is
+ * showing in `apps/collections`, and the folder the library is filtered by in `apps/music`.
+ * So it did not move. {@link FileTreeProps.selectedIds} sits BESIDE it, the selection is
+ * `[selectedId]` for a consumer that passes neither, and every plural callback is its own
+ * optional prop — `onMoveMany`, `onDeleteMany`, `onCopy` — with one rule holding it together:
+ * **N > 1 goes through the plural verb, and without it the gesture acts on the one row it
+ * started on**. A tree that silently became multi-select would have broken "what am I looking
+ * at" in two shipped apps on the day it published.
+ *
+ * The arithmetic is `fileTreeSelection.ts`, DOM-free and unit-tested, for the same reason
+ * `core/file-tree/fileTreeModel.ts` is: happy-dom computes no layout, so the pointer half of
+ * a multi-drag cannot be asserted anywhere and the RULES have to be reachable without it.
+ *
+ * ── 🔴 New Folder with Selection, 2026-09-16 ────────────────────────────────────────────
+ * Owner, 2026-09-13: *"allow make dir from file where dir wraps file location and gets name
+ * of file"*. Half of it was already here — the {@link FileTreeProps.draft} row, which names a
+ * folder before anything is created — and the other half is `onMove`/`onMoveMany`, so this is
+ * one gesture out of two things that existed rather than a new mechanism: the draft grew a
+ * `wrap` list, and committing hands the name AND the ids back in a single call. Two calls is
+ * how a folder ends up made and empty when the second one fails.
+ *
+ * It is Finder's *New Folder with Selection* and VS Code's ⌃⌘N, invented no further: the
+ * folder is made where the row already is, named after it with the extension dropped, and the
+ * row moves in. A selection of twenty is the same code path with N > 1, named after the first
+ * in TREE order — see `planWrap`, which is where all of that is decided without a DOM.
+ *
+ * ── 🔴 Pinned rows, 2026-09-16 ──────────────────────────────────────────────────────────
+ * Owner, 2026-09-13: *"need ces ability to pin open files where they stay at the top of the
+ * file tree in a new section above the folders. Pinned will mean I want to keep them there
+ * until I unpin them. This makes it easier to keep track of important files and folders. They
+ * still will exist in the folder they were stored in and unpinning takes it back to normal.
+ * Pinning or unpinning one place doesn't change pinning in the other place."*
+ *
+ * Five things in that paragraph, and the last two are the ones a sort order loses:
+ *
+ *   1. **A SECTION, not an order.** A pinned row is drawn TWICE — once at the top and once
+ *      where it lives, because *"they still will exist in the folder they were stored in"*.
+ *      Lifting the row out would make pinning a move, and unpinning an undo of one.
+ *   2. **Files and folders both** — *"important files and folders"*.
+ *   3. **Sticky until unpinned.** It is not a recents list and it does not age out, which is
+ *      why the list is the consumer's to persist rather than the tree's to remember.
+ *   4. **Unpinning leaves nothing behind**: the top copy goes and the row in the folder is
+ *      the row it always was.
+ *   5. 🔴 **Per place.** *"Pinning or unpinning one place doesn't change pinning in the other
+ *      place."* That is free here and only because the state is CONTROLLED — the consumer
+ *      holds one list per tree, exactly as `media/stageResize.ts` holds one height per
+ *      consumer key (*"one shared key would make sizing either of them silently resize the
+ *      other"* — the same defect, one surface along).
+ *
+ * 🔴 **One identity, two row keys.** Every selection, drag, reveal and aria path in here is
+ * keyed on `node.id`, and drawing a row twice would break each of them if both copies claimed
+ * the same key: `openPath`/`data-holds-open` walks for the selected row and would find the
+ * pinned copy, marking the wrong ancestors. So the node's id stays its identity and the COPY
+ * is addressed separately — two ref maps (`rowRefs`, `pinnedRefs`), and `focused` says which
+ * section it is in. `apps/collections` makes the same split with `itemRowId`/`nodeRowId`.
+ *
+ * 🔴 **Its own `role='tree'`, outside the scroller.** `aria-setsize`/`aria-posinset` below are
+ * computed from the rows ON SCREEN, on the stated assumption that every sibling of a visible
+ * row is itself visible — folding pins into that row list would make the counts wrong for
+ * every row in the tree. The section is a separate widget with counts of its own, and it sits
+ * ABOVE `.cbft-scroll` rather than sticky inside it, so the reveal below, the autoscroll and
+ * the blank-space drop target all still mean exactly what they meant.
+ *
+ * The pinned copy is a SHORTCUT, not a second editing surface: it is flat (no twisty, no
+ * depth), a drop aimed at it lands in the real folder, and the rename field draws on the real
+ * row whenever the real row is on screen.
+ *
+ * ── 🔴 The reveal OPENS the folder now, if it is asked to, 2026-09-16 ───────────────────
+ * Owner, `ideas/collections-09-14.md`: *"clicking a file in media gallery content window
+ * should show that file in the file tree by like vscode does when you select a tab with a
+ * file in it."* Almost all of that was already here — `selectedId`, `openPath`,
+ * `data-ancestor`/`data-holds-open` and the scroll — and the one thing missing was the one
+ * thing this file had DECIDED against: limit 1 of the reveal, *a shut folder stays shut*.
+ *
+ * He named VS Code, whose `explorer.autoReveal` is `true` and expands, and he named the exact
+ * gesture. So the ask wins over the default, and the decision is recorded in full on the
+ * effect itself rather than here: {@link FileTreeProps.expandOnReveal} is OFF unless a
+ * consumer wires it, and what it opens goes into an overlay of this component's own
+ * (`revealOpened`) which is **never handed to `onCollapsedChange`**. The persisted collapse
+ * is read back unchanged on the next mount, which is the half of limit 1's objection that was
+ * never a matter of taste.
+ *
+ * 🔴 Silent is not the same as invisible, and {@link FileTreeProps.onRevealExpand} is the
+ * difference. A tree that FETCHES a folder's children when it opens — `apps/collections` asks
+ * the server per open folder — would otherwise draw the folder the reveal opened with nothing
+ * in it, because the consumer never learned the expansion happened. So it is told, in a
+ * callback that exists to feed a fetch plan and explicitly not to be stored.
+ *
  * ── Pointer events, not HTML5 drag-and-drop, for INTERNAL drags ─────────────────────────
  * The ghost image is a translucent screenshot nobody asked for, `dragover` fires at the
  * mercy of the browser, and touch does not have HTML5 dnd at all. The drag only *starts*
@@ -68,6 +163,29 @@ export interface FileTreeProps {
     /** The row drawn as selected — usually "what the main pane is showing". */
     selectedId: string | null;
     onSelect: (node: FileTreeNode) => void;
+    /**
+     * The rows drawn as selected when there is more than one — shift-click and ⌘-click.
+     *
+     * 🔴 BESIDE {@link selectedId}, never instead of it, and that is the whole shape of this
+     * feature. `selectedId` is load-bearing in every consumer this tree has: in
+     * `apps/collections` it is the row the main pane is showing, in `apps/music` it is the
+     * folder the library is filtered by. Those are singular questions with singular answers,
+     * and a tree that silently became multi-select would break "what am I looking at" in two
+     * shipped apps on the day it published. So a consumer that passes neither this nor
+     * {@link onSelectionChange} gets EXACTLY today's behaviour, byte for byte.
+     *
+     * Omit it and the selection is `[selectedId]`, which is what makes ⌘-click work for a
+     * consumer that stores only the one id and grows into the array afterwards.
+     */
+    selectedIds?: readonly string[];
+    /**
+     * The selection changed by a gesture. **Wiring it is what turns multi-select on.**
+     *
+     * A plain click reports `[id]` and still calls {@link onSelect}; shift-click and ⌘-click
+     * report the new set and do NOT — in every file explorer, extending a selection is not
+     * also navigating, and in a consumer that opens on select it would be.
+     */
+    onSelectionChange?: (ids: string[]) => void;
     /**
      * Double-click, or Space on a focused row. Falls back to `onSelect` when omitted.
      *
@@ -77,11 +195,95 @@ export interface FileTreeProps {
     /** Shut folders, as a controlled value. Omit both for the tree's own memory. */
     collapsed?: readonly string[];
     onCollapsedChange?: (next: string[]) => void;
+    /**
+     * **Open the shut folders on the way to the selection**, instead of marking the shut one
+     * and stopping there — VS Code's `explorer.autoReveal`, which is on by default over there.
+     *
+     * Owner, `ideas/collections-09-14.md`: *"clicking a file in media gallery content window
+     * should show that file in the file tree by like vscode does when you select a tab with a
+     * file in it."* He named the application and he named the gesture, so this is what the
+     * reveal does when it is asked for by name — see limit 1 on the reveal effect for the
+     * argument this prop is the opt-in half of, and why it stays the default.
+     *
+     * 🔴 **It never touches {@link collapsed}.** The folders it opens are held in an overlay of
+     * the tree's own and {@link onCollapsedChange} is not called, so the collapse the consumer
+     * persisted is still the collapse it persisted — on the next mount the tree reads it back
+     * unchanged. Shutting one of them by hand drops it from the overlay and the persisted value
+     * decides again; nothing about it is ever written out. That is the whole of the objection
+     * limit 1 records, answered without giving up the behaviour he asked for.
+     *
+     * Off unless it is wired, like every other verb here: a consumer that passes nothing gets
+     * byte for byte today's reveal.
+     */
+    expandOnReveal?: boolean;
+    /**
+     * The folders {@link expandOnReveal} just opened, told to the consumer once per reveal.
+     *
+     * 🔴 **Not a request to persist them** — that is the one thing this must never be read as,
+     * and the whole reason the overlay exists. It is for a tree whose children are FETCHED when
+     * a folder opens: `apps/collections` asks the server for a folder's files only for the
+     * folders it believes are open (`ExplorerSidebar.tsx` → `nodesToFetch`), so an expansion it
+     * cannot see would draw the folder open and EMPTY, with the file the reveal was asked for
+     * still missing. A silent overlay is the right default and an unobservable one is a trap.
+     *
+     * Wire it to whatever decides the fetch plan, never to the stored collapse.
+     */
+    onRevealExpand?: (ids: readonly string[]) => void;
+    /**
+     * The rows kept in a section of their own ABOVE the folders — *"pin open files where they
+     * stay at the top of the file tree in a new section above the folders"*.
+     *
+     * Files and folders both, in the order they were pinned, and a pin the tree no longer holds
+     * is simply not drawn rather than drawn as a ghost. Each one appears TWICE: at the top and
+     * in the folder it lives in, which is the requirement — *"they still will exist in the
+     * folder they were stored in"*.
+     *
+     * 🔴 CONTROLLED, with no fallback to a memory of the tree's own — the one place this
+     * differs from {@link collapsed}, and deliberately. *"Pinned will mean I want to keep them
+     * there until I unpin them"*: a list this component remembered would be a list that
+     * evaporated on the next mount, which is the opposite of what the word means. Holding it
+     * outside is also the whole of *"pinning or unpinning one place doesn't change pinning in
+     * the other place"* — one list per tree, per app, wherever the consumer persists it, the
+     * same reasoning `media/stageResize.ts` records for its per-consumer height key.
+     *
+     * Omit it and there is no section, no pin control and no chord: byte for byte today's tree.
+     */
+    pinnedIds?: readonly string[];
+    /**
+     * Pin or unpin a row. **Wiring it is what puts the pin control on every row and ⌃⌘T on the
+     * keyboard**, the same rule every other verb here follows.
+     *
+     * The next list arrives whole (a new pin is appended, so the section keeps the order it was
+     * built in) and the consumer stores it. Pass {@link pinnedIds} without this to draw a
+     * read-only section and put the unpin on your own ⋯ menu.
+     */
+    onPinnedChange?: (next: string[]) => void;
+    /**
+     * What the pinned section is called — its heading, and its `aria-label`. Default `Pinned`.
+     *
+     * An app whose vocabulary differs ("Favourites", "Starred") passes its own, for the same
+     * reason {@link accessCopy} exists: the mechanism is general and the words are not.
+     */
+    pinnedLabel?: string;
     /**
      * Commit a drag. Omit it and the tree cannot be rearranged at all — no press starts a
      * drag, and {@link unavailableReason} says why on hover.
      */
     onMove?: (nodeId: string, drop: FileTreeDrop) => void;
+    /**
+     * Commit a move of MORE THAN ONE row — a dragged selection, or ⌘X then ⌘V.
+     *
+     * 🔴 The single rule that keeps every plural gesture from surprising an old consumer:
+     * **N > 1 always goes through this prop, and without it every gesture degrades to the one
+     * row it started on.** A tree that fell back to calling `onMove` N times would hand a
+     * consumer N separate writes against a tree that is re-derived between each of them, which
+     * is how a batch move half-lands.
+     *
+     * The ids arrive with descendants of other selected rows already removed — see
+     * `topmostSelected`. Moving a folder moves what is in it, so a selected child is the same
+     * move named twice, and acting on both flattens the child out of its own parent.
+     */
+    onMoveMany?: (nodeIds: readonly string[], drop: FileTreeDrop) => void;
     /** See `ResolveDropOptions.allowReorder`. Off unless the consumer stores an order. */
     allowReorder?: boolean;
     /** Words for refusing a drop into a node whose `acceptsDrop` is false. */
@@ -115,18 +317,95 @@ export interface FileTreeProps {
      * consumer owns the confirmation — this only reports which row the key was pressed on.
      */
     onDelete?: (node: FileTreeNode) => void;
+    /**
+     * The same keys on a SELECTION of more than one — *"hold command and click delete to
+     * delete all the selected files"*.
+     *
+     * Without it, ⌫ on a multi-selection deletes the focused row alone, which is today's
+     * behaviour and a consumer that never asked for the plural keeps it. The nodes are handed
+     * over rather than the ids, because a confirmation dialog needs their names.
+     */
+    onDeleteMany?: (nodes: readonly FileTreeNode[]) => void;
+    /**
+     * ⌘C then ⌘V — *"Copying should allow copying in another folder or the same folder."*
+     *
+     * Wiring it is what puts ⌘C on the keyboard at all. `drop` is where the paste landed,
+     * resolved by exactly the rules a drag obeys, so a copy can never reach a destination the
+     * pointer refuses.
+     */
+    onCopy?: (nodeIds: readonly string[], drop: FileTreeDrop) => void;
+    /**
+     * The consumer's veto on copying a row — words to refuse with, `null` to allow. The same
+     * shape as {@link canDrop}, and consulted BEFORE ⌘C takes, never after ⌘V.
+     *
+     * 🔴 Copy is the one clipboard verb that is not universal. A folder in `apps/music` is
+     * derived from the `folder` column of the tracks in it, so copying one would mean
+     * duplicating audio there is exactly one copy of — the tree must not assume every consumer
+     * can paste. See `refuseCopy`.
+     */
+    canCopy?: (node: FileTreeNode) => string | null;
     /**
      * A row being named that does not exist yet — the "New folder" gesture.
      *
      * 🔴 Nothing is created until the name is committed. A folder made first and renamed
      * afterwards is a row that spent a moment called "untitled", and a row in the way if the
      * field is cancelled.
+     *
+     * `wrap` is the same draft asked to close AROUND rows that already exist — *"allow make
+     * dir from file where dir wraps file location and gets name of file"*, which is Finder's
+     * **New Folder with Selection** and VS Code's ⌃⌘N. It is the ids to re-file into the
+     * folder the moment it is made; the field opens pre-filled with the first one's name minus
+     * its extension, and {@link onWrapStart} is how the tree ASKS for one of these.
      */
     draft?: {
         parentId: string | null;
+        wrap?: readonly string[];
     } | null;
-    onDraftCommit?: (name: string) => void;
+    /**
+     * The name was committed: make the folder.
+     *
+     * 🔴 `wrap` arrives in the SAME call, never as a second one, and that is the whole reason
+     * this prop grew an argument instead of a sibling callback being added beside it. "Create
+     * the folder, then move four things into it" is two round trips, and the failure mode of
+     * the second one is a folder that exists, is empty, is named after a file that is still
+     * sitting outside it, and that nobody asked for. One call is one transaction on the
+     * consumer's side, which is where the only transaction can be.
+     *
+     * It is absent — not empty — for an ordinary new folder, so a consumer written before this
+     * existed is called exactly as it always was. The ids are pruned of rows inside other
+     * wrapped rows and are in tree order; see `planWrap`.
+     */
+    onDraftCommit?: (name: string, wrap?: readonly string[]) => void;
     onDraftCancel?: () => void;
+    /**
+     * **⌃⌘N** on a focused row — *make a folder around this*. Wiring it is what puts the chord
+     * on the keyboard at all, and a consumer that does not is byte-for-byte unchanged.
+     *
+     * The tree does not own `draft`, so it cannot open one itself: this is the same shape
+     * {@link onRenameStart} has, and the answer to it is to set
+     * `draft = { parentId, wrap: nodes.map(n => n.id) }`. Both arguments are already worked
+     * out — the nodes in tree order with descendants of other chosen rows dropped, and the
+     * parent of the first of them, which is *where the file already is*. Wire a row menu's own
+     * "New folder with selection" to the SAME call so the two cannot drift.
+     *
+     * On a selection of more than one it is the whole selection (Finder's rule); on a row
+     * outside the selection it is that row alone, which is the rule every other plural gesture
+     * here already follows.
+     */
+    onWrapStart?: (nodes: readonly FileTreeNode[], parentId: string | null) => void;
+    /**
+     * The consumer's veto on wrapping a row — words to refuse with, `null` to allow. The twin
+     * of {@link canCopy}, consulted BEFORE the draft opens.
+     *
+     * 🔴 A tree whose folders are DERIVED has nothing to wrap with. `apps/music` builds a
+     * folder out of the `folder` column of the tracks inside it, so there is no folder for this
+     * gesture to make — and offering a name field that cannot be honoured is the "control that
+     * fails on commit" this component refuses everywhere else. See `refuseWrap`.
+     *
+     * A row the consumer marked `draggable: false` is refused without asking, because wrapping
+     * it MOVES it — the same all-or-nothing rule `beginDrag` holds.
+     */
+    canWrap?: (node: FileTreeNode) => string | null;
     /**
      * The focused row's own menu, reached by **Shift+F10** or the **Menu** key — the keyboard's
      * route to whatever {@link renderTools} draws.
@@ -179,5 +458,5 @@ export interface FileTreeProps {
     ariaLabel?: string;
     className?: string;
 }
-export declare function FileTree({ nodes, selectedId, onSelect, onOpen, collapsed: collapsedProp, onCollapsedChange, onMove, allowReorder, lockedReason, canDrop, unavailableReason, renamingId, onRenameStart, onRename, onRenameCancel, onDelete, draft, onDraftCommit, onDraftCancel, onRowMenu, renderTools, renderIcon, renderAccessory, onDropExternal, acceptsExternalDrag, accessCopy, filter, empty, ariaLabel, className, }: FileTreeProps): JSX.Element;
+export declare function FileTree({ nodes, selectedId, onSelect, selectedIds, onSelectionChange, onOpen, collapsed: collapsedProp, onCollapsedChange, expandOnReveal, onRevealExpand, pinnedIds, onPinnedChange, pinnedLabel, onMove, onMoveMany, allowReorder, lockedReason, canDrop, unavailableReason, renamingId, onRenameStart, onRename, onRenameCancel, onDelete, onDeleteMany, onCopy, canCopy, draft, onDraftCommit, onDraftCancel, onWrapStart, canWrap, onRowMenu, renderTools, renderIcon, renderAccessory, onDropExternal, acceptsExternalDrag, accessCopy, filter, empty, ariaLabel, className, }: FileTreeProps): JSX.Element;
 //# sourceMappingURL=FileTree.d.ts.map

package/dist/react/file-tree/FileTree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FileTree.d.ts","sourceRoot":"","sources":["../../../src/react/file-tree/FileTree.tsx"],"names":[],"mappings":"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"}
+{"version":3,"file":"FileTree.d.ts","sourceRoot":"","sources":["../../../src/react/file-tree/FileTree.tsx"],"names":[],"mappings":"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"}