cursedbelt 2.8.0 → 3.0.1

package/dist/core/events/ccEventBus.d.ts

@@ -1,45 +0,0 @@
-/**
- * The global event bus (03 §6.4) — lifecycle notifications only, never data
- * payloads (those ride the port hub).
- *
- * The depth guard is the reason this is a primitive rather than an EventEmitter:
- * handlers emit, and a handler chain that loops — `NOTE_SAVED` → indexer →
- * dashboard → audit interceptor → `NOTE_SAVED` — freezes the main thread with no
- * error and no stack that names the cycle. Each emission inherits
- * `depth = parent.depth + 1` via `causationId`; past `MAX_EVENT_DEPTH` the bus
- * terminates the chain and raises an `EventLoopDiagnostic` that names the whole
- * chain, so the loop is a report instead of a hang.
- *
- * Handlers are async-scheduled, never re-entrant: emitting from inside a handler
- * queues, so a synchronous handler cannot re-enter the dispatcher mid-iteration.
- */
-export interface CCEvent {
-    type: string;
-    tenantId: string;
-    causationId: string;
-    depth: number;
-    payload: Record<string, unknown>;
-}
-export interface EventLoopDiagnostic {
-    chain: string[];
-    terminatedAt: string;
-    causationId: string;
-}
-export type Unsubscribe = () => void;
-/** Past this depth a chain is a loop, not a workflow (03 §6.4). */
-export declare const MAX_EVENT_DEPTH = 5;
-export interface CCEventBusOptions {
-    onLoopDiagnostic?: (diagnostic: EventLoopDiagnostic) => void;
-    maxDepth?: number;
-}
-export interface CCEventBus {
-    emit(event: Partial<CCEvent> & {
-        type: string;
-    }): void;
-    on(type: string, handler: (event: CCEvent) => void): Unsubscribe;
-    /** Resolves once the queue drains — the probe's "is the main thread still responsive?" hook. */
-    settled(): Promise<void>;
-    diagnostics(): readonly EventLoopDiagnostic[];
-}
-export declare function createCcEventBus(options?: CCEventBusOptions): CCEventBus;
-//# sourceMappingURL=ccEventBus.d.ts.map

package/dist/core/events/ccEventBus.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ccEventBus.d.ts","sourceRoot":"","sources":["../../../src/core/events/ccEventBus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC;AAErC,mEAAmE;AACnE,eAAO,MAAM,eAAe,IAAI,CAAC;AAEjC,MAAM,WAAW,iBAAiB;IAChC,gBAAgB,CAAC,EAAE,CAAC,UAAU,EAAE,mBAAmB,KAAK,IAAI,CAAC;IAC7D,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACvD,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,WAAW,CAAC;IACjE,gGAAgG;IAChG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,WAAW,IAAI,SAAS,mBAAmB,EAAE,CAAC;CAC/C;AAED,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,iBAAsB,GAAG,UAAU,CAwE5E"}

package/dist/core/events/ccEventBus.js

@@ -1,71 +0,0 @@
-/** Past this depth a chain is a loop, not a workflow (03 §6.4). */
-export const MAX_EVENT_DEPTH = 5;
-export function createCcEventBus(options = {}) {
-    const maxDepth = options.maxDepth ?? MAX_EVENT_DEPTH;
-    const handlers = new Map();
-    const diagnostics = [];
-    const chains = new Map();
-    const queue = [];
-    let draining = false;
-    let drained = Promise.resolve();
-    let resolveDrained = null;
-    const drain = async () => {
-        draining = true;
-        while (queue.length > 0) {
-            const event = queue.shift();
-            for (const handler of handlers.get(event.type) ?? []) {
-                try {
-                    handler(event);
-                }
-                catch {
-                    // A throwing subscriber must not stop the rest of the chain.
-                }
-            }
-            await Promise.resolve(); // yield: handlers are scheduled, never re-entrant
-        }
-        draining = false;
-        resolveDrained?.();
-        resolveDrained = null;
-    };
-    return {
-        emit(partial) {
-            const causationId = partial.causationId ?? `cause_${chains.size + 1}_${partial.type}`;
-            const depth = partial.depth ?? 0;
-            const chain = [...(chains.get(causationId) ?? []), partial.type];
-            chains.set(causationId, chain);
-            if (depth > maxDepth) {
-                const diagnostic = { chain, terminatedAt: partial.type, causationId };
-                diagnostics.push(diagnostic);
-                options.onLoopDiagnostic?.(diagnostic);
-                return; // chain terminated — the guard, not a crash
-            }
-            queue.push({
-                type: partial.type,
-                tenantId: partial.tenantId ?? 'tenant-a',
-                causationId,
-                depth,
-                payload: partial.payload ?? {},
-            });
-            if (!draining) {
-                drained = new Promise((resolve) => {
-                    resolveDrained = resolve;
-                });
-                void drain();
-            }
-        },
-        on(type, handler) {
-            const list = handlers.get(type) ?? [];
-            list.push(handler);
-            handlers.set(type, list);
-            return () => {
-                const current = handlers.get(type) ?? [];
-                const index = current.indexOf(handler);
-                if (index >= 0)
-                    current.splice(index, 1);
-            };
-        },
-        settled: () => (draining ? drained : Promise.resolve()),
-        diagnostics: () => diagnostics,
-    };
-}
-//# sourceMappingURL=ccEventBus.js.map

