cursedbelt 2.8.0 → 3.0.0

package/dist/core/file-tree/fileTreeModel.js

@@ -1,337 +0,0 @@
-/**
- * The arithmetic behind `react/file-tree` — what is in the tree, what is on screen, and
- * which drops are legal. No DOM, so all of it is unit-tested; the pointer handling, the
- * markers and the keyboard live in the component and are not.
- *
- * ── Where this came from, and why it is here rather than in an app ──────────────────────
- * Owner, 2026-09-08: *"the spreadsheet app has a much better file tree sidebar than
- * collections has. Add the file tree viewer from it into cb so apps like collections can
- * use it."* `cursed-embeddable-spreadsheet`'s `FileTree` is the tree he means — it has been
- * carrying that app's whole navigation for weeks. What made it good is mostly in this file:
- * a drop that cannot happen is never OFFERED, so there is no marker, no highlight and no
- * error toast after the fact — the cursor simply says no while the row is still in the air.
- *
- * ── 🔴 Why this is not `core/folder-tree` ──────────────────────────────────────────────
- * `folder-tree` derives a hierarchy from delimited PATH STRINGS that items carry, and its
- * nodes are the result of that derivation. This models a tree that already exists, whatever
- * produced it: a node has an id, a kind and children, and an app may hand over folders
- * derived from paths (collections), rows from a table, or a mix of both under one root. The
- * two are complementary — collections feeds `buildFolderTree`'s output straight into this —
- * and collapsing them would force every consumer of one to adopt the other's storage shape.
- */
-const childrenOf = (node) => node.kind === 'folder' ? (node.children ?? []) : [];
-/** Every node in the tree, depth-first — the order the rows would be in fully expanded. */
-export function walkFileTree(nodes) {
-    const out = [];
-    const visit = (list) => {
-        for (const node of list) {
-            out.push(node);
-            visit(childrenOf(node));
-        }
-    };
-    visit(nodes);
-    return out;
-}
-export function findFileTreeNode(nodes, id) {
-    for (const node of walkFileTree(nodes))
-        if (node.id === id)
-            return node;
-    return null;
-}
-/**
- * The rows actually on screen, given which folders are shut.
- *
- * 🔴 `collapsed` is the exception list, not `expanded`. A tree derived fresh from the server
- * on every refresh gets new nodes constantly, and an expanded-set model shows each of them
- * shut — so a newly created folder would appear closed and empty at the moment its contents
- * are the thing you are looking for. The exception list defaults everything open, which is
- * also what reads best for the small trees these sidebars hold.
- */
-export function flattenFileTree(nodes, collapsed) {
-    const shut = new Set(collapsed);
-    const out = [];
-    const visit = (list, depth, parentId) => {
-        list.forEach((node, index) => {
-            const kids = childrenOf(node);
-            /*
-             * 🔴 EVERY folder is expandable unless it says otherwise (2026-09-11).
-             *
-             * Owner: *"Make them use an arrow icon next to a dir even when the dir is empty."*
-             * This was `kids.length > 0` and it was wrong in both directions. For a LAZY tree it
-             * is a trap door — a consumer that loads a row's contents only while it is open gives
-             * a collapsed row no children, the row loses its twisty, and it can never be opened
-             * again (measured in `apps/collections`, whose sidebar fetches one folder's files at a
-             * time). For an EAGER tree it draws an empty folder as a leaf, so the one mark that
-             * distinguishes a place from a file disappears exactly while the folder is new and
-             * being filled.
-             *
-             * "A row that claims to open onto nothing is its own small lie" was the old reasoning
-             * and it is answered by what VS Code does: the chevron says *folder*, not *occupied*,
-             * and opening an empty one onto nothing is the honest answer, not a broken promise.
-             * `node.expandable === false` is still honoured for a row that can never hold anything.
-             */
-            const expandable = node.kind === 'folder' && (node.expandable ?? true);
-            const expanded = expandable && !shut.has(node.id);
-            out.push({ node, depth, parentId, index, expandable, expanded });
-            if (expanded)
-                visit(kids, depth + 1, node.id);
-        });
-    };
-    visit(nodes, 0, null);
-    return out;
-}
-/** `id` and everything under it — the set a drag may not land inside. */
-export function descendantIdsOf(nodes, id) {
-    const node = findFileTreeNode(nodes, id);
-    const out = new Set();
-    if (!node)
-        return out;
-    const visit = (n) => {
-        out.add(n.id);
-        for (const child of childrenOf(n))
-            visit(child);
-    };
-    visit(node);
-    return out;
-}
-/**
- * The id of the folder a node sits in — `null` at the top level, and `null` for a node this
- * tree does not contain.
- *
- * 🔴 The two nulls are deliberately one answer. Every caller is asking "where would a move
- * put this", and for a row the tree no longer holds the honest answer is the top level
- * rather than a throw: a tree re-derived from the server between the press and the release
- * can genuinely lose the row under the pointer.
- */
-export function parentIdOf(nodes, id) {
-    const visit = (list, parent) => {
-        for (const node of list) {
-            if (node.id === id)
-                return { at: parent };
-            const found = visit(childrenOf(node), node.id);
-            if (found)
-                return found;
-        }
-        return null;
-    };
-    return visit(nodes, null)?.at ?? null;
-}
-/** The share of a folder row's height that means "into" rather than "between". */
-export const INTO_ZONE = 0.5;
-/**
- * Where the pointer currently is, as a decision.
- *
- * The rule the whole gesture is built around: **a drop that cannot happen is never
- * offered.** Every refusal below returns a reason rather than a null target, so the cursor
- * and the chip can say no while the row is still in the air.
- */
-export function resolveDrop({ nodes, row, offsetRatio, dragId, allowReorder = false, lockedReason = 'That folder is locked', canDrop, }) {
-    // Blank space under the last row: out of every folder. The one gesture that needs no
-    // target, and the only way to say "top level" when the top level has no row of its own.
-    if (!row)
-        return canDrop?.(dragId, { kind: 'root' })
-            ? { target: null, refused: true, reason: canDrop(dragId, { kind: 'root' }) }
-            : { target: { kind: 'root' }, refused: false, reason: null };
-    const forbidden = dragId ? descendantIdsOf(nodes, dragId) : new Set();
-    const target = row.node;
-    /** The consumer's last word on an otherwise-legal target. */
-    const vetted = (offer) => {
-        if (!offer.target || !canDrop)
-            return offer;
-        const reason = canDrop(dragId, offer.target);
-        return reason ? { target: null, refused: true, reason } : offer;
-    };
-    const intoFolder = () => {
-        if (target.kind !== 'folder')
-            return { target: null, refused: false, reason: null };
-        if (forbidden.has(target.id))
-            return {
-                target: null,
-                refused: true,
-                reason: target.id === dragId
-                    ? 'A folder cannot go inside itself'
-                    : 'A folder cannot go inside one of its own folders',
-            };
-        if (target.acceptsDrop === false)
-            return { target: null, refused: true, reason: lockedReason };
-        return vetted({ target: { kind: 'into', parentId: target.id }, refused: false, reason: null });
-    };
-    // A FILE row means "the folder that row is in" — what every file explorer does, and what
-    // keeps a long list of files from being a wall of rows nothing can be dropped on.
-    if (target.kind === 'file' && !allowReorder) {
-        if (row.parentId === null)
-            return vetted({ target: { kind: 'root' }, refused: false, reason: null });
-        const parent = findFileTreeNode(nodes, row.parentId);
-        if (parent && parent.acceptsDrop === false)
-            return { target: null, refused: true, reason: lockedReason };
-        if (parent && forbidden.has(parent.id))
-            return { target: null, refused: true, reason: 'A folder cannot go inside itself' };
-        return vetted({ target: { kind: 'into', parentId: row.parentId }, refused: false, reason: null });
-    }
-    if (!allowReorder)
-        return intoFolder();
-    // With an order to change, the middle half of a folder row is "into" and the edges are
-    // "between". A file row is all edges — there is no inside of a file.
-    const edge = target.kind === 'folder' ? (1 - INTO_ZONE) / 2 : 0.5;
-    if (target.kind === 'folder' && offsetRatio > edge && offsetRatio < 1 - edge)
-        return intoFolder();
-    const side = offsetRatio < 0.5 ? 'before' : 'after';
-    if (forbidden.has(target.id))
-        return { target: null, refused: true, reason: 'A folder cannot go inside itself' };
-    return vetted({
-        target: { kind: side, siblingId: target.id, parentId: row.parentId },
-        refused: false,
-        reason: null,
-    });
-}
-/**
- * Where ⌥→ / ⌥← would put the focused row — the keyboard's half of the drag.
- *
- * 🔴 It exists because a gesture with no keyboard route is a gesture half the people using
- * it cannot perform, and because TOUCH has no drag here at all: a sidebar row is a small
- * target on a surface whose one constant gesture is the flick, so the pointer drag gives
- * that up and this is what is left. `cursedesk`'s tree has carried it since it was written;
- * this one shipped with the drag alone.
- *
- * The two directions are the only two a keyboard can mean unambiguously. **→ demotes into
- * the nearest folder ABOVE it among its own siblings** — the one place a demotion can go
- * without asking which of several folders was meant — and **← promotes out to the folder its
- * own folder is in**, which is `root` at depth 1.
- *
- * 🔴 Every refusal the DRAG honours is honoured here, from the same fields: `acceptsDrop`,
- * the consumer's `canDrop`, and the descendant rule. A keyboard route that can reach a
- * destination the pointer refuses is a second, weaker opinion about what is legal — and it
- * is the one nobody looks at, because the pointer is what gets tested by hand.
- *
- * There is deliberately no ⌥↑/⌥↓ here. Those would move a row among its siblings, which is
- * only meaningful when the consumer stores an order — and when it does, the sibling before
- * and after are already reachable as `before`/`after` drops. Offering them unconditionally
- * would write a position nothing reads and then draw the row back where it started.
- */
-export function resolveKeyboardMove({ nodes, rows, row, direction, lockedReason = 'That folder is locked', canDrop, }) {
-    const vetted = (target) => {
-        const reason = canDrop?.(row.node.id, target);
-        return reason
-            ? { target: null, refused: true, reason }
-            : { target, refused: false, reason: null };
-    };
-    if (direction === 'out') {
-        if (row.parentId === null)
-            return { target: null, refused: true, reason: 'It is already at the top level' };
-        const grandparentId = parentIdOf(nodes, row.parentId);
-        if (grandparentId === null)
-            return vetted({ kind: 'root' });
-        const grandparent = findFileTreeNode(nodes, grandparentId);
-        if (grandparent?.acceptsDrop === false)
-            return { target: null, refused: true, reason: lockedReason };
-        return vetted({ kind: 'into', parentId: grandparentId });
-    }
-    // A row's siblings are all on screen whenever the row itself is — a shut folder hides its
-    // CHILDREN, never its peers — so the visible rows are the whole level.
-    const level = rows.filter((entry) => entry.parentId === row.parentId);
-    const above = level
-        .filter((entry) => entry.index < row.index && entry.node.kind === 'folder')
-        .at(-1);
-    if (!above)
-        return { target: null, refused: true, reason: 'There is no folder above it to move into' };
-    if (above.node.acceptsDrop === false)
-        return { target: null, refused: true, reason: lockedReason };
-    // Belt and braces: a folder cannot go inside itself, and `above` is a sibling rather than
-    // a descendant — but the rule is the tree's, not this function's, and stating it once here
-    // is cheaper than discovering the day someone changes what `above` means.
-    if (descendantIdsOf(nodes, row.node.id).has(above.node.id))
-        return { target: null, refused: true, reason: 'A folder cannot go inside itself' };
-    return vetted({ kind: 'into', parentId: above.node.id });
-}
-/**
- * Where a drop would put the thing being carried, in words — for the chip under the cursor
- * and for the screen reader that cannot see it.
- *
- * 🔴 A drag that says only WHAT is held answers half the question. Owner, of the tree this
- * one was ported from: *"dragging an item from one place to another does not have any
- * indication that it is working until you drop it somewhere new and see it move."* The chip
- * following the cursor answers "it is working"; this answers "and it is going there", which
- * is what stops a wrong drop before the pointer is lifted rather than after.
- *
- * Empty for no target — a refusal has its own words and this must never carry a second "no".
- */
-export function describeDrop(nodes, drop) {
-    if (!drop)
-        return '';
-    if (drop.kind === 'root')
-        return 'To the top level';
-    if (drop.kind === 'into') {
-        const folder = findFileTreeNode(nodes, drop.parentId);
-        return folder ? `Into ${folder.name}` : 'Into this folder';
-    }
-    const sibling = findFileTreeNode(nodes, drop.siblingId);
-    const where = drop.kind === 'before' ? 'Above' : 'Below';
-    return sibling ? `${where} ${sibling.name}` : `${where} this row`;
-}
-/**
- * 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, copy) {
-    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.
- *
- * Typeahead is what makes a long tree usable without a search box — `bud` jumps to
- * `budget-2026` — and wrapping is what stops it dying at the bottom of the list.
- */
-export function matchTypeahead(rows, query, fromIndex) {
-    if (!query)
-        return -1;
-    const needle = query.toLowerCase();
-    for (let step = 1; step <= rows.length; step += 1) {
-        const index = (fromIndex + step + rows.length) % rows.length;
-        const row = rows[index];
-        if (row?.node.name.toLowerCase().startsWith(needle))
-            return index;
-    }
-    return -1;
-}
-/**
- * The tree narrowed to what matches, with the folders on the way to a match kept.
- *
- * A folder that matches keeps ALL of its contents — searching for a folder means you want
- * to see what is in it, not a folder that looks empty because its children spell something
- * else.
- */
-export function filterFileTree(nodes, query) {
-    const needle = query.trim().toLowerCase();
-    if (!needle)
-        return nodes;
-    const keep = (node) => {
-        const hit = node.name.toLowerCase().includes(needle);
-        if (hit)
-            return node;
-        const kids = childrenOf(node)
-            .map(keep)
-            .filter((n) => n !== null);
-        if (kids.length === 0)
-            return null;
-        return { ...node, children: kids };
-    };
-    return nodes.map(keep).filter((n) => n !== null);
-}
-//# sourceMappingURL=fileTreeModel.js.map

