@k2b/ui 0.1.0-rc.0 → 0.1.1

package/dist/types/content/DataTable.d.ts

@@ -0,0 +1,113 @@
+import { type JSX } from "solid-js";
+export type DataTableColumn<T> = {
+    id: string;
+    header: JSX.Element | ((ctx: {
+        col: DataTableColumn<T>;
+    }) => JSX.Element);
+    subtitle?: JSX.Element | ((ctx: {
+        col: DataTableColumn<T>;
+    }) => JSX.Element);
+    value?: keyof T | ((row: T) => unknown);
+    class?: string;
+    headerClass?: string;
+    cellClass?: string;
+    /** Defaults to right for numeric values and left for everything else. */
+    align?: "left" | "center" | "right";
+    /**
+     * Marks the column sortable. Pass a string when the server's sort key
+     * differs from the column id — they often do, because one column can show a
+     * rate while another sorts by the absolute count behind it.
+     */
+    sortable?: boolean | string;
+};
+export type DataTableSort = {
+    key: string;
+    direction: "asc" | "desc";
+};
+export type DataTableRenderCell<T> = (ctx: {
+    row: T;
+    col: DataTableColumn<T>;
+    value: unknown;
+    render: (value: unknown) => JSX.Element;
+}) => JSX.Element;
+export type DataTableRenderHeader<T> = (ctx: {
+    col: DataTableColumn<T>;
+    render: () => JSX.Element;
+}) => JSX.Element;
+export type DataTableFooter<T> = {
+    values?: Record<string, unknown>;
+    renderCell?: (ctx: {
+        col: DataTableColumn<T>;
+        value: unknown;
+        render: (value: unknown) => JSX.Element;
+    }) => JSX.Element;
+};
+export type DataTableProps<T> = {
+    rows: readonly T[];
+    columns: readonly DataTableColumn<T>[];
+    /** Accessible name for a standalone table region. Defaults to "Data table". */
+    ariaLabel?: string;
+    /** ID of a visible heading that labels the table region. Takes precedence over ariaLabel. */
+    ariaLabelledBy?: string;
+    getRowId?: (row: T) => string;
+    /** Current server-side ordering, or null when the default applies. */
+    sort?: DataTableSort | null;
+    /**
+     * Link target for a sortable header. Link-based because every admin table is
+     * server-rendered: sorting is a query change, not client state.
+     */
+    sortHref?: (next: DataTableSort) => string;
+    selectedRowId?: string | null;
+    rowClass?: string | ((row: T) => string | undefined);
+    hoverRows?: boolean;
+    onRowClick?: (row: T) => void;
+    onRowDoubleClick?: (row: T) => void;
+    renderCell?: DataTableRenderCell<T>;
+    renderHeader?: DataTableRenderHeader<T>;
+    footer?: DataTableFooter<T>;
+    hasMore?: boolean;
+    loadingMore?: boolean;
+    onLoadMore?: () => void;
+    empty?: JSX.Element;
+    density?: "compact" | "normal";
+    stickyHeader?: boolean;
+    highlightColumns?: boolean;
+    verticalAlign?: "top" | "middle" | "bottom";
+    cellContentClass?: string;
+    fillHeight?: boolean;
+    /** Visual frame for a standalone table. Defaults preserve the legacy class-based behavior. */
+    surface?: "paper" | "plain";
+    class?: string;
+    /** Additional classes for the table element. Core table geometry is always retained. */
+    tableClass?: string;
+    scrollPreserveKey?: string | false;
+};
+export type DataTablePanelProps = {
+    children: JSX.Element;
+    class?: string;
+};
+export type DataTableHeaderProps = {
+    title: string;
+    subtitle?: string;
+    children?: JSX.Element;
+    as?: "h1" | "h2" | "h3";
+    size?: "sm" | "md";
+    class?: string;
+};
+export type DataTableControlsProps = {
+    children: JSX.Element;
+    class?: string;
+};
+export type DataTablePanelFooterProps = {
+    children: JSX.Element;
+    class?: string;
+};
+type DataTableComponent = {
+    <T>(props: DataTableProps<T>): JSX.Element;
+    Panel: (props: DataTablePanelProps) => JSX.Element;
+    Header: (props: DataTableHeaderProps) => JSX.Element;
+    Controls: (props: DataTableControlsProps) => JSX.Element;
+    Footer: (props: DataTablePanelFooterProps) => JSX.Element;
+};
+declare const DataTable: DataTableComponent;
+export default DataTable;

