@joewinke/jatui 0.26.0 → 0.27.1

package/dist/components/table/groupRows.js

@@ -0,0 +1,118 @@
+/**
+ * groupRows — grouped render-list flattening (jatui-u6d4e.2).
+ *
+ * Spec: jat `docs/design/datatable-virtualisation-group-rows.md` §3.2.
+ *
+ * Turns an already filtered + sorted row array into the flat list a table (or a
+ * row window) renders: group header items interleaved with row items, nested to
+ * any number of levels. Pure, DOM-free and framework-free so it runs under
+ * node:test and can feed a virtualiser directly (one item = one rendered line).
+ *
+ *   - Rows inside a group keep the order the caller passed in — the page's sort
+ *     comparator and tiebreakers survive untouched. Only GROUPS are reordered,
+ *     by `level.compare` (default: first-seen order).
+ *   - A collapsed group still emits its header (with `collapsed: true` and the
+ *     full `rows`/`count`) but nothing beneath it.
+ *   - `showHeader` returning false hides that header: its rows (and subgroups)
+ *     still render, one visual level shallower. A hidden header cannot be
+ *     toggled, so `collapsed` is ignored for it.
+ *   - `depth` is the VISUAL nesting level — the number of visible headers above
+ *     the item — so hidden headers never leave an indentation gap. `path` /
+ *     `groupPath` always carry the full key path.
+ *   - `position` (first/middle/last/only) is computed over each contiguous run of
+ *     rows under the same visible parent, which is what ├ / └ tree glyphs need.
+ */
+/** Separator joining a group path into the key used by `collapsed`. */
+export const GROUP_PATH_SEPARATOR = '::';
+/** The `collapsed`-set key for a group path: ["jat", "jat-vte6e"] → "jat::jat-vte6e". */
+export function groupPathKey(path) {
+    return path.join(GROUP_PATH_SEPARATOR);
+}
+/** Bucket rows by key, preserving first-seen key order and in-bucket row order. */
+function bucket(rows, key) {
+    const out = new Map();
+    for (const row of rows) {
+        const k = key(row);
+        const list = out.get(k);
+        if (list)
+            list.push(row);
+        else
+            out.set(k, [row]);
+    }
+    return out;
+}
+export function groupRows(rows, levels, opts) {
+    const { getRowId, collapsed, label } = opts;
+    const items = [];
+    // Parallel to `items`: identity of the visible parent of each row item, so
+    // the position pass can tell a run of siblings from two adjacent runs.
+    const parents = [];
+    const walk = (groupRowsIn, levelIndex, path, depth, visibleParent) => {
+        if (levelIndex >= levels.length) {
+            for (const row of groupRowsIn) {
+                items.push({
+                    kind: 'row',
+                    row,
+                    id: getRowId(row),
+                    depth,
+                    groupPath: path,
+                    position: 'only'
+                });
+                parents.push(visibleParent);
+            }
+            return;
+        }
+        const level = levels[levelIndex];
+        const buckets = bucket(groupRowsIn, level.key);
+        const keys = [...buckets.keys()];
+        // Array.prototype.sort is stable, so equal keys keep first-seen order.
+        if (level.compare)
+            keys.sort(level.compare);
+        for (const key of keys) {
+            const members = buckets.get(key);
+            const groupPath = [...path, key];
+            const shown = level.showHeader ? level.showHeader(key, members) : true;
+            if (!shown) {
+                walk(members, levelIndex + 1, groupPath, depth, visibleParent);
+                continue;
+            }
+            const pathKey = groupPathKey(groupPath);
+            const isCollapsed = collapsed.has(pathKey);
+            items.push({
+                kind: 'group',
+                key,
+                path: groupPath,
+                depth,
+                label: label ? label(groupPath) : key,
+                rows: members,
+                count: members.length,
+                collapsed: isCollapsed
+            });
+            parents.push(null);
+            if (!isCollapsed)
+                walk(members, levelIndex + 1, groupPath, depth + 1, pathKey);
+        }
+    };
+    // The root parent can't collide with a real path key: those are all built
+    // from keys at least one level deep, and the root is only used at depth 0.
+    walk(rows, 0, [], 0, '\u0000root');
+    // Position pass: a run is consecutive row items sharing one visible parent.
+    let i = 0;
+    while (i < items.length) {
+        if (items[i].kind !== 'row') {
+            i++;
+            continue;
+        }
+        let j = i;
+        while (j + 1 < items.length && items[j + 1].kind === 'row' && parents[j + 1] === parents[i])
+            j++;
+        if (j > i) {
+            items[i].position = 'first';
+            for (let k = i + 1; k < j; k++)
+                items[k].position = 'middle';
+            items[j].position = 'last';
+        }
+        i = j + 1;
+    }
+    return items;
+}