package/dist/core/file-tree/fileTreeModel.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fileTreeModel.js","sourceRoot":"","sources":["../../../src/core/file-tree/fileTreeModel.ts"],"names":[],"mappings":"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"}

package/dist/core/folder-tree/actions.d.ts

@@ -1,85 +0,0 @@
-/**
- * The FOLDER OPERATIONS every app with folders offers — one model, so "move it into
- * that one" means the same thing in music as it does in collections.
- *
- * ── The owner's ask, verbatim (draft, 2026-08-25) ───────────────────────────────────────
- * *"in cb make or ensure we have a standardized folder list view. I want it applied to
- * music app and collections app and other apps with folders like that which should get the
- * same features if any. The features should include a 3 dot menu for choosing to move all
- * contents to a different folder or move a folder into another folder. For instance I could
- * move rock songs from a folder 'extra-rock-songs' to a 'rock' folder with it. Also allow
- * deleting a folder which deletes all the folder contents or allows deleting the folder and
- * having the contents not grouped in a folder anymore. Allow renaming folders."*
- *
- * ── 🔴 Four verbs, and three of them already existed ────────────────────────────────────
- * `planFolderRename`, `planFolderMove` and `planFolderDelete` in `tree.ts` are exactly
- * rename, "move a folder into another folder", and "delete the folder and leave the
- * contents ungrouped" — built for the vault and notes, and reachable from no menu anywhere.
- * The gap the owner is describing is not model, it is SURFACE: every app grew its own
- * subset of folder tools, so the operations that were never wired are the ones nobody has.
- * This module adds the ONE missing verb and the shared descriptions; the menu that renders
- * them is `react/folder-tree/FolderActionsMenu`.
- *
- * ── 🔴 Why "delete the contents too" is not a plan ──────────────────────────────────────
- * The other three verbs are pure path rewrites — a {@link FolderRemap} list the consumer
- * applies, with nothing destroyed. Deleting the CONTENTS destroys items, and this module
- * has never seen an item; it only ever sees the paths they carry. So `purge` is a mode the
- * menu offers and the CONSUMER implements against its own store, which is also the only
- * place that can count what is about to be lost or refuse the operation. Modelling it here
- * would mean inventing an item, and an item this model cannot see is one it cannot protect.
- */
-import type { FolderNode, FolderRemap } from "./tree";
-/**
- * Move everything at or under `source` INTO `destination`, and stop `source` existing.
- *
- * The owner's own example: *"I could move rock songs from a folder 'extra-rock-songs' to a
- * 'rock' folder with it."* Items directly in `extra-rock-songs` land directly in `rock`;
- * `extra-rock-songs/live` becomes `rock/live`.
- *
- * 🔴 This is NOT `planFolderMove`, and the difference is the whole reason it exists.
- * `planFolderMove(source, newParent)` makes `source` a CHILD — `rock/extra-rock-songs` —
- * which keeps the folder the owner is trying to get rid of. Both are real operations a
- * person wants ("put this inside that" vs "empty this into that"), they read almost
- * identically in a menu, and getting them confused is silent: the files are all present and
- * the folder you meant to dissolve is still there one level down.
- *
- * @param destination an empty array means the ROOT — "take these out of any folder".
- */
-export declare function planFolderMergeInto(serializedPaths: Iterable<string>, source: readonly string[], destination: readonly string[]): FolderRemap[];
-/** One place a folder may be moved or merged to. `path` empty = the root. */
-export interface FolderTarget {
-    path: string[];
-    serialized: string;
-    /** `Home › Phones`, for a menu label. The root's label is the caller's word for it. */
-    label: string;
-    key: string;
-}
-/**
- * Every folder `source` may legally be moved into, deepest-first within each branch.
- *
- * 🔴 A folder can never be moved into itself or into one of its own descendants — that
- * orphans the subtree, and `planFolderMove` throws on it. Filtering the DESTINATIONS rather
- * than catching the throw is what makes the menu honest: the offer a person is shown is the
- * set of offers that work, so there is no way to pick one and be told no.
- *
- * The current parent is filtered out too. "Move it to where it already is" is not a
- * no-op a person meant to ask for; it is a menu entry that does nothing, which reads as a
- * broken control.
- */
-export declare function folderMoveTargets(nodes: readonly FolderNode[], source: readonly string[], options?: {
-    rootLabel?: string;
-    separator?: string;
-}): FolderTarget[];
-/**
- * What "delete this folder" is allowed to mean.
- *
- * Two modes rather than one, because the owner asked for both in one sentence and they are
- * opposites: one is a filing change and the other destroys files. They are never the same
- * button — see {@link FolderActionsMenuProps} for how the menu keeps them apart.
- */
-export type FolderDeleteMode = 
-/** Splice the folder out; every item keeps existing, one path segment shorter. */
-"ungroup"
-/** Delete the folder AND everything in it. The consumer's store does this, not us. */
- | "purge";
-//# sourceMappingURL=actions.d.ts.map