package/dist/core/events/ccEventBus.js.map

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

package/dist/core/file-tree/fileTreeModel.d.ts

@@ -1,295 +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.
- */
-/** What a row IS. `folder` may hold children and accept drops; `file` is a leaf. */
-export type FileTreeNodeKind = 'folder' | 'file';
-/**
- * How visible a node is, generalised from collections' private/locked folders.
- *
- * 🔴 It is a LABEL, never an enforcement. The server decides what a session may see, and a
- * tree that hides a row the server sent (or shows one it did not) is a second, weaker
- * opinion about access that will disagree with the first. collections' server already omits
- * what a locked session may not see — see `albums.ts:folderTree` — so a `private` row here
- * means "you are unlocked and this is one of the protected ones", which is a thing to MARK.
- */
-export type FileTreeAccess = 'normal' | 'private' | 'locked';
-export interface FileTreeNode {
-    /** Stable across re-derivation — it is the React key, the selection value and the drag id. */
-    id: string;
-    name: string;
-    kind: FileTreeNodeKind;
-    /** Folders only. A folder with `[]` is empty; a file's is ignored. */
-    children?: readonly FileTreeNode[];
-    /**
-     * Whether this folder draws a twisty. **Default `true` for every folder**, empty ones
-     * included — pass `false` only for a row that is a folder in name and can never hold
-     * anything.
-     *
-     * 🔴 2026-09-11, the owner: *"Make them use an arrow icon next to a dir even when the dir
-     * is empty."* It used to default to `children.length > 0`, and that was wrong twice over.
-     * For a LAZY tree it is a trap door — a consumer that fetches a row's contents only while
-     * it is open produces a collapsed row with no children, which loses its caret and can
-     * never be reopened (`apps/collections` hit exactly that, and had to pass this flag to get
-     * out of it). And for an EAGER tree it makes an empty folder look like a file: the arrow
-     * is the only thing on the row that says "this is a place", so a folder you have not put
-     * anything in yet is drawn as a leaf until the moment it stops being empty.
-     *
-     * VS Code draws the chevron on every folder and opens an empty one onto nothing, which is
-     * what this now matches.
-     */
-    expandable?: boolean;
-    /**
-     * A picture of THIS row's contents, drawn in the glyph box in place of its type icon.
-     *
-     * 🔴 2026-09-11, the owner: *"For media files show a thumbnail instead of the file type
-     * icon to the left of the name."* A folder of photographs is a list of rows whose type
-     * icons are all identical, so the glyph column says nothing at all — the thumbnail is the
-     * only thing in the row that distinguishes one picture from the next before you open it.
-     *
-     * It takes the SAME 16px box the type icon uses rather than growing the row: the row's
-     * height is pinned to the glyph by `fleet/standards/file-tree-geometry.json`, and a tree
-     * whose rows change height per file is one you cannot scan. A thumbnail that 404s falls
-     * back to the type icon exactly once — see `FileTree`'s `RowGlyph`. Omit it for anything
-     * that has no picture, and never point it at the full-size object: this is a 16px box, and
-     * a tree of 200 rows pointed at originals is 200 full downloads.
-     */
-    thumbnailUrl?: string;
-    /** Badge on the row — usually "everything at or under here". Omit for none. */
-    count?: number;
-    access?: FileTreeAccess;
-    /**
-     * Refuse drops INTO this node even though it is a folder.
-     *
-     * The consumer's veto, for a rule the tree cannot know: collections uses it so a folder
-     * cannot be dragged across album boundaries, which the server has no route for. Defaults
-     * to true for folders and is meaningless for files.
-     */
-    acceptsDrop?: boolean;
-    /**
-     * Whether this row can be picked up. Default true once `onMove` is wired.
-     *
-     * Not every row in a tree is a thing you can move: collections puts its ALBUMS at the top
-     * level, and albums have no order and no parent to be moved into. A row that cannot go
-     * anywhere must not start a drag — otherwise the gesture begins, follows the cursor, and
-     * refuses everywhere, which reads as a broken tree rather than a fixed one.
-     */
-    draggable?: boolean;
-    /** Whatever the consumer needs back in a callback. Never read here. */
-    meta?: unknown;
-}
-/** Where a drag would put the thing it is carrying. */
-export type FileTreeDrop = {
-    kind: 'into';
-    parentId: string;
-}
-/**
- * Out of every folder, at the top of the tree.
- *
- * The blank space under the last row is what expresses "get this out of here" — the
- * gesture every file explorer has and the only one that does not need a target row.
- */
- | {
-    kind: 'root';
-}
-/** Between two rows, when the consumer stores an order. See {@link ResolveDropOptions}. */
- | {
-    kind: 'before';
-    siblingId: string;
-    parentId: string | null;
-} | {
-    kind: 'after';
-    siblingId: string;
-    parentId: string | null;
-};
-/** A pointer position resolved against the tree: a target, or a refusal with words. */
-export interface DropOffer {
-    target: FileTreeDrop | null;
-    refused: boolean;
-    /**
-     * Why, in words, when it is refused.
-     *
-     * `DESIGN.md`'s law: a control that cannot do a thing says so. A drop that is silently
-     * ignored reads as a broken app rather than a refused one.
-     */
-    reason: string | null;
-}
-/** One row as drawn, top to bottom. */
-export interface FileTreeRow {
-    node: FileTreeNode;
-    /** How far in it is drawn — 0 at the top level. */
-    depth: number;
-    parentId: string | null;
-    /** Its position among its own siblings, which is what a keyboard move needs. */
-    index: number;
-    /** True when it is a folder with children (so it gets a twisty). */
-    expandable: boolean;
-    expanded: boolean;
-}
-/** Every node in the tree, depth-first — the order the rows would be in fully expanded. */
-export declare function walkFileTree(nodes: readonly FileTreeNode[]): FileTreeNode[];
-export declare function findFileTreeNode(nodes: readonly FileTreeNode[], id: string): FileTreeNode | 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 declare function flattenFileTree(nodes: readonly FileTreeNode[], collapsed: Iterable<string>): FileTreeRow[];
-/** `id` and everything under it — the set a drag may not land inside. */
-export declare function descendantIdsOf(nodes: readonly FileTreeNode[], id: string): Set<string>;
-/**
- * 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 declare function parentIdOf(nodes: readonly FileTreeNode[], id: string): string | null;
-/** The share of a folder row's height that means "into" rather than "between". */
-export declare const INTO_ZONE = 0.5;
-export interface ResolveDropOptions {
-    nodes: readonly FileTreeNode[];
-    /** The row under the pointer, or null over blank space below the tree. */
-    row: FileTreeRow | null;
-    /** How far down that row the pointer is, 0 at its top edge and 1 at its bottom. */
-    offsetRatio: number;
-    /** What is being dragged — a node id from this tree, or null for an external payload. */
-    dragId: string | null;
-    /**
-     * Whether the consumer stores a sibling ORDER.
-     *
-     * 🔴 Off by default, and collections is why. Its folders are DERIVED from the paths its
-     * files carry and are always sorted by name, so there is no order to change — offering a
-     * between-rows marker would draw a promise the app cannot keep. Off, a row is only ever
-     * dropped INTO something, which is the whole of what that app can do.
-     */
-    allowReorder?: boolean;
-    /** Words for refusing a drop into a folder whose `acceptsDrop` is false. */
-    lockedReason?: string;
-    /**
-     * The consumer's veto, for a refusal that depends on WHAT is being dragged.
-     *
-     * `acceptsDrop` is a property of the target alone and cannot express "this folder takes
-     * files but not folders from another album" — which is collections' actual rule, because
-     * its server has a route for re-pathing a folder inside one album and none for moving one
-     * across albums. Return the words; return null to allow.
-     *
-     * 🔴 Consulted BEFORE the target is offered, never after the drop. The whole design of
-     * this tree is that an impossible drop is never drawn as possible.
-     */
-    canDrop?: (dragId: string | null, target: FileTreeDrop) => string | null;
-}
-/**
- * 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 declare function resolveDrop({ nodes, row, offsetRatio, dragId, allowReorder, lockedReason, canDrop, }: ResolveDropOptions): DropOffer;
-export interface KeyboardMoveOptions {
-    nodes: readonly FileTreeNode[];
-    /** The rows on screen — siblings are read off these, which is every sibling by construction. */
-    rows: readonly FileTreeRow[];
-    /** The row the keyboard is on. */
-    row: FileTreeRow;
-    /** `in` demotes into the nearest folder above it; `out` promotes to its grandparent. */
-    direction: 'in' | 'out';
-    lockedReason?: string;
-    canDrop?: (dragId: string | null, target: FileTreeDrop) => string | 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 declare function resolveKeyboardMove({ nodes, rows, row, direction, lockedReason, canDrop, }: KeyboardMoveOptions): DropOffer;
-/**
- * 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 declare function describeDrop(nodes: readonly FileTreeNode[], drop: FileTreeDrop | null): string;
-/** 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 declare function accessMarkCopy(access: FileTreeAccess | undefined, copy?: AccessMarkCopy): string;
-/**
- * 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 declare function matchTypeahead(rows: readonly FileTreeRow[], query: string, fromIndex: number): number;
-/**
- * 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 declare function filterFileTree(nodes: readonly FileTreeNode[], query: string): readonly FileTreeNode[];
-//# sourceMappingURL=fileTreeModel.d.ts.map

package/dist/core/file-tree/fileTreeModel.d.ts.map

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