@joewinke/jatui 0.39.0 → 0.41.0

package/dist/data/grid/clipboard.js

@@ -0,0 +1,131 @@
+/**
+ * Spreadsheet clipboard + CSV I/O (jatui/grid, jatui-6kitr).
+ *
+ * Behaviour follows BoardUI's data-grid utils (MIT, © 2026 Mertcan Dundar
+ * Esmergul): TSV that round-trips quoted tabs/newlines from Excel and Google
+ * Sheets, and CSV export with a BOM and formula-injection escaping. Clean
+ * re-implementation.
+ */
+/**
+ * Parse clipboard text from Excel / Sheets / Numbers into a cell matrix.
+ *
+ * - Tab separates cells, newline (LF or CRLF) separates rows.
+ * - A cell that STARTS with `"` is quoted: tabs and newlines inside it are
+ *   literal and `""` is an escaped quote. (Sheets quotes any cell holding a
+ *   newline or a quote.) A `"` mid-cell is literal.
+ * - One trailing newline (every spreadsheet adds it) does not make an empty row.
+ * - Ragged rows are padded with '' to the widest row.
+ */
+export function parseClipboardTsv(text) {
+    const rows = [];
+    let row = [];
+    let cell = '';
+    let i = 0;
+    const n = text.length;
+    let atCellStart = true;
+    while (i < n) {
+        const ch = text[i];
+        if (atCellStart && ch === '"') {
+            // Quoted cell: read to the closing quote.
+            i++;
+            let closed = false;
+            while (i < n) {
+                if (text[i] === '"') {
+                    if (text[i + 1] === '"') {
+                        cell += '"';
+                        i += 2;
+                        continue;
+                    }
+                    i++;
+                    closed = true;
+                    break;
+                }
+                cell += text[i++];
+            }
+            if (!closed) {
+                // Unbalanced: treat the whole thing as literal text.
+                cell = '"' + cell;
+            }
+            atCellStart = false;
+            continue;
+        }
+        atCellStart = false;
+        if (ch === '\t') {
+            row.push(cell);
+            cell = '';
+            atCellStart = true;
+            i++;
+        }
+        else if (ch === '\n' || ch === '\r') {
+            row.push(cell);
+            rows.push(row);
+            row = [];
+            cell = '';
+            atCellStart = true;
+            i += ch === '\r' && text[i + 1] === '\n' ? 2 : 1;
+        }
+        else {
+            cell += ch;
+            i++;
+        }
+    }
+    // Flush the last row unless the text ended exactly on a newline.
+    if (!atCellStart || row.length > 0) {
+        row.push(cell);
+        rows.push(row);
+    }
+    const width = rows.reduce((w, r) => Math.max(w, r.length), 0);
+    for (const r of rows)
+        while (r.length < width)
+            r.push('');
+    return rows;
+}
+/** Serialize a matrix as clipboard TSV, quoting cells that hold a tab, newline or quote. */
+export function serializeTsv(rows) {
+    return rows
+        .map((r) => r
+        .map((v) => {
+        const s = cellText(v);
+        return /[\t\n\r"]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+    })
+        .join('\t'))
+        .join('\n');
+}
+/** Characters that make a spreadsheet treat a cell as a formula (OWASP CSV injection). */
+const FORMULA_START = /^[=+\-@\t\r]/;
+/**
+ * Neutralise a cell a spreadsheet would execute (`=HYPERLINK(...)`,
+ * `+cmd|...`, `@SUM(...)`) by prefixing a single quote. Only STRINGS are
+ * escaped: a real number such as -5 is data, not a formula.
+ */
+export function escapeCsvFormula(value) {
+    return typeof value === 'string' && FORMULA_START.test(value) ? `'${value}` : value;
+}
+function cellText(v) {
+    if (v == null)
+        return '';
+    if (v instanceof Date)
+        return Number.isNaN(v.getTime()) ? '' : v.toISOString();
+    if (typeof v === 'object')
+        return JSON.stringify(v);
+    return String(v);
+}
+/** RFC 4180 CSV from a matrix (first row = header if you include one). */
+export function serializeCsv(rows, opts = {}) {
+    const { bom = true, escapeFormulas = true, delimiter = ',', newline = '\r\n' } = opts;
+    const needsQuote = new RegExp(`[${delimiter.replace(/[\\\]^-]/g, '\\$&')}"\\n\\r]`);
+    const body = rows
+        .map((r) => r
+        .map((v) => {
+        const s = cellText(escapeFormulas ? escapeCsvFormula(v) : v);
+        return needsQuote.test(s) || /^\s|\s$/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+    })
+        .join(delimiter))
+        .join(newline);
+    return (bom ? '' : '') + body;
+}
+/** CSV from objects: one header row, then one row per object. */
+export function serializeRowsToCsv(data, columns, opts) {
+    const get = (row, c) => typeof c.value === 'function' ? c.value(row) : row[c.value];
+    return serializeCsv([columns.map((c) => c.header), ...data.map((row) => columns.map((c) => get(row, c)))], opts);
+}

package/dist/data/grid/edits.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Diff-based edit transactions + undo/redo for editable grids (jatui/grid,
+ * jatui-6kitr).
+ *
+ * `history.ts` snapshots the whole state per step, which is heavy for a
+ * 10k-row table. This stores only what changed (cell before/after, deleted
+ * rows with their index) and refuses to undo a transaction whose cells no
+ * longer hold what it wrote: when the data changed underneath (a server
+ * refresh, a collaborator), the history is cleared instead of silently
+ * reverting someone else's change. That stale guard follows BoardUI's data
+ * grid (MIT, © 2026 Mertcan Dundar Esmergul); clean re-implementation.
+ *
+ * Everything is immutable: functions return new arrays and copy only the
+ * rows they touch.
+ */
+export interface CellEdit {
+    rowId: string;
+    columnId: string;
+    before: unknown;
+    after: unknown;
+}
+export type GridTransaction<TRow> = {
+    kind: 'cells';
+    edits: CellEdit[];
+    label?: string;
+} | {
+    kind: 'delete';
+    rows: {
+        row: TRow;
+        index: number;
+    }[];
+    label?: string;
+} | {
+    kind: 'insert';
+    rows: {
+        row: TRow;
+        index: number;
+    }[];
+    label?: string;
+};
+export interface GridAccess<TRow> {
+    getRowId: (row: TRow) => string;
+    /** Default: `row[columnId]`. */
+    getCell?: (row: TRow, columnId: string) => unknown;
+    /** Default: `{ ...row, [columnId]: value }`. Must return a NEW row. */
+    setCell?: (row: TRow, columnId: string, value: unknown) => TRow;
+    /** Default: Object.is. */
+    equals?: (a: unknown, b: unknown) => boolean;
+}
+/**
+ * Apply cell edits (`direction: 'forward'` writes `after`, `'backward'`
+ * writes `before`). Edits for unknown rows are skipped.
+ */
+export declare function applyEdits<TRow>(data: readonly TRow[], edits: readonly CellEdit[], access: GridAccess<TRow>, direction?: 'forward' | 'backward'): TRow[];
+/** Build edits for writing `values` (rowId → columnId → value), capturing `before` from `data`. */
+export declare function diffEdits<TRow>(data: readonly TRow[], values: ReadonlyArray<{
+    rowId: string;
+    columnId: string;
+    value: unknown;
+}>, access: GridAccess<TRow>): CellEdit[];
+/** Does `data` currently hold what `tx` would hold after `direction`? (the stale guard) */
+export declare function transactionMatches<TRow>(data: readonly TRow[], tx: GridTransaction<TRow>, access: GridAccess<TRow>, state: 'applied' | 'reverted'): boolean;
+/** Apply a whole transaction forward (redo) or backward (undo). */
+export declare function applyTransaction<TRow>(data: readonly TRow[], tx: GridTransaction<TRow>, access: GridAccess<TRow>, direction: 'forward' | 'backward'): TRow[];
+/** Delete rows by id, returning the new data and the transaction to record. */
+export declare function deleteRows<TRow>(data: readonly TRow[], ids: Iterable<string>, access: Pick<GridAccess<TRow>, 'getRowId'>, label?: string): {
+    data: TRow[];
+    transaction: GridTransaction<TRow>;
+};
+export type HistoryStep<TRow> = {
+    ok: true;
+    data: TRow[];
+    transaction: GridTransaction<TRow>;
+} | {
+    ok: false;
+    reason: 'empty' | 'stale';
+};
+export interface EditHistory<TRow> {
+    /** Record a transaction you have already applied. Clears the redo stack. */
+    record(tx: GridTransaction<TRow>): void;
+    /** Shorthand: apply cell edits to `data`, record them, return the new data. */
+    commit(data: readonly TRow[], edits: CellEdit[], label?: string): TRow[];
+    undo(data: readonly TRow[]): HistoryStep<TRow>;
+    redo(data: readonly TRow[]): HistoryStep<TRow>;
+    clear(): void;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    readonly size: {
+        undo: number;
+        redo: number;
+    };
+    /** Fires after every change to the stacks (for reactive canUndo/canRedo). */
+    subscribe(fn: () => void): () => void;
+}
+export interface EditHistoryOptions<TRow> extends GridAccess<TRow> {
+    /** Max undo depth. Default 100. */
+    limit?: number;
+}
+export declare function createEditHistory<TRow>(opts: EditHistoryOptions<TRow>): EditHistory<TRow>;
+export interface PasteTarget {
+    /** Visible row ids in display order. */
+    rowIds: readonly string[];
+    /** Visible column ids in display order. */
+    columnIds: readonly string[];
+    /** Top-left cell of the paste. */
+    start: {
+        row: number;
+        col: number;
+    };
+    /**
+     * Per-column parser (e.g. `parseCellValue` with that column's spec).
+     * Return `{ ok: false }` to reject a cell. Default: keep the text.
+     */
+    parse?: (raw: string, columnId: string) => {
+        ok: true;
+        value: unknown;
+    } | {
+        ok: false;
+        error: string;
+    };
+    /** Columns that cannot be written (read-only / computed). */
+    readOnly?: (columnId: string) => boolean;
+    /**
+     * A 1×1 clipboard fills the whole selection when given (Excel behaviour).
+     * Selection bounds inclusive, in display indices.
+     */
+    fillRange?: {
+        rowEnd: number;
+        colEnd: number;
+    };
+}
+export interface PastePlan {
+    values: {
+        rowId: string;
+        columnId: string;
+        value: unknown;
+    }[];
+    errors: {
+        rowId: string;
+        columnId: string;
+        raw: string;
+        error: string;
+    }[];
+    /** Cells that fell outside the grid. */
+    clipped: number;
+}
+/** Map a clipboard matrix onto grid cells. Feed `values` to `diffEdits`, then `history.commit`. */
+export declare function planPaste(matrix: readonly (readonly string[])[], target: PasteTarget): PastePlan;

package/dist/data/grid/edits.js

@@ -0,0 +1,222 @@
+/**
+ * Diff-based edit transactions + undo/redo for editable grids (jatui/grid,
+ * jatui-6kitr).
+ *
+ * `history.ts` snapshots the whole state per step, which is heavy for a
+ * 10k-row table. This stores only what changed (cell before/after, deleted
+ * rows with their index) and refuses to undo a transaction whose cells no
+ * longer hold what it wrote: when the data changed underneath (a server
+ * refresh, a collaborator), the history is cleared instead of silently
+ * reverting someone else's change. That stale guard follows BoardUI's data
+ * grid (MIT, © 2026 Mertcan Dundar Esmergul); clean re-implementation.
+ *
+ * Everything is immutable: functions return new arrays and copy only the
+ * rows they touch.
+ */
+const defaultGet = (row, col) => row[col];
+const defaultSet = (row, col, v) => ({ ...row, [col]: v });
+function resolve(a) {
+    return {
+        getRowId: a.getRowId,
+        getCell: a.getCell ?? defaultGet,
+        setCell: a.setCell ?? defaultSet,
+        equals: a.equals ?? Object.is
+    };
+}
+/**
+ * Apply cell edits (`direction: 'forward'` writes `after`, `'backward'`
+ * writes `before`). Edits for unknown rows are skipped.
+ */
+export function applyEdits(data, edits, access, direction = 'forward') {
+    const { getRowId, setCell } = resolve(access);
+    const byRow = new Map();
+    for (const e of edits) {
+        const list = byRow.get(e.rowId);
+        if (list)
+            list.push(e);
+        else
+            byRow.set(e.rowId, [e]);
+    }
+    if (!byRow.size)
+        return data.slice();
+    const ordered = direction === 'forward' ? (l) => l : (l) => l.slice().reverse();
+    return data.map((row) => {
+        const list = byRow.get(getRowId(row));
+        if (!list)
+            return row;
+        let next = row;
+        for (const e of ordered(list))
+            next = setCell(next, e.columnId, direction === 'forward' ? e.after : e.before);
+        return next;
+    });
+}
+/** Build edits for writing `values` (rowId → columnId → value), capturing `before` from `data`. */
+export function diffEdits(data, values, access) {
+    const { getRowId, getCell, equals } = resolve(access);
+    const rows = new Map(data.map((r) => [getRowId(r), r]));
+    const out = [];
+    for (const v of values) {
+        const row = rows.get(v.rowId);
+        if (!row)
+            continue;
+        const before = getCell(row, v.columnId);
+        if (!equals(before, v.value))
+            out.push({ rowId: v.rowId, columnId: v.columnId, before, after: v.value });
+    }
+    return out;
+}
+/** Does `data` currently hold what `tx` would hold after `direction`? (the stale guard) */
+export function transactionMatches(data, tx, access, state) {
+    const { getRowId, getCell, equals } = resolve(access);
+    const rows = new Map(data.map((r) => [getRowId(r), r]));
+    if (tx.kind === 'cells') {
+        // Last write per cell wins when a transaction touched a cell twice.
+        const final = new Map();
+        const first = new Map();
+        for (const e of tx.edits) {
+            const k = e.rowId + '\u0000' + e.columnId;
+            final.set(k, e);
+            if (!first.has(k))
+                first.set(k, e);
+        }
+        for (const [k, e] of final) {
+            const row = rows.get(e.rowId);
+            if (!row)
+                return false;
+            const expected = state === 'applied' ? e.after : first.get(k).before;
+            if (!equals(getCell(row, e.columnId), expected))
+                return false;
+        }
+        return true;
+    }
+    const present = tx.rows.every((r) => rows.has(getRowId(r.row)));
+    const absent = tx.rows.every((r) => !rows.has(getRowId(r.row)));
+    const rowsShouldExist = (tx.kind === 'insert') === (state === 'applied');
+    return rowsShouldExist ? present : absent;
+}
+function removeRows(data, ids, getRowId) {
+    return data.filter((r) => !ids.has(getRowId(r)));
+}
+function insertRows(data, rows) {
+    const out = data.slice();
+    for (const r of rows.slice().sort((a, b) => a.index - b.index)) {
+        out.splice(Math.min(Math.max(0, r.index), out.length), 0, r.row);
+    }
+    return out;
+}
+/** Apply a whole transaction forward (redo) or backward (undo). */
+export function applyTransaction(data, tx, access, direction) {
+    if (tx.kind === 'cells')
+        return applyEdits(data, tx.edits, access, direction);
+    const removing = (tx.kind === 'delete') === (direction === 'forward');
+    if (removing) {
+        return removeRows(data, new Set(tx.rows.map((r) => access.getRowId(r.row))), access.getRowId);
+    }
+    return insertRows(data, tx.rows);
+}
+/** Delete rows by id, returning the new data and the transaction to record. */
+export function deleteRows(data, ids, access, label) {
+    const set = new Set(ids);
+    const rows = [];
+    data.forEach((row, index) => {
+        if (set.has(access.getRowId(row)))
+            rows.push({ row, index });
+    });
+    return {
+        data: removeRows(data, set, access.getRowId),
+        transaction: { kind: 'delete', rows, label }
+    };
+}
+export function createEditHistory(opts) {
+    const limit = Math.max(1, opts.limit ?? 100);
+    let past = [];
+    let future = [];
+    const subs = new Set();
+    const emit = () => subs.forEach((f) => f());
+    function step(data, from) {
+        const stack = from === 'undo' ? past : future;
+        const tx = stack[stack.length - 1];
+        if (!tx)
+            return { ok: false, reason: 'empty' };
+        if (!transactionMatches(data, tx, opts, from === 'undo' ? 'applied' : 'reverted')) {
+            past = [];
+            future = [];
+            emit();
+            return { ok: false, reason: 'stale' };
+        }
+        stack.pop();
+        (from === 'undo' ? future : past).push(tx);
+        const next = applyTransaction(data, tx, opts, from === 'undo' ? 'backward' : 'forward');
+        emit();
+        return { ok: true, data: next, transaction: tx };
+    }
+    return {
+        record(tx) {
+            if (tx.kind === 'cells' ? !tx.edits.length : !tx.rows.length)
+                return;
+            past.push(tx);
+            if (past.length > limit)
+                past = past.slice(past.length - limit);
+            future = [];
+            emit();
+        },
+        commit(data, edits, label) {
+            if (!edits.length)
+                return data.slice();
+            const next = applyEdits(data, edits, opts, 'forward');
+            this.record({ kind: 'cells', edits, label });
+            return next;
+        },
+        undo: (data) => step(data, 'undo'),
+        redo: (data) => step(data, 'redo'),
+        clear() {
+            past = [];
+            future = [];
+            emit();
+        },
+        get canUndo() {
+            return past.length > 0;
+        },
+        get canRedo() {
+            return future.length > 0;
+        },
+        get size() {
+            return { undo: past.length, redo: future.length };
+        },
+        subscribe(fn) {
+            subs.add(fn);
+            return () => subs.delete(fn);
+        }
+    };
+}
+/** Map a clipboard matrix onto grid cells. Feed `values` to `diffEdits`, then `history.commit`. */
+export function planPaste(matrix, target) {
+    const plan = { values: [], errors: [], clipped: 0 };
+    const { rowIds, columnIds, start } = target;
+    let src = matrix;
+    if (target.fillRange && matrix.length === 1 && matrix[0]?.length === 1) {
+        const h = target.fillRange.rowEnd - start.row + 1;
+        const w = target.fillRange.colEnd - start.col + 1;
+        src = Array.from({ length: Math.max(1, h) }, () => Array.from({ length: Math.max(1, w) }, () => matrix[0][0]));
+    }
+    src.forEach((line, r) => {
+        line.forEach((raw, c) => {
+            const ri = start.row + r;
+            const ci = start.col + c;
+            if (ri >= rowIds.length || ci >= columnIds.length) {
+                plan.clipped++;
+                return;
+            }
+            const rowId = rowIds[ri];
+            const columnId = columnIds[ci];
+            if (target.readOnly?.(columnId))
+                return;
+            const parsed = target.parse ? target.parse(raw, columnId) : { ok: true, value: raw };
+            if (parsed.ok)
+                plan.values.push({ rowId, columnId, value: parsed.value });
+            else
+                plan.errors.push({ rowId, columnId, raw, error: parsed.error });
+        });
+    });
+    return plan;
+}

package/dist/data/grid/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * jatui/grid — pure helpers for spreadsheet-style grids (jatui-6kitr).
+ *
+ * TSV clipboard parse/serialize, injection-safe CSV export, A1 addressing,
+ * typed cell parsing, and diff-based edit transactions with a stale-data
+ * undo guard. No DOM, no dependencies: point an editable table (MOS tables,
+ * IDE tables, a future DataTable editable mode) at these instead of
+ * re-deriving them.
+ */
+export { parseClipboardTsv, serializeTsv, escapeCsvFormula, serializeCsv, serializeRowsToCsv, type SerializeCsvOptions, type CsvColumn } from './clipboard';
+export { columnLetter, columnIndex, parseCellRef, parseCellValue, type GridCellType, type GridCellSpec, type ParseCellResult } from './cells';
+export { applyEdits, diffEdits, applyTransaction, transactionMatches, deleteRows, createEditHistory, planPaste, type CellEdit, type GridTransaction, type GridAccess, type EditHistory, type EditHistoryOptions, type HistoryStep, type PasteTarget, type PastePlan } from './edits';

package/dist/data/grid/index.js

@@ -0,0 +1,12 @@
+/**
+ * jatui/grid — pure helpers for spreadsheet-style grids (jatui-6kitr).
+ *
+ * TSV clipboard parse/serialize, injection-safe CSV export, A1 addressing,
+ * typed cell parsing, and diff-based edit transactions with a stale-data
+ * undo guard. No DOM, no dependencies: point an editable table (MOS tables,
+ * IDE tables, a future DataTable editable mode) at these instead of
+ * re-deriving them.
+ */
+export { parseClipboardTsv, serializeTsv, escapeCsvFormula, serializeCsv, serializeRowsToCsv } from './clipboard';
+export { columnLetter, columnIndex, parseCellRef, parseCellValue } from './cells';
+export { applyEdits, diffEdits, applyTransaction, transactionMatches, deleteRows, createEditHistory, planPaste } from './edits';

package/dist/index.d.ts

@@ -75,6 +75,10 @@ export { default as InfiniteSearchGrid } from './components/InfiniteSearchGrid.s
 export { createInfiniteLoader } from './components/infiniteGridLoader';
 export type { InfinitePage, InfiniteLoadContext, InfiniteLoadFn, InfiniteLoader, InfiniteLoaderState, InfiniteStatus } from './components/infiniteGridLoader';
 export { default as Button } from './components/Button.svelte';
+export { default as IconButton } from './components/IconButton.svelte';
+export type { IconButtonVariant, IconButtonSize } from './components/IconButton.svelte';
+export { default as CloseButton } from './components/CloseButton.svelte';
+export { default as LinkButton } from './components/LinkButton.svelte';
 export { default as Badge } from './components/Badge.svelte';
 export { default as Card } from './components/Card.svelte';
 export { default as Drawer } from './components/Drawer.svelte';
@@ -83,6 +87,8 @@ export { default as LoadingSpinner } from './components/LoadingSpinner.svelte';
 export { default as StatusBadge } from './components/StatusBadge.svelte';
 export { default as TextInput } from './components/TextInput.svelte';
 export { default as TextArea } from './components/TextArea.svelte';
+export { textareaRowsHeight } from './utils/textareaRows';
+export type { TextareaRowsInput } from './utils/textareaRows';
 export { default as SelectInput } from './components/SelectInput.svelte';
 export { default as PhoneInput } from './components/PhoneInput.svelte';
 export { default as AudioWaveform } from './components/AudioWaveform.svelte';
@@ -202,6 +208,8 @@ export type { MapJob, MapAgent } from './types/maps';
 export { loadGoogleMapsAPI, isGoogleMapsLoaded, isPlacesLoaded, isGeometryLoaded, } from './utils/googleMapsLoader';
 export { tooltip } from './actions/tooltip';
 export type { TooltipOptions } from './actions/tooltip';
+export { scrollEdge, edgeOpacity, edgeDistances } from './actions/scrollEdge';
+export type { ScrollEdgeOptions, ScrollEdgeSide } from './actions/scrollEdge';
 export { staggerEntrance } from './actions/staggerEntrance';
 export type { StaggerEntranceOptions } from './actions/staggerEntrance';
 export { attention } from './actions/attention';
@@ -216,7 +224,8 @@ export { floating, makeVirtualAnchor } from './actions/floating';
 export type { FloatingOptions, Placement } from './actions/floating';
 export { glide } from './transitions/glide';
 export type { GlideOrigin, GlideParams } from './transitions/glide';
-export { themeWipe } from './utils/themeWipe';
+export { themeWipe, wipeOrigin, coverRadius } from './utils/themeWipe';
+export type { ThemeWipeOptions } from './utils/themeWipe';
 export { viewTransition } from './utils/viewTransition';
 export { MOTION_LEVELS, DEFAULT_MOTION_LEVEL, MOTION_LEVEL_ATTR, MOTION_DURATIONS, MOTION_LEVEL_SCALE, MOTION_LEVEL_TRAVEL, MOTION_EASING_POINTS, isMotionLevel, parseMotionLevel, prefersReducedMotion, resolveMotionLevel, motionContextFor, getMotionContext, motionDuration, effectiveEasing, setMotionLevel, cubicBezier, motionEasing, motionFade, motionScale, motionSlide, resolveMotionTiming, createMotionLevelStore } from './motion';
 export type { MotionLevel, MotionDurationToken, MotionEasingToken, MotionContext, EasingFn, MotionTransitionParams, MotionTransitionConfig, MotionFadeParams, MotionScaleParams, MotionSlideParams, ResolvedMotionTiming, MotionState, MotionLevelStore, MotionLevelStoreOptions } from './motion';
@@ -240,6 +249,7 @@ export { default as AnimatedNumber } from './components/AnimatedNumber.svelte';
 export { default as CopyButton } from './components/CopyButton.svelte';
 export { default as HoldToConfirm } from './components/HoldToConfirm.svelte';
 export { default as PinInput } from './components/PinInput.svelte';
+export { applyCellInput as applyPinCellInput, distribute as distributePin, cellsFromValue as pinCellsFromValue, isPinComplete, sanitizePin } from './utils/pinInput';
 export { default as PasswordMeter } from './components/PasswordMeter.svelte';
 export { default as QuantityStepper } from './components/QuantityStepper.svelte';
 export { default as TypingIndicator } from './components/messaging/TypingIndicator.svelte';
@@ -261,6 +271,9 @@ export type { StickState, StickToBottomOptions, StickController } from './action
 export { ansiToHtml, ansiToHtmlStateful, ansiToHtmlWithLinks, ansiToHtmlWithHierarchy, linkifyUrls, stripAnsi, classifyLine, parseOutputLines, createDefaultAnsiState } from './utils/ansiToHtml';
 export type { AnsiState, ParsedLine } from './utils/ansiToHtml';
 export { default as Breadcrumb } from './components/basic/Breadcrumb.svelte';
+export type { BreadcrumbItem } from './components/basic/Breadcrumb.svelte';
+export { collapseBreadcrumb } from './components/basic/breadcrumbCollapse';
+export type { BreadcrumbSlot } from './components/basic/breadcrumbCollapse';
 export { default as Alert } from './components/basic/Alert.svelte';
 export { default as ButtonGroup } from './components/basic/ButtonGroup.svelte';
 export { default as Switch } from './components/basic/Switch.svelte';
@@ -338,3 +351,25 @@ export { stepsSummary, stepsRemaining, isStepsFinished, clampStepProgress } from
 export { default as NotificationCenter } from './components/NotificationCenter.svelte';
 export { DEFAULT_NOTIFICATION_TABS, DATE_GROUP_LABELS as NOTIFICATION_DATE_GROUP_LABELS, dateGroupKey as notificationDateGroupKey, groupNotificationsByDate, toTimestampMs as notificationTimestampMs, isNotificationUnread, unreadIds as unreadNotificationIds, filterByTab as filterNotificationsByTab, tabCounts as notificationTabCounts, unreadSummary as notificationUnreadSummary } from './components/notificationCenter';
 export type { NotificationItem, NotificationAction, NotificationTab, NotificationStatus, NotificationGroup, DateGroupKey as NotificationDateGroupKey } from './components/notificationCenter';
+export { default as TreeView } from './components/tree/TreeView.svelte';
+export type { TreeRowContext, TreeViewVirtualOptions } from './components/tree/TreeView.svelte';
+export { flattenTree, collectBranchIds, pathToNode } from './components/tree/flattenTree';
+export type { FlatTreeNode, FlattenTreeOptions } from './components/tree/flattenTree';
+export { resolveTreeKey, treeTypeahead } from './components/tree/treeKeys';
+export type { TreeKeyResult } from './components/tree/treeKeys';
+export { default as StatCard } from './components/stats/StatCard.svelte';
+export type { StatTone } from './components/stats/StatCard.svelte';
+export { default as StatGroup } from './components/stats/StatGroup.svelte';
+export { default as ChartCard } from './components/stats/ChartCard.svelte';
+export type { ChartCardPoint, ChartCardContext } from './components/stats/ChartCard.svelte';
+export { default as BarList } from './components/stats/BarList.svelte';
+export type { BarListItem } from './components/stats/BarList.svelte';
+export { default as ActivityHeatmap } from './components/stats/ActivityHeatmap.svelte';
+export { buildHeatmap, moveHeatFocus, isoDay as heatmapIsoDay, defaultLevelOf as heatmapLevelOf } from './components/stats/heatmap';
+export type { HeatDay, HeatmapLayout, BuildHeatmapOptions } from './components/stats/heatmap';
+export { default as SegmentedControl } from './components/SegmentedControl.svelte';
+export type { SegmentedOption } from './components/SegmentedControl.svelte';
+export { default as SettingsSection } from './components/settings/SettingsSection.svelte';
+export { default as SettingsRow } from './components/settings/SettingsRow.svelte';
+export type { SettingsRowContext } from './components/settings/SettingsRow.svelte';
+export * from './data/grid/index';