package/dist/components/table/index.d.ts

@@ -1,5 +1,11 @@
 export { default as DataTable } from './DataTable.svelte';
+export { default as ManageColumnsDropdown } from './ManageColumnsDropdown.svelte';
+export type { ManageColumnsProps } from './ManageColumnsDropdown.svelte';
+export { saveColumnSettings, loadColumnSettings } from './columnStorage.js';
+export type { ColumnSettings } from './columnStorage.js';
 export { flexRender } from './flexRender';
 export { columnResize } from './columnResize';
 export type { ColumnResizeOptions } from './columnResize';
-export type { DataTableProps, DataTableApi, DataTableRowProps, DataTableHeaderProps, DataTableSortEvent, DataTableVariant, GroupedItem, SelectionEvent, ColumnDef, Row, SortingState } from './types';
+export type { DataTableProps, DataTableApi, DataTableRowProps, DataTableHeaderProps, DataTableSortEvent, DataTableVariant, DataTableVirtualOptions, DataTableRowWindow, DataTableRowWindowOptions, DataTableRenderItem, DataTableGroupHeaderContext, SelectionEvent, ColumnDef, Row, SortingState } from './types';
+export { groupRows, groupPathKey, GROUP_PATH_SEPARATOR } from './groupRows';
+export type { GroupLevel, GroupedItem, GroupedGroupItem, GroupedRowItem, GroupedRowPosition, GroupRowsOptions } from './groupRows';

package/dist/components/table/index.js

@@ -1,4 +1,7 @@
 // Subpath entry: @joewinke/jatui/table — requires peer @tanstack/table-core.
 export { default as DataTable } from './DataTable.svelte';
+export { default as ManageColumnsDropdown } from './ManageColumnsDropdown.svelte';
+export { saveColumnSettings, loadColumnSettings } from './columnStorage.js';
 export { flexRender } from './flexRender';
 export { columnResize } from './columnResize';
+export { groupRows, groupPathKey, GROUP_PATH_SEPARATOR } from './groupRows';

package/dist/components/table/types.d.ts

@@ -2,29 +2,88 @@ import type { Snippet } from 'svelte';
 import type { ColumnDef, Row, SortingState } from '@tanstack/table-core';
 export type { ColumnDef, Row, SortingState };
 /**
- * One entry in the table's render list. Today DataTable renders flat rows, so
- * every item is `kind: 'row'` with `depth: 0`; the `group` variant is the shape
- * the grouped render list (`groupRows`, design doc
- * jat/docs/design/datatable-virtualisation-group-rows.md §3.2) will produce, so
- * `rowProps` callers written now keep working when grouping lands.
+ * One entry in the table's render list. Flat tables render `kind: 'row'` items
+ * with `depth: 0`; with `groupBy`, `groupRows` interleaves `kind: 'group'`
+ * header items. Defined in ./groupRows.
  */