package/dist/core/folder-tree/actions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../src/core/folder-tree/actions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAQH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAEtD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAClC,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,EACjC,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,WAAW,EAAE,SAAS,MAAM,EAAE,GAC5B,WAAW,EAAE,CAoBf;AAED,6EAA6E;AAC7E,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,uFAAuF;IACvF,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACZ;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAChC,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GACtD,YAAY,EAAE,CAiChB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB;AAC3B,kFAAkF;AAChF,SAAS;AACX,sFAAsF;GACpF,OAAO,CAAC"}

package/dist/core/folder-tree/actions.js

@@ -1,120 +0,0 @@
-/**
- * The FOLDER OPERATIONS every app with folders offers — one model, so "move it into
- * that one" means the same thing in music as it does in collections.
- *
- * ── The owner's ask, verbatim (draft, 2026-08-25) ───────────────────────────────────────
- * *"in cb make or ensure we have a standardized folder list view. I want it applied to
- * music app and collections app and other apps with folders like that which should get the
- * same features if any. The features should include a 3 dot menu for choosing to move all
- * contents to a different folder or move a folder into another folder. For instance I could
- * move rock songs from a folder 'extra-rock-songs' to a 'rock' folder with it. Also allow
- * deleting a folder which deletes all the folder contents or allows deleting the folder and
- * having the contents not grouped in a folder anymore. Allow renaming folders."*
- *
- * ── 🔴 Four verbs, and three of them already existed ────────────────────────────────────
- * `planFolderRename`, `planFolderMove` and `planFolderDelete` in `tree.ts` are exactly
- * rename, "move a folder into another folder", and "delete the folder and leave the
- * contents ungrouped" — built for the vault and notes, and reachable from no menu anywhere.
- * The gap the owner is describing is not model, it is SURFACE: every app grew its own
- * subset of folder tools, so the operations that were never wired are the ones nobody has.
- * This module adds the ONE missing verb and the shared descriptions; the menu that renders
- * them is `react/folder-tree/FolderActionsMenu`.
- *
- * ── 🔴 Why "delete the contents too" is not a plan ──────────────────────────────────────
- * The other three verbs are pure path rewrites — a {@link FolderRemap} list the consumer
- * applies, with nothing destroyed. Deleting the CONTENTS destroys items, and this module
- * has never seen an item; it only ever sees the paths they carry. So `purge` is a mode the
- * menu offers and the CONSUMER implements against its own store, which is also the only
- * place that can count what is about to be lost or refuse the operation. Modelling it here
- * would mean inventing an item, and an item this model cannot see is one it cannot protect.
- */
-import { folderPathKey, isFolderPathUnder, parseFolderPath, serializeFolderPath, } from "./path";
-/**
- * Move everything at or under `source` INTO `destination`, and stop `source` existing.
- *
- * The owner's own example: *"I could move rock songs from a folder 'extra-rock-songs' to a
- * 'rock' folder with it."* Items directly in `extra-rock-songs` land directly in `rock`;
- * `extra-rock-songs/live` becomes `rock/live`.
- *
- * 🔴 This is NOT `planFolderMove`, and the difference is the whole reason it exists.
- * `planFolderMove(source, newParent)` makes `source` a CHILD — `rock/extra-rock-songs` —
- * which keeps the folder the owner is trying to get rid of. Both are real operations a
- * person wants ("put this inside that" vs "empty this into that"), they read almost
- * identically in a menu, and getting them confused is silent: the files are all present and
- * the folder you meant to dissolve is still there one level down.
- *
- * @param destination an empty array means the ROOT — "take these out of any folder".
- */
-export function planFolderMergeInto(serializedPaths, source, destination) {
-    if (source.length === 0)
-        throw new Error("cannot move the root's contents");
-    if (isFolderPathUnder(destination, source)) {
-        throw new Error("cannot move a folder's contents into itself or one of its descendants");
-    }
-    const out = [];
-    const seen = new Set();
-    for (const raw of serializedPaths) {
-        const path = parseFolderPath(raw);
-        if (path.length === 0 || !isFolderPathUnder(path, source))
-            continue;
-        const key = folderPathKey(path);
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        // Drop the whole SOURCE prefix and re-root what is left under `destination`.
-        const moved = [...destination, ...path.slice(source.length)];
-        const from = serializeFolderPath(path);
-        const to = serializeFolderPath(moved);
-        if (from !== to)
-            out.push({ from, to });
-    }
-    return out;
-}
-/**
- * Every folder `source` may legally be moved into, deepest-first within each branch.
- *
- * 🔴 A folder can never be moved into itself or into one of its own descendants — that
- * orphans the subtree, and `planFolderMove` throws on it. Filtering the DESTINATIONS rather
- * than catching the throw is what makes the menu honest: the offer a person is shown is the
- * set of offers that work, so there is no way to pick one and be told no.
- *
- * The current parent is filtered out too. "Move it to where it already is" is not a
- * no-op a person meant to ask for; it is a menu entry that does nothing, which reads as a
- * broken control.
- */
-export function folderMoveTargets(nodes, source, options = {}) {
-    const separator = options.separator ?? " › ";
-    const currentParent = folderPathKey(source.slice(0, -1));
-    const targets = [];
-    // The root, unless the folder is already at the top level.
-    if (source.length > 1) {
-        targets.push({
-            path: [],
-            serialized: "",
-            label: options.rootLabel ?? "Top level",
-            key: folderPathKey([]),
-        });
-    }
-    const walk = (list) => {
-        for (const node of list) {
-            const key = folderPathKey(node.path);
-            const isSelfOrDescendant = isFolderPathUnder(node.path, source);
-            if (!isSelfOrDescendant && key !== currentParent) {
-                targets.push({
-                    path: [...node.path],
-                    serialized: node.serialized,
-                    label: node.path.join(separator),
-                    key,
-                });
-            }
-            // 🔴 Descend even into a branch that was itself refused: only the SUBTREE of
-            // `source` is unreachable. The current parent is skipped as a target and its
-            // children are perfectly good ones.
-            if (!isSelfOrDescendant)
-                walk(node.children);
-        }
-    };
-    walk(nodes);
-    return targets;
-}
-//# sourceMappingURL=actions.js.map