package/dist/types/content/Docs.d.ts

@@ -0,0 +1,52 @@
+import { type JSX } from "solid-js";
+import type { CodeDisplayLanguage } from "./CodeDisplay";
+export type DocCodeHighlighter = (code: string) => string;
+export type DocCodeProps = {
+    code: string;
+    title?: string;
+    language?: CodeDisplayLanguage;
+    highlight?: DocCodeHighlighter;
+    format?: (code: string) => string;
+    copy?: boolean;
+    copyText?: string;
+    lineNumbers?: boolean;
+    class?: string;
+};
+export type DocNoteVariant = "info" | "tip" | "warning";
+export type DocRow = {
+    title: string;
+    icon?: string;
+    text: JSX.Element;
+};
+export type DocConcept = {
+    title: string;
+    icon: string;
+    text: JSX.Element;
+};
+export declare const DocPage: (props: {
+    children: JSX.Element;
+    class?: string;
+}) => JSX.Element;
+export declare const DocLead: (props: {
+    children: JSX.Element;
+}) => JSX.Element;
+export declare const DocSection: (props: {
+    title: string;
+    eyebrow?: string;
+    children: JSX.Element;
+}) => JSX.Element;
+export declare const DocInlineCode: (props: {
+    children: JSX.Element;
+}) => JSX.Element;
+export declare const DocCode: (props: DocCodeProps) => JSX.Element;
+export declare const DocConceptGrid: (props: {
+    items: DocConcept[];
+}) => JSX.Element;
+export declare const DocRows: (props: {
+    items: DocRow[];
+}) => JSX.Element;
+export declare const DocNote: (props: {
+    title: string;
+    variant?: DocNoteVariant;
+    children: JSX.Element;
+}) => JSX.Element;

package/dist/types/content/FileBrowser.d.ts

@@ -0,0 +1,40 @@
+import { type FileTreeEntry } from "./FileTree";
+import { type FileViewContent, type FileViewRenderer } from "./FileView";
+export type FileSource = {
+    list(): Promise<FileTreeEntry[]>;
+    read(path: string): Promise<FileViewContent>;
+    write?(path: string, content: string, encoding?: "utf8" | "base64"): Promise<void>;
+    remove?(path: string): Promise<void>;
+    rename?(from: string, to: string): Promise<void>;
+    upload?(dirPath: string, files: File[]): Promise<void>;
+    downloadHref?(path: string): string | null;
+    /** Paths matching this predicate stay read-only even when the source can write (e.g. /input). */
+    isReadOnly?(path: string): boolean;
+};
+export type FileBrowserPanelProps = {
+    source: FileSource;
+    /** Hide every mutating affordance while retaining file selection and downloads. */
+    readOnly?: boolean;
+    /** Refetch entries when this host-controlled value changes. */
+    refreshKey?: unknown;
+    /** Preselect a file once entries are loaded. */
+    initialPath?: string;
+    /** Mirrors file selection into route state when the host needs durable navigation. */
+    onSelectedPathChange?: (path: string | null) => void;
+    /** Per-instance preview extensions forwarded to FileView. */
+    renderers?: readonly FileViewRenderer[];
+    /** Optional host copy/policy for leaving an unsaved file. */
+    confirmDiscard?: (path: string, nextPath: string | null) => boolean | Promise<boolean>;
+    /** Fixed shell height — the panes scroll inside it. */
+    class?: string;
+    /** Optional imperative refresh used by realtime owners that must await the visible update. */
+    registerRefresh?: (refresh: () => Promise<void>) => void | (() => void);
+};
+export declare function FileBrowserPanel(props: FileBrowserPanelProps): import("solid-js").JSX.Element;
+/** Open the file browser as a dialog. Returns when the dialog closes. */
+export declare const openFileBrowser: (options: {
+    source: FileSource;
+    title?: string;
+    subtitle?: string;
+    icon?: string;
+}) => Promise<void>;

package/dist/types/content/FileTree.d.ts