-export type GroupedItem<T = any> = {
-    kind: 'group';
-    key: string;
-    path: string[];
-    depth: number;
-    label: string;
-    rows: T[];
-    count: number;
-    collapsed: boolean;
-} | {
-    kind: 'row';
-    row: T;
+import type { GroupedItem, GroupedGroupItem, GroupLevel } from './groupRows';
+export type { GroupedItem };
+/**
+ * An item of the windowed render list, as `virtual.estimateRowSize` sees it: a
+ * group header, a data row, or the detail row under an expanded row.
+ */
+export type DataTableRenderItem<TData = any> = GroupedItem<TData> | {
+    kind: 'detail';
+    row: TData;
     id: string;
-    depth: number;
-    groupPath: string[];
-    position: 'first' | 'middle' | 'last' | 'only';
 };
+/**
+ * The slice of `createRowWindow`'s options DataTable drives. Declared
+ * structurally here so `@joewinke/jatui/table` never imports the
+ * `@tanstack/virtual-core` peer — the caller hands the factory in.
+ */
+export interface DataTableRowWindowOptions {
+    count: () => number;
+    getKey: (index: number) => string;
+    estimateSize: (index: number) => number;
+    scrollRoot?: HTMLElement | Window | 'auto';
+    overscan?: number;
+    pinned?: () => Iterable<string>;
+    threshold?: number;
+    stickyIndices?: () => readonly (readonly number[])[];
+    scrollPaddingStart?: number;
+    scrollPaddingEnd?: number;
+    initialViewportSize?: number;
+}
+/** The slice of `createRowWindow`'s return value DataTable reads. */
+export interface DataTableRowWindow {
+    readonly items: ReadonlyArray<{
+        index: number;
+        key: string;
+        gapBefore: number;
+    }>;
+    readonly paddingTop: number;
+    readonly paddingBottom: number;
+    readonly windowed: boolean;
+    measure: (node: HTMLElement, key: string) => {
+        update?(key: string): void;
+        destroy(): void;
+    };
+    anchor: (node: HTMLElement) => {
+        destroy(): void;
+    };
+    scrollToKey(key: string, opts?: {
+        align?: 'auto' | 'start' | 'center' | 'end';
+    }): void;
+}
+/**
+ * Windowed body (grid mode). Pass `createRowWindow` from
+ * `@joewinke/jatui/virtual` — DataTable never imports it itself, so tables
+ * that don't window need not install the optional `@tanstack/virtual-core`.
+ * Read once at mount: toggling windowing on an existing table is not supported.
+ */
+export interface DataTableVirtualOptions<TData = any> {
+    createRowWindow: (opts: DataTableRowWindowOptions) => DataTableRowWindow;
+    /** First-paint height guess, px. Default: 40 rows, 36 group headers, 120 detail rows. */
+    estimateRowSize?: number | ((item: DataTableRenderItem<TData>) => number);
+    /** Extra items rendered above and below the viewport. Default 6. */
+    overscan?: number;
+    /** Below this many render items, draw everything (keeps enter animations). Default 0. */
+    threshold?: number;
+    /** The element that scrolls. Default `'auto'` = nearest ancestor that really scrolls. */
+    scrollRoot?: HTMLElement | Window | 'auto';
+    /** Height a sticky header covers at the top, px — `scrollToRow` keeps targets below it. */
+    scrollPaddingStart?: number;
+}
+/** Context handed to the `groupHeader` snippet. */
+export interface DataTableGroupHeaderContext {
+    /** Collapse / expand this group (updates `collapsed`). */
+    toggle(): void;
+    /** Number of columns — give your header cell `colspan={colspan}`. */
+    colspan: number;
+    collapsed: boolean;
+}
+export type { GroupedGroupItem, GroupLevel };
 /** What `rowProps` may put on a body `<tr>`. */
 export interface DataTableRowProps {
     class?: string;
@@ -124,6 +183,48 @@ export interface DataTableProps<TData = any> {
     tableClass?: string;
     /** Imperative handle — `bind:api`. */
     api?: DataTableApi;
+    /**
+     * Group levels, outermost first (0 levels = flat). Rows keep the table's
+     * order inside each group; groups are ordered by `level.compare`. With
+     * `paginated`, each page is grouped on its own.
+     */
+    groupBy?: GroupLevel<TData>[];
+    /** Collapsed group path keys (see `groupPathKey`) — `bind:collapsed`. Unbound, the table owns it. */
+    collapsed?: Set<string>;
+    /** Fires whenever a group is collapsed or expanded — persist it here. */
+    onCollapsedChange?: (next: Set<string>) => void;
+    /** Header label for a group path. Default: the group's own key. */
+    groupLabel?: (path: string[]) => string;
+    /**
+     * Renders the CELLS of a group header row (the `<tr>` is the table's). Give
+     * the cell `colspan={ctx.colspan}`. Default: one full-width cell with a
+     * collapse toggle, the label and the row count.
+     */
+    groupHeader?: Snippet<[GroupedGroupItem<TData>, DataTableGroupHeaderContext]>;
+    /** Group header rows stick below the (sticky) thead while their rows scroll past. */
+    stickyGroupHeaders?: boolean;
+    /** The thead sticks to the top of the scroll container. */
+    stickyHeader?: boolean;
+    /**
+     * Make the table its own vertical scroller (`max-height` + overflow auto),
+     * e.g. `'70vh'`. Without it, sticky headers stick against the page's
+     * scroller and horizontal overflow is clipped rather than scrolled.
+     */
+    maxHeight?: string;
+    /** Windowed body via `createRowWindow` — see DataTableVirtualOptions. */
+    virtual?: DataTableVirtualOptions<TData>;
+    /** Row ids that stay rendered while windowed (focused row, open editor, exit animation). */
+    pinnedRowIds?: Iterable<string>;
+    /**
+     * Expose ARIA grid semantics: `role="grid"` (`"treegrid"` with `groupBy`),
+     * `aria-selected` on rows when `selectable`, `aria-level` / `aria-expanded`
+     * on grouped rows, `aria-rowindex` / `aria-rowcount`. The host supplies row
+     * focus movement (e.g. `listNav`). Windowed tables always get the
+     * rowindex / rowcount pair so assistive tech knows rows are missing.
+     */
+    ariaGrid?: boolean;
+    /** Accessible name for the `<table>`. */
+    ariaLabel?: string;
 }
 export interface SelectionEvent<TData> {
     rows: TData[];

package/dist/index.d.ts

@@ -5,6 +5,12 @@ export type { ListNavOptions, ListNavController } from './actions/listNav';
 export { collapse } from './actions/collapse';
 export type { CollapseOptions } from './actions/collapse';
 export { default as Collapse } from './components/Collapse.svelte';
+export { keyboardScope, createKeyboardScope, comboFor } from './actions/keyboardScope';
+export type { KeyboardScope, KeyboardScopeHandlers } from './actions/keyboardScope';
+export { PollBackoff, createPollLoop, computeBackoffDelayMs } from './utils/pollBackoff';
+export type { PollBackoffOptions } from './utils/pollBackoff';
+export { default as PageHeader } from './components/basic/PageHeader.svelte';
+export { default as ProgressButton } from './components/basic/ProgressButton.svelte';
 export { default as LinkedColumns } from './components/linked-columns/LinkedColumns.svelte';
 export type { ColumnLink } from './components/linked-columns/types.js';
 export { default as ChapterTimeline } from './components/replay/ChapterTimeline.svelte';
@@ -176,8 +182,8 @@ export type { MarkupTool, Point, MarkupShape, ArrowShape, RectangleShape, Ellips
 export type { Annotation, AnnotationProfile, AnnotationThread, AnnotationCallbacks, } from './types/annotation';
 export { default as KeyboardShortcutsOverlay } from './components/KeyboardShortcutsOverlay.svelte';
 export type { KeyboardShortcut, SectionEntry as KeyboardShortcutSectionEntry, ShortcutSection as KeyboardShortcutSection, } from './components/KeyboardShortcutsOverlay.svelte';
-export { createShortcutRegistry, getShortcutRegistry, formatShortcut, parseCombo as parseShortcutCombo, isTypingTarget, detectPlatform as detectShortcutPlatform, SIDEBAR_TOGGLE_KEY, } from './utils/keyboardShortcutRegistry';
-export type { ShortcutRegistry, ShortcutDefinition, ShortcutModifier, ShortcutPlatform, PushContextOptions as ShortcutContextOptions, RegistrySection as ShortcutRegistrySection, ToSectionsOptions as ShortcutSectionsOptions, ShortcutRegistryOptions, ShortcutEventTarget, } from './utils/keyboardShortcutRegistry';
+export { createShortcutRegistry, getShortcutRegistry, formatShortcut, parseCombo as parseShortcutCombo, isTypingTarget, detectPlatform as detectShortcutPlatform, SIDEBAR_TOGGLE_KEY, normalizeCombo, comboFromEvent, validateCombo, localStorageBindingStore, BROWSER_RESERVED_COMBOS, } from './utils/keyboardShortcutRegistry';
+export type { ShortcutRegistry, ShortcutDefinition, ShortcutModifier, ShortcutPlatform, PushContextOptions as ShortcutContextOptions, RegistrySection as ShortcutRegistrySection, ToSectionsOptions as ShortcutSectionsOptions, ShortcutRegistryOptions, ShortcutEventTarget, ShortcutDeclaration, BindingOverrides, BindingStore, BindingInfo, ShortcutConflict, ShortcutConflictSeverity, FindConflictsTarget, AllConflictsOptions as ShortcutAllConflictsOptions, ReservedCombo, RebindResult, RebindOptions as ShortcutRebindOptions, RejectedBinding, RawShortcutHandler, ModifierState as ShortcutModifierState, } from './utils/keyboardShortcutRegistry';
 export { default as MapView } from './components/MapView.svelte';
 export { default as LocationMap } from './components/LocationMap.svelte';
 export { default as GPSTracker } from './components/GPSTracker.svelte';
@@ -227,8 +233,17 @@ export { default as SidebarItem } from './components/shell/SidebarItem.svelte';
 export { default as NavigationMenu } from './components/shell/NavigationMenu.svelte';
 export { createSidebarState } from './components/shell/shell';
 export type { SidebarMode, SidebarState } from './components/shell/shell';
+export { groupRows, groupPathKey, GROUP_PATH_SEPARATOR } from './components/table/groupRows';
+export type { GroupLevel, GroupedItem, GroupedGroupItem, GroupedRowItem, GroupedRowPosition, GroupRowsOptions } from './components/table/groupRows';
 export { default as Kbd } from './components/basic/Kbd.svelte';
 export { default as Empty } from './components/basic/Empty.svelte';
+export { default as ErrorState } from './components/basic/ErrorState.svelte';
+export type { EmptyGlyph } from './components/basic/Empty.svelte';
+export { default as JumpToLatest } from './components/basic/JumpToLatest.svelte';
+export { createStickToBottom } from './actions/stickToBottom';
+export type { StickState, StickToBottomOptions, StickController } from './actions/stickToBottom';
+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 { default as Alert } from './components/basic/Alert.svelte';
 export { default as ButtonGroup } from './components/basic/ButtonGroup.svelte';
@@ -255,6 +270,13 @@ export { useElapsedEstimate } from './components/batch/useElapsedEstimate';
 export type { ElapsedEstimate } from './components/batch/useElapsedEstimate';
 export { pollOperation, PollTimeoutError } from './components/batch/pollOperation';
 export type { PollStep, PollContext, PollOptions } from './components/batch/pollOperation';
+export { swipe } from './actions/swipe';
+export type { SwipeOptions } from './actions/swipe';
+export { longpress } from './actions/longpress';
+export type { LongPressOptions, LongPressDetail } from './actions/longpress';
+export { resolveSnapTarget, keyboardInsetPx, clampSnapHeight, FLICK_VELOCITY_PX_MS } from './utils/snapFlick';
+export type { SnapName, SnapHeight, SnapInput, SnapResult } from './utils/snapFlick';
+export { default as BottomSheet } from './components/BottomSheet.svelte';
 export { default as VariantMatrixPicker } from './components/variant/VariantMatrixPicker.svelte';
 export { countCombinations, generateCombinations, generateVariantFilename, findVariantOption, variantCategoryMode } from './components/variant/variantCombinations';
 export type { VariantCategory, VariantOption, VariantSelection, VariantSelectionMode, VariantCombination } from './components/variant/variantCombinations';

package/dist/index.js

@@ -3,6 +3,26 @@ export { railNav, createRailNav, cycle } from './actions/railNav';
 export { listNav, createListNav } from './actions/listNav';
 export { collapse } from './actions/collapse';
 export { default as Collapse } from './components/Collapse.svelte';
+// Keyboard scope (upstreamed from the JAT IDE — jatui-rl7w6.5, audit U6):
+// embed-safe shortcuts for a self-contained widget living in a busy host
+// page — ownership decided from DOM engagement (what was last clicked/focused),
+// the container-local complement to the shortcut registry's context stack.
+export { keyboardScope, createKeyboardScope, comboFor } from './actions/keyboardScope';
+// Poll loop with coordinated exponential backoff (upstreamed from the JAT IDE
+// — jatui-rl7w6.5, audit U12): the recurring-poll companion to pollOperation.
+// Framework-free; skips ticks while the document is hidden, never overlaps
+// ticks, backs off exponentially with jitter capped at maxIntervalMs.
+export { PollBackoff, createPollLoop, computeBackoffDelayMs } from './utils/pollBackoff';
+// Page chrome (upstreamed from the JAT IDE — jatui-rl7w6.5, audit U7):
+// PageHeader, the standard route header, and ProgressButton, the
+// phase-narrating async submit button.
+export { default as PageHeader } from './components/basic/PageHeader.svelte';
+export { default as ProgressButton } from './components/basic/ProgressButton.svelte';
+// NOTE: ContextMenuTrigger is exported ONCE — grouped with ContextMenu further
+// down. 0.27.0 shipped it twice here and in the ContextMenu section, and the
+// duplicated `export` in dist/index.js / index.d.ts hard-failed every
+// rolldown/vite consumer build ('[PARSE_ERROR] Duplicated export'). Guarded by
+// tests/unit/indexBarrelExports.test.ts + scripts/verify-dist.mjs (check 4).
 // Components — Session primitives (from JAT IDE, jat-jj79f.16 G1)
 export { default as LinkedColumns } from './components/linked-columns/LinkedColumns.svelte';
 export { default as ChapterTimeline } from './components/replay/ChapterTimeline.svelte';
@@ -193,7 +213,7 @@ export { default as AnnotationPanel } from './components/AnnotationPanel.svelte'
 export { MARKUP_COLORS, DEFAULT_STROKE_WIDTH, renderShape, renderAllShapes, nextShapeId, } from './components/markup';
 // Components — Keyboard Navigation
 export { default as KeyboardShortcutsOverlay } from './components/KeyboardShortcutsOverlay.svelte';
-export { createShortcutRegistry, getShortcutRegistry, formatShortcut, parseCombo as parseShortcutCombo, isTypingTarget, detectPlatform as detectShortcutPlatform, SIDEBAR_TOGGLE_KEY, } from './utils/keyboardShortcutRegistry';
+export { createShortcutRegistry, getShortcutRegistry, formatShortcut, parseCombo as parseShortcutCombo, isTypingTarget, detectPlatform as detectShortcutPlatform, SIDEBAR_TOGGLE_KEY, normalizeCombo, comboFromEvent, validateCombo, localStorageBindingStore, BROWSER_RESERVED_COMBOS, } from './utils/keyboardShortcutRegistry';
 // Components — Google Maps (DispatchMap fork + location primitives)
 export { default as MapView } from './components/MapView.svelte';
 export { default as LocationMap } from './components/LocationMap.svelte';
@@ -265,9 +285,18 @@ export { createSidebarState } from './components/shell/shell';
 //   import { DataTable, flexRender } from '@joewinke/jatui/table';    (@tanstack/table-core)
 //   import { GraphCanvas } from '@joewinke/jatui/graph';              (@xyflow/svelte)
 //   import { Carousel } from '@joewinke/jatui/carousel';              (embla-carousel-svelte)
+// groupRows is pure (no @tanstack peer), so it is also safe on the barrel —
+// same function as '@joewinke/jatui/table' exports (jatui-u6d4e.2).
+export { groupRows, groupPathKey, GROUP_PATH_SEPARATOR } from './components/table/groupRows';
 // Basic primitives (thin DaisyUI wraps — layering policy)
 export { default as Kbd } from './components/basic/Kbd.svelte';
 export { default as Empty } from './components/basic/Empty.svelte';
+export { default as ErrorState } from './components/basic/ErrorState.svelte';
+export { default as JumpToLatest } from './components/basic/JumpToLatest.svelte';
+// Streaming-transcript auto-scroll (upstreamed from the JAT IDE, U3 — jatui-rl7w6.3).
+export { createStickToBottom } from './actions/stickToBottom';
+// ANSI terminal output → HTML (upstreamed from the JAT IDE, U5 — jatui-rl7w6.3).
+export { ansiToHtml, ansiToHtmlStateful, ansiToHtmlWithLinks, ansiToHtmlWithHierarchy, linkifyUrls, stripAnsi, classifyLine, parseOutputLines, createDefaultAnsiState } from './utils/ansiToHtml';
 export { default as Breadcrumb } from './components/basic/Breadcrumb.svelte';
 export { default as Alert } from './components/basic/Alert.svelte';
 export { default as ButtonGroup } from './components/basic/ButtonGroup.svelte';
@@ -289,6 +318,12 @@ export { toJobRows, nextJobsToStart, isProcessLimitReached, moveJob, summarizeJo
 export { rollingAverage, estimateRemainingMs } from './components/batch/elapsedEstimate';
 export { useElapsedEstimate } from './components/batch/useElapsedEstimate';
 export { pollOperation, PollTimeoutError } from './components/batch/pollOperation';
+// Mobile gesture kit (upstreamed from the JAT IDE — jatui-rl7w6.2):
+// swipe + longpress actions, snapFlick math and the BottomSheet primitive.
+export { swipe } from './actions/swipe';
+export { longpress } from './actions/longpress';
+export { resolveSnapTarget, keyboardInsetPx, clampSnapHeight, FLICK_VELOCITY_PX_MS } from './utils/snapFlick';
+export { default as BottomSheet } from './components/BottomSheet.svelte';
 // Variant matrix picker + combination algebra (harvested from vid-gen FrameVariantGenerator — jatui-m4uz3.8).
 export { default as VariantMatrixPicker } from './components/variant/VariantMatrixPicker.svelte';
 export { countCombinations, generateCombinations, generateVariantFilename, findVariantOption, variantCategoryMode } from './components/variant/variantCombinations';

package/dist/utils/ansiToHtml.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Convert ANSI escape codes to HTML spans with inline styles
+ * Supports common color codes used by Claude Code / terminal output
+ * Includes automatic contrast adjustment for background colors
+ */
+export interface AnsiState {
+    bold: boolean;
+    dim: boolean;
+    italic: boolean;
+    underline: boolean;
+    reverse: boolean;
+    color: string | null;
+    bgColor: string | null;
+}
+export declare function createDefaultAnsiState(): AnsiState;
+/**
+ * Convert a string containing ANSI escape codes to HTML
+ */
+export declare function ansiToHtml(input: string): string;
+/** Strip ANSI codes from a string (for plain text).
+ *
+ * THE one ANSI stripper for the IDE (jat-69f8v dedup): every consumer that
+ * needs plain text without escape codes imports this — do not write a local
+ * copy (scripts/grep-gate-helper-dedup.sh refuses new definitions).
+ *
+ * Bare-escape handling is a strict ECMA-48 parse (jat-ybwwn): the old rule
+ * \x1b[^\[]\S* ate the escape AND every following non-space character, so
+ * "\x1b7hello" (DECSC + text) lost "hello". Escapes are now matched
+ * sequence-by-sequence; text after a two-byte escape survives.
+ */
+export declare function stripAnsi(input: string): string;
+/**
+ * Convert URLs in HTML to clickable links
+ * Must be called AFTER ansiToHtml to avoid breaking span tags
+ */
+export declare function linkifyUrls(html: string): string;
+/**
+ * Convert ANSI to HTML and make URLs clickable
+ */
+export declare function ansiToHtmlWithLinks(input: string): string;
+/**
+ * Convert ANSI multi-line output to HTML with per-line hierarchy classes.
+ * Wraps each line in <span class="tl-{kind}"> so CSS can mute tool calls
+ * and brighten prose without per-line DOM nodes.
+ *
+ * Intended for <pre>-based surfaces that render the whole output string
+ * at once (OverlayTerminal) where individual div wrappers aren't available.
+ */
+export declare function ansiToHtmlWithHierarchy(input: string): string;
+/**
+ * Convert ANSI to HTML starting from a given ANSI state, returning the end state.
+ * Enables incremental parsing: call with the end state of the previous segment to
+ * continue rendering without re-processing already-seen content.
+ */
+export declare function ansiToHtmlStateful(input: string, startState: AnsiState): {
+    html: string;
+    endState: AnsiState;
+};
+export interface ParsedLine {
+    content: string;
+    html: string;
+    endState: AnsiState;
+    /** Visual hierarchy class: 'tc' = tool-call header, 'tr' = tool-result, 'td' = tool-detail, '' = prose */
+    lineClass: string;
+}
+/**
+ * Classify a raw terminal line for visual hierarchy rendering.
+ *
+ * Claude Code tool calls follow a predictable ANSI pattern:
+ *   - Tool call header: ANSI-colored ● (U+25CF) or ⏺ (U+23FA) followed by bold tool name
+ *   - Tool result:      "  ⎿ " prefix (2 spaces + U+23BF)
+ *   - Tool detail:      5-space indent + dim content (folded result body)
+ *   - Separator:        Line of ─ or ━ box-drawing characters
+ *
+ * Returns a short CSS class suffix: 'tc' | 'tr' | 'td' | 'sep' | '' (prose)
+ */
+export declare function classifyLine(raw: string): string;
+/**
+ * Parse an array of raw line strings into ParsedLine records.
+ * Each line's ANSI end state is passed as the start state for the next line,
+ * so color/bold/etc. carry across line boundaries correctly.
+ */
+export declare function parseOutputLines(rawLines: string[], startState: AnsiState): ParsedLine[];