package/dist/core/folder-tree/actions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"actions.js","sourceRoot":"","sources":["../../../src/core/folder-tree/actions.ts"],"names":[],"mappings":"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"}

package/dist/core/folder-tree/index.d.ts

@@ -1,4 +0,0 @@
-export { FOLDER_PATH_DELIMITER, FOLDER_PATH_ESCAPE, folderDescendantPrefix, folderPathKey, formatFolderPath, isFolderPathUnder, isValidFolderName, normalizeFolderName, parseFolderPath, serializeFolderPath, } from "./path";
-export { buildFolderIndex, buildFolderTree, flattenFolderTree, type FolderIndex, type FolderNode, type FolderRemap, planFolderDelete, planFolderMove, planFolderRename, } from "./tree";
-export { type FolderDeleteMode, type FolderTarget, folderMoveTargets, planFolderMergeInto, } from "./actions";
-//# sourceMappingURL=index.d.ts.map

package/dist/core/folder-tree/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/folder-tree/index.ts"],"names":[],"mappings":"AAiBA,OAAO,EACN,qBAAqB,EACrB,kBAAkB,EAClB,sBAAsB,EACtB,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,mBAAmB,GACnB,MAAM,QAAQ,CAAC;AAChB,OAAO,EACN,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,gBAAgB,EAChB,cAAc,EACd,gBAAgB,GAChB,MAAM,QAAQ,CAAC;AAChB,OAAO,EACN,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,iBAAiB,EACjB,mBAAmB,GACnB,MAAM,WAAW,CAAC"}