@@ -0,0 +1,29 @@
+import { type DropdownItem } from "../actions/Dropdown";
+import { type FileTreeEntry } from "./file-tree";
+export type { FileTreeEntry } from "./file-tree";
+/** Presence of a callback enables the matching UI affordance. */
+export type FileTreeActions = {
+    rename?: (path: string, nextName: string) => void | Promise<void>;
+    remove?: (path: string) => void | Promise<void>;
+    createFile?: (dirPath: string) => void | Promise<void>;
+    createFolder?: (dirPath: string) => void | Promise<void>;
+    /** Enables drag & drop of files and folders onto folders (and the tree root). */
+    move?: (path: string, targetDir: string) => void | Promise<void>;
+    /** Download menu entry — folders arrive as "Download as ZIP". */
+    download?: (path: string, isFolder: boolean) => void | Promise<void>;
+};
+export type FileTreeProps = {
+    entries: FileTreeEntry[];
+    selectedPath?: string | null;
+    onSelect?: (entry: FileTreeEntry) => void;
+    /** Controlled expansion; omit for internal state (folders start expanded). */
+    expandedPaths?: Set<string>;
+    onExpandedChange?: (expanded: Set<string>) => void;
+    /** Extra context-menu items per entry, merged above the built-in actions. */
+    contextMenu?: (entry: FileTreeEntry) => DropdownItem[];
+    actions?: FileTreeActions;
+    /** Accessible name for the tree. */
+    label?: string;
+    class?: string;
+};
+export default function FileTree(props: FileTreeProps): import("solid-js").JSX.Element;

package/dist/types/content/FileView.d.ts

@@ -0,0 +1,59 @@
+/**
+ * FileView — renders one file through a small renderer registry keyed by
+ * media type / path. Editing is enabled purely by the presence of `save`;
+ * without it every renderer is read-only. IDE-style chrome: editors reuse
+ * the markdown editor's surface (toolbar with an in-toolbar save, Ctrl/Cmd+S),
+ * previews are quiet paper panels with icon-only actions overlaid top-right.
+ * Custom renderers are passed per instance, which keeps SSR requests and
+ * independently mounted applications isolated.
+ */
+import { type Component, type JSX } from "solid-js";
+import { type FileViewFile } from "./file-view-preview";
+export type { FileViewFile, FileViewPreviewKind } from "./file-view-preview";
+export { canPreviewFile, getFileViewPreviewKind } from "./file-view-preview";
+export type FileViewContent = {
+    encoding: "utf8" | "base64";
+    content: string;
+    mediaType: string;
+};
+export type FileViewProps = {
+    file: FileViewFile;
+    load: () => Promise<FileViewContent>;
+    /** Refetch the current path when this host-owned revision changes. */
+    revision?: unknown;
+    /** Register an awaitable refresh for the currently visible preview. */
+    registerRefresh?: (refresh: () => Promise<void>) => void | (() => void);
+    /** Presence enables editing for text-based renderers. */
+    save?: (content: string) => Promise<void>;
+    /** Authenticated inline URL used by browser-native image, PDF, audio, and video previews. */
+    previewHref?: string | null;
+    downloadHref?: string | null;
+    /** App-specific renderers matched before the built-ins for this instance. */
+    renderers?: readonly FileViewRenderer[];
+    /** Reports local edit state so a parent browser can guard navigation. */
+    onDirtyChange?: (dirty: boolean) => void;
+    class?: string;
+};
+export type FileViewRendererProps = {
+    file: FileViewFile;
+    content: FileViewContent;
+    previewHref: string | null;
+    downloadHref: string | null;
+    /** Null when the file is read-only. */
+    editor: {
+        draft: () => string;
+        setDraft: (value: string) => void;
+        dirty: () => boolean;
+        saving: () => boolean;
+        save: () => Promise<void>;
+    } | null;
+};
+export type FileViewRenderer = {
+    id: string;
+    match: (file: FileViewFile, content: FileViewContent) => boolean;
+    component: Component<FileViewRendererProps>;
+    /** Text renderers that support the edit affordance when `save` is present. */
+    editable?: boolean;
+};
+export declare const formatFileViewSize: (bytes: number) => string;
+export default function FileView(props: FileViewProps): JSX.Element;

package/dist/types/content/Lightbox.d.ts

@@ -0,0 +1,16 @@
+export type LightboxImage = {
+    src: string;
+    alt?: string;
+    downloadUrl?: string;
+};
+type LightboxProps = {
+    images: LightboxImage[];
+    initialIndex?: number;
+    onClose: () => void;
+};
+/**
+ * Minimal, accessible lightbox using native <dialog>.
+ * Supports keyboard navigation, touch swipe gestures, and screen readers.
+ */
+export default function Lightbox(props: LightboxProps): import("solid-js").JSX.Element;
+export {};

package/dist/types/content/LogEntriesTable.d.ts

@@ -0,0 +1,14 @@
+export type LogTableEntry = {
+    id: number | string;
+    level: string;
+    source: string;
+    message: string;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+};
+type Props = {
+    entries: readonly LogTableEntry[];
+    emptyMessage?: string;
+};
+export default function LogEntriesTable(props: Props): import("solid-js").JSX.Element;
+export {};

package/dist/types/content/MarkdownView.d.ts

@@ -0,0 +1,46 @@
+type CommonProps = {
+    /** Optional additional CSS classes */
+    class?: string;
+    /**
+     * Visual heading scale. Markdown heading levels and document structure stay
+     * unchanged.
+     */
+    headingScale?: "compact" | "normal" | "large";
+};
+export type MarkdownViewProps = CommonProps & ({
+    /** Untrusted Markdown. Raw HTML and unsafe link protocols are escaped. */
+    markdown: string;
+    /** Exact standalone text tokens to emphasize without changing Markdown parsing or trusted-HTML boundaries. */
+    inlineTokens?: readonly string[];
+    trustedHtml?: never;
+} | {
+    /** Explicitly trusted, already-rendered HTML. The caller owns sanitization. */
+    trustedHtml: string;
+    markdown?: never;
+    inlineTokens?: never;
+});
+export type MarkdownRenderOptions = {
+    inlineTokens?: readonly string[];
+};
+export declare const renderSafeMarkdown: (markdown: string, options?: MarkdownRenderOptions) => string;
+/**
+ * Markdown View Component (SSR)
+ *
+ * Renders untrusted Markdown safely by default. Raw HTML and unsafe link
+ * protocols are escaped. Already-rendered HTML requires the deliberately named
+ * `trustedHtml` boundary; the caller owns sanitization in that mode.
+ *
+ * @example
+ * ```tsx
+ * import { MarkdownView } from "@k2b/ui";
+ *
+ * <MarkdownView markdown={source} />;
+ * ```
+ *
+ * @example Compact headings, e.g. inside comments or file previews:
+ * ```tsx
+ * <MarkdownView markdown={source} headingScale="compact" />;
+ * ```
+ */
+export default function MarkdownView(props: MarkdownViewProps): import("solid-js").JSX.Element;
+export {};

package/dist/types/content/Pagination.d.ts

@@ -0,0 +1,10 @@
+import { type LinkNavigateEvent } from "@k2b/ssr/nav";
+import { type JSX } from "solid-js";
+export type PaginationProps = {
+    currentPage: number;
+    totalPages: number;
+    baseUrl: string;
+    onNavigate?: (event: LinkNavigateEvent) => void | Promise<void>;
+};
+/** Link-based pagination with directional navigation and compact mobile disclosure. */
+export declare const Pagination: (props: PaginationProps) => JSX.Element;

package/dist/types/content/PdfPreview.d.ts

@@ -0,0 +1,11 @@
+export type PdfPreviewRequest = () => Promise<Response | Blob>;
+export type PdfPreviewProps = {
+    request: PdfPreviewRequest;
+    disabled?: () => boolean;
+    title?: string;
+    buttonLabel?: string;
+    openButtonLabel?: string;
+    emptyText?: string;
+    class?: string;
+};
+export default function PdfPreview(props: PdfPreviewProps): import("solid-js").JSX.Element;

package/dist/types/content/RangePicker.d.ts

@@ -0,0 +1,29 @@
+/**
+ * RangePicker — the time window every observability surface needs.
+ *
+ * Rendered as links rather than buttons on purpose: window selection is a
+ * server concern (the query, not the rendering), so it belongs in the URL and
+ * works without hydration. Callers supply the href per option, which is what
+ * lets each page keep its own other params intact — the hand-rolled copies
+ * differed exactly there, with one silently dropping every unrelated filter.
+ *
+ * The vocabulary stays with the caller too. Traces think in `10m…30d`, request
+ * telemetry in `1h…30d`, audit in days; a single hardcoded list would be wrong
+ * for most of them.
+ */
+export type RangeOption<T extends string> = {
+    value: T;
+    /** Defaults to the value, which is already short by convention (`24h`). */
+    label?: string;
+    href: string;
+};
+export type RangePickerProps<T extends string> = {
+    options: readonly RangeOption<T>[];
+    value: T;
+    /** Leading caption. Pass `null` to omit it in tight toolbars. */
+    label?: string | null;
+    /** Names the control for assistive tech; defaults to the visible label. */
+    ariaLabel?: string;
+    class?: string;
+};
+export default function RangePicker<T extends string>(props: RangePickerProps<T>): import("solid-js").JSX.Element;