package/dist/core/folder-tree/index.js

@@ -1,21 +0,0 @@
-// cursedbelt/folder-tree — the PURE nested-folder model: path encoding, the derived
-// tree, per-folder counts, and the structural-edit plans (rename/move/delete). No
-// React, no DOM, node-builtin-free — so a SERVER can hold the same folder semantics
-// its UI does.
-//
-//   import { buildFolderTree, planFolderRename, serializeFolderPath } from 'cursedbelt/folder-tree';
-//
-// The three UI pieces (rail, picker, breadcrumb) live at `cursedbelt/react/folder-tree`,
-// which re-exports everything here — so a browser-only consumer keeps one import.
-//
-// ── Why the model is its own export ─────────────────────────────────────────────
-// The vault (the first consumer) is zero-knowledge: folders are derived entirely in
-// the browser from encrypted meta, so a React subpath was the whole world. `apps/notes`
-// is the second, and its folders are SERVER state — filed items are searched, filtered
-// and bulk-moved by SQL. Importing the React barrel into a Bun server to reach
-// `isFolderPathUnder` would drag `Button`/`Input` and the whole component graph into a
-// process that renders nothing. Same law as `cursedbelt/sharing` vs `cursedbelt/react/sharing`.
-export { FOLDER_PATH_DELIMITER, FOLDER_PATH_ESCAPE, folderDescendantPrefix, folderPathKey, formatFolderPath, isFolderPathUnder, isValidFolderName, normalizeFolderName, parseFolderPath, serializeFolderPath, } from "./path";
-export { buildFolderIndex, buildFolderTree, flattenFolderTree, planFolderDelete, planFolderMove, planFolderRename, } from "./tree";
-export { folderMoveTargets, planFolderMergeInto, } from "./actions";
-//# sourceMappingURL=index.js.map

package/dist/core/folder-tree/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/folder-tree/index.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,kFAAkF;AAClF,oFAAoF;AACpF,eAAe;AACf,EAAE;AACF,qGAAqG;AACrG,EAAE;AACF,yFAAyF;AACzF,kFAAkF;AAClF,EAAE;AACF,mFAAmF;AACnF,oFAAoF;AACpF,wFAAwF;AACxF,uFAAuF;AACvF,+EAA+E;AAC/E,uFAAuF;AACvF,gGAAgG;AAChG,OAAO,EACN,qBAAqB,EACrB,kBAAkB,EAClB,sBAAsB,EACtB,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,mBAAmB,GACnB,MAAM,QAAQ,CAAC;AAChB,OAAO,EACN,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EAIjB,gBAAgB,EAChB,cAAc,EACd,gBAAgB,GAChB,MAAM,QAAQ,CAAC;AAChB,OAAO,EAGN,iBAAiB,EACjB,mBAAmB,GACnB,MAAM,WAAW,CAAC"}