package/dist/types/content/StructuredDataPreview.d.ts

@@ -0,0 +1,20 @@
+import { type MaybeAccessor } from "../inputs/field-contract";
+export type StructuredDataPreviewMode = "formatted" | "raw";
+export type StructuredDataValue = null | boolean | number | string | readonly StructuredDataValue[] | {
+    readonly [key: string]: StructuredDataValue;
+};
+export declare const isStructuredDataValue: (value: unknown, seen?: WeakSet<object>) => value is StructuredDataValue;
+export type StructuredDataPreviewProps = {
+    title?: string;
+    data: StructuredDataValue;
+    /** Controlled display mode. */
+    mode?: MaybeAccessor<StructuredDataPreviewMode>;
+    onModeChange?: (mode: StructuredDataPreviewMode) => void;
+    /** Initial mode for an uncontrolled preview. */
+    defaultMode?: StructuredDataPreviewMode;
+    copy?: boolean;
+    empty?: string;
+    maxRows?: number;
+    class?: string;
+};
+export default function StructuredDataPreview(props: StructuredDataPreviewProps): import("solid-js").JSX.Element;

package/dist/types/content/calendar-event-layout.d.ts

@@ -0,0 +1,16 @@
+export type CalendarIntervalLayout<T> = {
+    item: T;
+    lane: number;
+    lanes: number;
+    groupId: number;
+    groupStart: number;
+    groupEnd: number;
+};
+/**
+ * Assigns the lowest available visual lane to overlapping intervals.
+ * Sorting plus two binary heaps keeps large overlap groups at O(n log n).
+ */
+export declare const layoutCalendarIntervals: <T>(items: readonly T[], bounds: (item: T) => {
+    start: number;
+    end: number;
+}) => CalendarIntervalLayout<T>[];

package/dist/types/content/calendar-pointer.d.ts

@@ -0,0 +1,22 @@
+export declare const CALENDAR_SNAP_MINUTES = 15;
+export declare const snapCalendarMinutes: (minutes: number, step?: number) => number;
+export declare const calendarDayIndexAtPoint: (clientX: number, startX: number, width: number, days: number) => number | null;
+export declare const calendarMinuteAtPoint: (clientY: number, top: number, height: number, startHour: number, endHour: number) => number;
+export declare const calendarAutoScrollSpeed: (clientY: number, top: number, bottom: number, edge?: number, maximum?: number) => number;
+type CalendarPointerSessionOptions<T> = {
+    event: PointerEvent;
+    resolve: (clientX: number, clientY: number) => T | null;
+    onActivate?: () => void;
+    onPreview: (value: T) => void;
+    onCommit: (value: T) => void;
+    onCancel?: () => void;
+    scrollContainer?: HTMLElement;
+    threshold?: number;
+};
+/**
+ * Owns one pointer gesture from threshold crossing through commit or cancel.
+ * Views provide geometry through `resolve`; this helper owns global cleanup,
+ * pointer cancellation, Escape handling, and edge auto-scroll.
+ */
+export declare const startCalendarPointerSession: <T>(options: CalendarPointerSessionOptions<T>) => (() => void);
+export {};

package/dist/types/content/chart-map-viewport.d.ts

@@ -0,0 +1,5 @@
+import type { MapViewport } from "@k2b/stdlib";
+export declare const DEFAULT_MAP_VIEWPORT: MapViewport;
+export declare const normalizeMapViewport: (viewport: MapViewport | undefined) => MapViewport;
+export declare const zoomMapViewport: (viewport: MapViewport, delta: number) => MapViewport;
+export declare const panMapViewport: (viewport: MapViewport, deltaX: number, deltaY: number, width: number, height: number) => MapViewport;

package/dist/types/content/chart-state-timeline.d.ts

@@ -0,0 +1,42 @@
+export type StateTimelineDomain = readonly [number, number];
+export type StateTimelineInterval = {
+    from: number;
+    to: number;
+    state: string;
+    label?: string;
+    href?: string;
+    tooltip?: string;
+};
+export type StateTimelineRow = {
+    label: string;
+    href?: string;
+    tooltip?: string;
+    intervals: StateTimelineInterval[];
+};
+export type StateTimelineState = {
+    state: string;
+    label?: string;
+    color?: string;
+};
+export type StateTimelineChartOptions = {
+    rows: StateTimelineRow[];
+    states?: StateTimelineState[];
+    domain?: StateTimelineDomain;
+    xAxis?: {
+        format?: (value: number) => string;
+        label?: string;
+    };
+    legend?: boolean;
+    interactive?: boolean;
+};
+export declare const stateTimelineDomain: (rows: readonly StateTimelineRow[], domain?: StateTimelineDomain) => StateTimelineDomain;
+export declare const normalizeStateTimelineViewport: (viewport: StateTimelineDomain | undefined, fullDomain: StateTimelineDomain) => StateTimelineDomain;
+export declare const zoomStateTimelineViewport: (viewport: StateTimelineDomain, fullDomain: StateTimelineDomain, delta: number, anchor?: number) => StateTimelineDomain;
+export declare const panStateTimelineViewport: (viewport: StateTimelineDomain, fullDomain: StateTimelineDomain, pixelDelta: number, plotWidth: number) => StateTimelineDomain;
+export declare const stateTimelineHeight: (rows: number, legend?: boolean) => number;
+export declare const renderStateTimelineSvg: (opts: StateTimelineChartOptions & {
+    width: number;
+    height: number;
+    viewport?: StateTimelineDomain;
+    className?: string;
+}) => string;

package/dist/types/content/code-highlight.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Small safe highlighters for CodeDisplay.
+ *
+ * These are display-only highlighters: no AST, no runtime parser, no
+ * dependency. Every input character is HTML-escaped before being wrapped
+ * in token spans, so the returned strings are safe to inject with
+ * `innerHTML`.
+ */
+export type CodeDisplayLanguage = "ts" | "tsx" | "js" | "jsx" | "script" | "markdown" | "md" | "text";
+export declare const escapeCodeHtml: (s: string) => string;
+export declare const highlightCode: (code: string) => string;
+export declare const highlightMarkdownDisplay: (code: string) => string;
+export declare const highlightCodeDisplayLines: (code: string, language?: CodeDisplayLanguage) => string[];
+export declare const highlightCodeDisplay: (code: string, language?: CodeDisplayLanguage) => string;

package/dist/types/content/file-tree.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Tree shaping for FileTree — flat paths in, sorted nodes out.
+ *
+ * Kept beside the component rather than inside it because it is pure: no JSX,
+ * no reactivity, nothing that needs a DOM. That is also what makes it testable
+ * — a test importing the .tsx pulls the whole component through Bun's JSX
+ * transform, which resolves against the root tsconfig and lands on the React
+ * runtime. Same reason `file-view-preview.ts` sits next to FileView.
+ */
+export type FileTreeEntry = {
+    /** Canonical identity, e.g. "/input/report.csv". */
+    path: string;
+    /** Folders are usually implicit from paths — explicit entries model empty dirs. */
+    kind?: "file" | "folder";
+    size?: number;
+    mediaType?: string;
+    updatedAt?: string;
+    /** Icon override (tabler class without "ti " prefix); default derives from the name. */
+    icon?: string;
+    /** Small trailing badge, e.g. "ro" on read-only mounts. */
+    badge?: string;
+};
+export type TreeNode = {
+    entry: FileTreeEntry;
+    name: string;
+    depth: number;
+    isFolder: boolean;
+    children: TreeNode[];
+};
+/** Containing directory of a path; "/" for top-level entries. */
+export declare const parentOf: (path: string) => string;
+/**
+ * Flat paths → sorted tree (folders first, then files, both alphabetical).
+ *
+ * Passing the previous tree preserves object identity by path while updating
+ * the cached node in place. Solid's keyed `<For>` can then keep rows, rename
+ * inputs, and focus alive even when a refetch changes metadata.
+ */
+export declare const buildTree: (entries: FileTreeEntry[], previous?: TreeNode[]) => TreeNode[];
+export declare const flattenVisible: (nodes: TreeNode[], expanded: Set<string>) => TreeNode[];
+export declare const allFolderPaths: (nodes: TreeNode[]) => string[];

package/dist/types/content/file-view-preview.d.ts

@@ -0,0 +1,22 @@
+export type FileViewFile = {
+    path: string;
+    mediaType?: string;
+    size?: number;
+};
+export type FileViewPreviewKind = "markdown" | "image" | "pdf" | "json" | "delimited-text" | "audio" | "video" | "text";
+export declare const fileViewExtension: (path: string) => string;
+/**
+ * Returns the built-in preview kind when FileView can render the file within
+ * its bounded client-side limits. Custom renderers remain registry-driven.
+ */
+export declare const getFileViewPreviewKind: (file: FileViewFile) => FileViewPreviewKind | null;
+/** Use this to expose preview actions only for files FileView can render. */
+export declare const canPreviewFile: (file: FileViewFile) => boolean;
+export type DelimitedTextPreview = {
+    rows: string[][];
+    truncated: boolean;
+};
+export declare const parseDelimitedText: (input: string, delimiter: "," | "\t", limits?: {
+    rows?: number;
+    columns?: number;
+}) => DelimitedTextPreview;

package/dist/types/content/index.d.ts

@@ -0,0 +1,26 @@
+export type { CalendarAttendee, CalendarDayBadge, CalendarEvent, CalendarEventColor, CalendarEventRenderContext, CalendarEventTimeChange, CalendarLabels, CalendarProps, CalendarRecurrence, CalendarResource, CalendarView, } from "./Calendar";
+export { default as Calendar } from "./Calendar";
+export type { ChartKind, ChartLabels, ChartProps } from "./Chart";
+export { default as Chart } from "./Chart";
+export type { CodeDisplayLanguage, CodeDisplayProps } from "./CodeDisplay";
+export { default as CodeDisplay } from "./CodeDisplay";
+export type { StateTimelineChartOptions, StateTimelineDomain, StateTimelineInterval, StateTimelineRow, StateTimelineState, } from "./chart-state-timeline";
+export type { DataTableColumn, DataTableControlsProps, DataTableFooter, DataTableHeaderProps, DataTablePanelFooterProps, DataTablePanelProps, DataTableProps, DataTableRenderCell, DataTableRenderHeader, DataTableSort, } from "./DataTable";
+export { default as DataTable } from "./DataTable";
+export type { DocCodeHighlighter, DocCodeProps, DocConcept, DocNoteVariant, DocRow } from "./Docs";
+export { DocCode, DocConceptGrid, DocInlineCode, DocLead, DocNote, DocPage, DocRows, DocSection } from "./Docs";
+export { FileBrowserPanel, type FileBrowserPanelProps, type FileSource, openFileBrowser } from "./FileBrowser";
+export { default as FileTree, type FileTreeActions, type FileTreeEntry, type FileTreeProps } from "./FileTree";
+export { canPreviewFile, default as FileView, type FileViewContent, type FileViewFile, type FileViewPreviewKind, type FileViewProps, type FileViewRenderer, type FileViewRendererProps, formatFileViewSize, getFileViewPreviewKind, } from "./FileView";
+export type { LightboxImage } from "./Lightbox";
+export { default as Lightbox } from "./Lightbox";
+export type { LogTableEntry } from "./LogEntriesTable";
+export { default as LogEntriesTable } from "./LogEntriesTable";
+export { default as MarkdownView, renderSafeMarkdown, type MarkdownRenderOptions, type MarkdownViewProps } from "./MarkdownView";
+export { Pagination, type PaginationProps } from "./Pagination";
+export type { PdfPreviewProps, PdfPreviewRequest } from "./PdfPreview";
+export { default as PdfPreview } from "./PdfPreview";
+export type { RangeOption, RangePickerProps } from "./RangePicker";
+export { default as RangePicker } from "./RangePicker";
+export type { StructuredDataPreviewMode, StructuredDataPreviewProps, StructuredDataValue } from "./StructuredDataPreview";
+export { default as StructuredDataPreview, isStructuredDataValue } from "./StructuredDataPreview";

package/dist/types/feedback/InlineGuidance.d.ts

@@ -0,0 +1,10 @@
+import { type JSX } from "solid-js";
+import type { IntentTone } from "../semantics";
+export type InlineGuidanceProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "children" | "class"> & {
+    children: JSX.Element;
+    tone?: IntentTone;
+    icon?: string | false;
+    class?: string;
+};
+export declare function InlineGuidance(props: InlineGuidanceProps): JSX.Element;
+export default InlineGuidance;