@k2b/ui 0.17.0 → 0.19.0

package/dist/types/actions/Dropdown.d.ts

@@ -18,7 +18,8 @@ export type DropdownAction = (DropdownActionBase & {
 }) | (DropdownActionBase & {
     href: string;
     external?: boolean;
-    action?: never;
+    /** Runs on a plain click instead of following the link; modified clicks, middle-click, and the link's menu keep it. */
+    action?: () => void;
 }) | (DropdownActionBase & {
     disabled: true;
     action?: never;
@@ -35,6 +36,11 @@ export type DropdownChoice = DropdownActionBase & {
 };
 export type DropdownSection = {
     sectionLabel?: string;
+    /**
+     * `row` sets a few short radio choices, such as a sort direction, side by side as one segmented row. Give it a
+     * `sectionLabel`: the label names the choice above the row and for screen readers.
+     */
+    layout?: "row";
     items: readonly (DropdownAction | DropdownChoice)[];
 };
 export type DropdownItem = DropdownAction | DropdownChoice | DropdownSection;
@@ -82,9 +88,15 @@ export type DropdownItemProps = {
     variant?: "danger";
     href?: string;
     external?: boolean;
+    /** Runs when the item is chosen. With `href`, a plain click runs it instead of following the link. */
     onSelect?: () => void;
     class?: string;
 };
+/**
+ * Left and Right cycle through the segments of a row section; Up and Down leave it like any item. Returns whether
+ * the key moved focus.
+ */
+export declare const focusRowSegment: (items: HTMLElement[], key: string) => boolean;
 export declare const dropdownPosition: (trigger: DOMRect, menu: Pick<DOMRect, "width" | "height">, position: DropdownPosition, viewport: {
     width: number;
     height: number;

package/dist/types/actions/FilterChip.d.ts

@@ -10,6 +10,11 @@ export type FilterChipSection = {
     label?: string;
     options: readonly FilterChipOption[];
     multiple?: boolean;
+    /**
+     * `row` sets a few short single-select options side by side as one segmented row under its `label`. Selecting the
+     * chosen option again keeps it; give the row a value in `defaultValue` so Reset keeps a choice too.
+     */
+    layout?: "row";
 };
 export type FilterChipProps = {
     label: string;

package/dist/types/chat/ChatComposer.d.ts

@@ -1,5 +1,5 @@
 import { type JSX } from "solid-js";
-import type { ChatAction, ChatAttachment, ChatComposerState, ChatContextUsageData, ChatMention, ChatModelOption, ChatSubmitInput } from "./types";
+import type { ChatAction, ChatAttachment, ChatComposerEmoji, ChatComposerMicrophone, ChatComposerState, ChatContextUsageData, ChatMention, ChatModelOption, ChatSubmitInput } from "./types";
 export type ChatCommandContext = {
     setValue: (value: string) => void;
     submit: () => void;
@@ -17,6 +17,12 @@ export type ChatCommand = {
 };
 export type ChatFileSelection = {
     onSelect: (files: readonly File[]) => void | Promise<void>;
+    /**
+     * Chooses files for "Attach files" instead of the device's file dialog, for example to offer other sources as well.
+     * Called within the menu activation, so it may still open the device's dialog; resolve `[]` when the user cancels.
+     * `multiple: false` keeps the first chosen file, and a rejection reaches `onError`.
+     */
+    choose?: () => Promise<readonly File[]>;
     onError?: (error: unknown) => void;
     accept?: string;
     multiple?: boolean;
@@ -71,5 +77,22 @@ export type ChatComposerProps = {
     focusToken?: unknown;
     draftKey?: unknown;
     class?: string;
+    /**
+     * `"conversation"` is the composer for messages between people: one row with attach, a pill-shaped field and Send,
+     * without the assistant prompt's footer. The field starts with one line and grows to a third of its nearest size
+     * container, a hint line of fixed height sits above it, its buttons keep it focused, and Enter breaks the line
+     * inside an open code block and on touch-only devices. The default is the assistant prompt.
+     */
+    variant?: "default" | "conversation";
+    /** `"enter"` (default): Enter sends and Shift+Enter breaks the line. `"mod-enter"`: Enter breaks the line. Ctrl/⌘+Enter always sends. */
+    sendKey?: "enter" | "mod-enter";
+    /** Adds "Aa", which opens one row of Markdown formatting buttons above the field; the field and its controls stay put. */
+    formatting?: boolean;
+    /** An emoji button at a fixed place. Touch-only devices hide it; their keyboard has emoji. */
+    emoji?: ChatComposerEmoji;
+    /** A microphone at a fixed place: a tap dictates, holding it or its menu asks for a voice message. */
+    microphone?: ChatComposerMicrophone;
+    /** One line above the field. The conversation variant always keeps its height; the default shows it only with content. */
+    hint?: JSX.Element;
 };
 export declare function ChatComposer(props: ChatComposerProps): JSX.Element;

package/dist/types/chat/ChatPrimitives.d.ts

@@ -44,7 +44,7 @@ export type ChatActivityProps = {
 export type ChatContextUsageProps = ChatContextUsageData & {
     action?: ChatAction;
     onActionError?: (error: unknown) => void;
-    /** Host-owned number formatting. The default is locale-independent and SSR-stable. */
+    /** Host-owned number formatting. The default groups whole numbers in the inherited render locale. */
     formatNumber?: (value: number) => string;
     class?: string;
 };

package/dist/types/chat/chat-behavior.d.ts

@@ -24,3 +24,18 @@ export declare const runChatSubmission: (run: ChatSubmissionRun) => Promise<bool
 export declare const reportChatFailure: (perform: () => unknown, onError?: (error: unknown) => void) => void;
 /** Executes the one behavior guaranteed by the ChatAction contract. */
 export declare const executeChatAction: (action: ChatAction) => Promise<void>;
+export type ChatEnterKey = {
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+};
+/**
+ * What Enter does in a conversation composer: Ctrl/⌘+Enter always sends; Shift+Enter, Enter inside an open code
+ * block, and Enter on a touch-only device break the line; otherwise `sendKey` decides. IME input is the caller's check.
+ */
+export declare const conversationEnterAction: (key: ChatEnterKey, context: {
+    sendKey: "enter" | "mod-enter";
+    touchOnly: boolean;
+    inCodeBlock: boolean;
+}) => "send" | "newline";

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

@@ -11,7 +11,7 @@ export type { ChatActivityProps, ChatContextUsageProps, ChatMessageProps } from
 export { formatChatTokens } from "./ChatPrimitives";
 export type { ChatRootProps } from "./ChatRoot";
 export type { ChatActivityItem, ChatMessageItem, ChatTimelineItem, ChatTimelineProps } from "./ChatTimeline";
-export type { ChatAction, ChatActivityTone, ChatAttachment, ChatComposerState, ChatContextUsageData, ChatMention, ChatMessageStatus, ChatModelOption, ChatRole, ChatSubmitInput, ChatSubmitIntent, ChatUsage, } from "./types";
+export type { ChatAction, ChatActivityTone, ChatAttachment, ChatComposerEmoji, ChatComposerMicrophone, ChatComposerState, ChatContextUsageData, ChatDictationState, ChatMention, ChatMessageStatus, ChatModelOption, ChatRole, ChatSubmitInput, ChatSubmitIntent, ChatUsage, } from "./types";
 /**
  * Portable, controlled chat surface. Applications own storage, streaming,
  * authorization, rich message rendering, and domain actions.

package/dist/types/chat/types.d.ts

@@ -1,3 +1,4 @@
+import type { EmojiSkinTone } from "../inputs/emoji/emoji-index";
 export type ChatRole = "user" | "assistant" | "system" | "tool";
 export type ChatMessageStatus = "pending" | "streaming" | "complete" | "error";
 export type ChatActivityTone = "neutral" | "ai" | "success" | "danger";
@@ -68,4 +69,37 @@ export type ChatMention = {
     end: number;
     attachment: ChatAttachment;
 };
+/**
+ * Live dictation as the caller runs it: `listening` while speech arrives, `refining` after the stop until the refined
+ * text replaced it, `refined` afterwards, `unrefined` when the raw text stays, and `interrupted` when the connection
+ * ended early and the text so far stays.
+ */
+export type ChatDictationState = "listening" | "refining" | "refined" | "unrefined" | "interrupted";
+/** The composer's microphone. Dictation comes first; a voice message is the deliberate second action. */
+export type ChatComposerMicrophone = {
+    /** A tap starts or stops live dictation. Without it, a tap opens the microphone menu. */
+    onDictate?: () => void;
+    /** Holding the microphone, or "Record voice message" in its menu. Omit it where recording is not available. */
+    onVoiceMessage?: () => void;
+    /** The dictation state, shown on the microphone and in the hint line. */
+    dictation?: ChatDictationState | null;
+    /** Offered as "Restore original" while `dictation` is `refined`. */
+    onRestoreOriginal?: () => void;
+    disabled?: boolean;
+};
+/**
+ * The composer's emoji button and `:shortcode` completion. Typing a colon and two letters suggests emoji by their
+ * English or German name or GitHub shortcode; a complete `:thumbsup:` becomes 👍 when its closing colon is typed.
+ */
+export type ChatComposerEmoji = {
+    /** Opens the emoji choice next to `anchor`, usually `EmojiPicker.Popover`; `insert` puts the chosen text at the caret. */
+    onOpen: (context: {
+        anchor: HTMLElement;
+        insert: (text: string) => void;
+    }) => void;
+    /** The skin tone of completed emoji that have one, as in the picker. */
+    skinTone?: EmojiSkinTone;
+    /** Called with each emoji the completion inserted, for example to remember it with `rememberEmoji`. */
+    onPick?: (emoji: string) => void;
+};
 export {};

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

@@ -15,7 +15,16 @@ export type CalendarEvent = {
     dataSpaceItemId?: string;
     meta?: string;
     description?: string;
-    display?: "event" | "background";
+    /**
+     * `marker` draws a point in time, such as a deadline, as a colored marker
+     * beside its title instead of a filled band.
+     */
+    display?: "event" | "background" | "marker";
+    /**
+     * Short text the accessible name adds after the title and time, for state the event shows only visually, such as
+     * a priority flag in custom `renderEvent` content.
+     */
+    accessibleDetail?: string;
     location?: string;
     calendarName?: string;
     attendees?: CalendarAttendee[];
@@ -55,11 +64,20 @@ export type CalendarEventRenderContext = {
     durationHours: number;
     timeLabel: string;
 };
-export type CalendarProps = {
+/** A view the application adds to the switcher; the calendar shows its header and toolbar, the application the body. */
+export type CalendarCustomView<V extends string = string> = {
+    value: V;
+    label: string;
+};
+export type CalendarProps<V extends string = never> = {
     date: Date | string;
     events: CalendarEvent[];
-    view?: CalendarView;
+    view?: CalendarView | V;
     views?: CalendarView[];
+    /** Views after the built-in ones. While one is active, `children` is the body and the header pages by day. */
+    customViews?: CalendarCustomView<V>[];
+    /** The body of the active custom view. */
+    children?: JSX.Element;
     labels?: CalendarLabels;
     /** stdlib date context used for timezone-aware rendering and calendar math. */
     dateConfig?: DateContext;
@@ -76,8 +94,8 @@ export type CalendarProps = {
     selectedDate?: Date | string;
     selectedEventId?: string;
     dayBadges?: Record<string, CalendarDayBadge>;
-    getViewHref?: (view: CalendarView) => string;
-    getDateHref?: (date: Date, view: CalendarView) => string;
+    getViewHref?(view: CalendarView | V): string;
+    getDateHref?(date: Date, view: CalendarView | V): string;
     getEventHref?: (event: CalendarEvent) => string | undefined;
     renderEvent?: (event: CalendarEvent, context: CalendarEventRenderContext) => JSX.Element;
     /** Progressively enhance canonical calendar links after the app has loaded their target state. */
@@ -87,8 +105,8 @@ export type CalendarProps = {
     /** Optionally preload the target behind a canonical calendar link. */
     onPrefetch?: (href: string) => void;
     navigationPending?: boolean;
-    onViewChange?: (view: CalendarView) => void;
-    onDateChange?: (date: Date, view: CalendarView) => void;
+    onViewChange?(view: CalendarView | V): void;
+    onDateChange?(date: Date, view: CalendarView | V): void;
     /** One activation contract for pointer and keyboard input. */
     onEventActivate?: (event: CalendarEvent) => void;
     /** Pointer gesture used for activation. Keyboard activation is always immediate. */
@@ -111,5 +129,7 @@ export type CalendarDayBadge = {
     icon?: string;
     label: string;
 };
-declare const Calendar: (props: CalendarProps) => JSX.Element;
+/** JSX infers the values of `customViews`; inference from the last signature, as in `createComponent`, sees plain props. */
+declare function Calendar<V extends string = never>(props: CalendarProps<V>): JSX.Element;
+declare function Calendar(props: CalendarProps): JSX.Element;
 export default Calendar;

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

@@ -1,7 +1,15 @@
+/** One more thing to do with the shown image, beside Download: a short label, its icon class, and what it does. */
+export type LightboxAction = {
+    label: string;
+    icon: string;
+    onClick: () => void;
+};
 export type LightboxImage = {
     src: string;
     alt?: string;
     downloadUrl?: string;
+    /** Actions for this image, shown before Download in the same style. */
+    actions?: readonly LightboxAction[];
 };
 type LightboxProps = {
     images: LightboxImage[];

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

@@ -0,0 +1,49 @@
+import type { DateContext } from "@k2b/stdlib";
+import { type JSX } from "solid-js";
+import { type TimelineItem } from "./timeline-model";
+export type { TimelineColor, TimelineItem } from "./timeline-model";
+export type TimelineController = {
+    /** Scrolls a time into view; `start` (default) puts it near the start edge, `center` in the middle. */
+    scrollToTime: (time: Date | string, options?: {
+        align?: "start" | "center";
+    }) => void;
+    /** Scrolls the current time to the middle of the view. */
+    scrollToNow: () => void;
+};
+export type TimelineProps = {
+    items: readonly TimelineItem[];
+    /** Start of the loaded range. The view starts here, so pass the first time the reader should see. */
+    from: Date | string;
+    /** End of the loaded range (exclusive). */
+    to: Date | string;
+    /** The current time. Without it the timeline uses the clock and moves the now line every 30 seconds. */
+    now?: Date | string;
+    /** Accessible name of the region. Defaults to "Timeline". */
+    label?: string;
+    /** stdlib date context: time zone and locale of days, hours, and folds. */
+    dateConfig?: DateContext;
+    /** Convenience override for `dateConfig.timeZone`. */
+    timeZone?: string;
+    /** Level of the per-day headings. Defaults to 3. */
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
+    /** Opens an item, on click, Enter, or Space. */
+    onActivate?: (item: TimelineItem) => void;
+    /** Changes the checkbox of an item, on a click on the box or Space. Leave it out when the reader may not change it. */
+    onToggle?: (item: TimelineItem, checked: boolean) => void;
+    /**
+     * Called once when the reader nears the start, again once `from` moved and changed the strip's length. Extend `from`
+     * to load earlier days.
+     */
+    onLoadEarlier?: () => unknown;
+    /** Called once when the reader nears the end, again once `to` moved and changed the strip's length. Extend `to` to load later days. */
+    onLoadLater?: () => unknown;
+    /** Marks the region busy, for example while a range loads. */
+    busy?: boolean;
+    controller?: (controller: TimelineController) => void;
+    class?: string;
+};
+/**
+ * A continuous filmstrip of time: waking hours are proportional, nights and empty days fold, overlapping bands share
+ * lanes. Wide containers show it horizontally, narrow ones vertically; both use the same model.
+ */
+export default function Timeline(props: TimelineProps): JSX.Element;

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

@@ -0,0 +1,41 @@
+/**
+ * VideoPlayer — one video with the browser's own controls inside a frame whose
+ * size never depends on the video. The frame fills the height its host gives
+ * it, or keeps a ratio where the host leaves the height open. The picture fits
+ * inside uncropped, so a portrait reel and a wide recording both show whole and
+ * nothing moves while the video loads.
+ */
+import { type JSX } from "solid-js";
+export type VideoPlayerProps = {
+    /**
+     * Inline address of the video. Seeking needs a server that answers `Range` requests; Safari plays nothing without.
+     * Null while the host still fetches it, for example a signed URL: the frame already shows at its final size.
+     */
+    src: string | null;
+    /** Names the video for assistive technology, for example its file name. */
+    label: string;
+    /** Picture shown before playback starts. Without one, the player shows the first frame. */
+    poster?: string;
+    /** Width divided by height of the frame where the host leaves its height open. Defaults to 16 / 9. */
+    ratio?: number;
+    /** CORS mode for a video on another origin. Omit to keep the browser default. */
+    crossOrigin?: "anonymous" | "use-credentials";
+    /**
+     * Resolves a fresh address of the same video, for example a renewed signed URL. When playback fails, the player asks
+     * for one and continues at the same time, playing if it was. A renewed address that fails before it shows that point,
+     * or within ten seconds after, shows the fallback, so a renewed address must stay valid for longer.
+     */
+    renew?: () => Promise<string>;
+    /** Offered with the fallback when the browser cannot play the video, typically a download. */
+    fallbackAction?: JSX.Element;
+    /**
+     * Shown in the frame instead of the video while set, for example the host's own error with a retry when it could not
+     * fetch the address. The frame keeps its size.
+     */
+    error?: JSX.Element;
+    /** Called when the player gives up on the video and shows its fallback. */
+    onFallback?: () => void;
+    class?: string;
+};
+export declare function VideoPlayer(props: VideoPlayerProps): JSX.Element;
+export default VideoPlayer;

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

@@ -1,4 +1,4 @@
-export type { CalendarAttendee, CalendarDayBadge, CalendarEvent, CalendarEventColor, CalendarEventRenderContext, CalendarEventTimeChange, CalendarLabels, CalendarProps, CalendarRecurrence, CalendarResource, CalendarView, } from "./Calendar";
+export type { CalendarAttendee, CalendarCustomView, CalendarDayBadge, CalendarEvent, CalendarEventColor, CalendarEventRenderContext, CalendarEventTimeChange, CalendarLabels, CalendarProps, CalendarRecurrence, CalendarResource, CalendarView, } from "./Calendar";
 export { default as Calendar } from "./Calendar";
 export type { ChartKind, ChartLabels, ChartProps, ChartRenderOptions } from "./Chart";
 export { default as Chart } from "./Chart";
@@ -26,7 +26,7 @@ export { FileBrowserPanel, type FileBrowserPanelProps, type FileSource, openFile
 export { FileGrid, type FileGridProps } from "./FileGrid";
 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 type { LightboxAction, LightboxImage } from "./Lightbox";
 export { default as Lightbox } from "./Lightbox";
 export type { LogTableEntry } from "./LogEntriesTable";
 export { default as LogEntriesTable } from "./LogEntriesTable";
@@ -34,6 +34,7 @@ export { default as MarkdownView, type MarkdownRenderOptions, type MarkdownViewP
 export type { MessageGroupEntry, MessageRowAction, MessageRowAttachment, MessageRowAuthor, MessageRowFile, MessageRowMedia, MessageRowProgress, MessageRowProps, MessageRowQuote, MessageRowReaction, MessageRowStatus, MessageRowThread, MessageSystemRowProps, } from "./MessageRow";
 export { MessageRow, MessageSystemRow, startsMessageGroup } from "./MessageRow";
 export { type MarkdownInfoBlock, type MarkdownInfoBlockRenderInput, type MarkdownInfoBlockType, markdownInfoBlocks, renderMarkdownInfoBlock, scanMarkdownInfoBlock, } from "./markdown-info-blocks";
+export { type MarkdownLinkInput, type MarkdownReference, type MarkdownReferenceKind, type MarkdownReferenceType, markdownLinkReference, markdownReferenceIcon, markdownReferenceType, markdownReferenceTypeLabel, markStandaloneLinks, renderMarkdownLink, } from "./markdown-links";
 export { Pagination, type PaginationProps } from "./Pagination";
 export type { PdfPreviewProps, PdfPreviewRequest } from "./PdfPreview";
 export { default as PdfPreview } from "./PdfPreview";
@@ -41,6 +42,9 @@ 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";
+export type { TimelineColor, TimelineController, TimelineItem, TimelineProps } from "./Timeline";
+export { default as Timeline } from "./Timeline";
+export { VideoPlayer, type VideoPlayerProps } from "./VideoPlayer";
 export type { VirtualFeedController, VirtualFeedProps, VirtualFeedScrollOptions } from "./VirtualFeed";
 export { VirtualFeed } from "./VirtualFeed";
 export type { ZoomPanAction, ZoomPanFullscreen, ZoomPanViewportProps } from "./ZoomPanViewport";

package/dist/types/content/markdown-links.d.ts

@@ -0,0 +1,66 @@
+import type { Token, Tokens } from "marked";
+/** What a reference points to inside the host application. */
+export type MarkdownReferenceKind = "file" | "note" | "heading" | "task" | "page";
+/** The type a reference shows: a file's type from its extension, or the kind of the referenced content. */
+export type MarkdownReferenceType = "pdf" | "image" | "design" | "file" | "note" | "heading" | "task" | "page";
+/**
+ * A link to content inside the host application, as opposed to a web or mail link.
+ * References render as a calm pill whose icon names the type.
+ */
+export type MarkdownReference = {
+    kind: MarkdownReferenceKind;
+    /** The file's name, which decides its type and icon. Defaults to the link text. */
+    fileName?: string;
+    /** The file's formatted size. It shows only when the link stands alone on its line. */
+    size?: string;
+    /** Plain-text title of the document that holds a heading, for a heading in another document. */
+    document?: string;
+};
+export type MarkdownLinkInput = {
+    /** The final, already validated link destination. */
+    href: string;
+    /** The rendered link text. It crosses a trust boundary: the caller sanitizes it. */
+    html: string;
+    /** The link text as plain text, for the accessible name. Defaults to the text of `html`. */
+    text?: string;
+    title?: string;
+    target?: "_blank";
+    /** Link relations without a new tab, such as `noreferrer`. `target: "_blank"` always sets `noopener noreferrer`. */
+    rel?: string;
+    /** A reference inside the host. Without one, the link is a web link, or a mail link for `mailto:` and `tel:`. */
+    reference?: MarkdownReference | null;
+    /** The link is the only content of its line. Only then does a file show its size. */
+    standalone?: boolean;
+    /** Locale of the type name in the accessible name. Defaults to English on the server and the page language in the browser. */
+    locale?: string;
+};
+/** The type of a file reference, from the extension of its name. */
+export declare const markdownFileType: (fileName: string) => "pdf" | "image" | "design" | "file";
+/**
+ * The reference a link destination names on its own: `#anchor` is a heading in the same document, and any other
+ * relative URL is a page of the host, or a file when its last path segment has a file extension. Absolute URLs,
+ * every scheme, and relative URLs that a browser resolves to another host, such as `//host` or `/\host`, are web
+ * or mail links; the result is then `null`.
+ */
+export declare const markdownLinkReference: (href: string) => MarkdownReference | null;
+/** The type a reference shows. */
+export declare const markdownReferenceType: (reference: MarkdownReference, text: string) => MarkdownReferenceType;
+/** The Tabler glyph of a reference type; any other file keeps the glyph of its file family. */
+export declare const markdownReferenceIcon: (type: MarkdownReferenceType, fileName?: string) => string;
+/** The localized name of a reference type, such as "PDF" or "Überschrift". */
+export declare const markdownReferenceTypeLabel: (type: MarkdownReferenceType, locale?: string) => string;
+/**
+ * One link of rendered Markdown. A reference to content of the host renders as a calm pill: a neutral fill, the
+ * text in the prose colour, and an icon whose colour names the type. Its accessible name starts with the type, as
+ * in "PDF: Brand-2026.pdf". A heading in another document shows that document first ("Notes › Heading"). A web
+ * link stays prose text with a thin underline in the link accent and a small ↗; a mail link has no arrow. A link
+ * around an image is the image: a plain anchor that the image's own text names.
+ */
+export declare const renderMarkdownLink: (input: MarkdownLinkInput) => string;
+/**
+ * The links among `tokens` that stand alone on their line: the only content of a paragraph or list item line,
+ * between line breaks. Pass the result's check as `standalone` to `renderMarkdownLink`, so a file shows its size
+ * in a list of files but not inside a sentence. Call it from `walkTokens` of a renderer with GFM line breaks
+ * (`breaks: true`), where every source line is a visual line.
+ */
+export declare const markStandaloneLinks: (token: Token, standalone: WeakSet<Tokens.Link>) => void;

package/dist/types/content/timeline-model.d.ts

@@ -0,0 +1,148 @@
+import { type DateContext } from "@k2b/stdlib";
+/** A color token of the shared calendar palette, or a hex color such as a label color. */
+export type TimelineColor = "blue" | "emerald" | "amber" | "red" | "violet" | "cyan" | "zinc" | `#${string}`;
+export type TimelineItem = {
+    /** Unique among the items. */
+    id: string;
+    label: string;
+    /** A date-only string (`2026-10-08`) is a day in the time zone; anything else is an instant. */
+    start: Date | string;
+    /** End of a band. Without it, the item is a point in time. For all-day items, a midnight end is exclusive. */
+    end?: Date | string;
+    allDay?: boolean;
+    /** `band` (default) shows the duration; `marker` shows a point in time at `start`, such as a deadline. */
+    kind?: "band" | "marker";
+    color?: TimelineColor;
+    /** Extra text such as a place or a category: read with the item and shown where there is room. */
+    detail?: string;
+    /** Checkbox state. Leave it out for items without a checkbox. */
+    checked?: boolean;
+    /** Link target; without it the item is a button. */
+    href?: string;
+};
+/**
+ * A place on the main axis as the count of each unit before it: hours of waking time, nights, folds of empty days,
+ * day headings, and all-day rows. The axis gives every unit its size, so one model serves both axes.
+ */
+export type TimelineSpan = readonly [hours: number, nights: number, folds: number, heads: number, rows: number];
+export type TimelineUnits = TimelineSpan;
+export declare const TIMELINE_UNIT_NAMES: readonly ["hour", "night", "fold", "head", "row"];
+/** Waking hours; the night between them is folded. */
+export declare const TIMELINE_WAKE_HOURS: readonly [6, 22];
+/** Visible lanes of overlapping bands and of all-day items; more overlaps collapse into a "+n" entry in the last lane. */
+export declare const TIMELINE_BAND_LANES = 3;
+export declare const TIMELINE_ALL_DAY_LANES = 2;
+/** Visible items stacked in one night or fold; more collapse into a "+n" entry in the last place. */
+export declare const TIMELINE_FOLD_LANES = 3;
+export declare const addSpan: (a: TimelineSpan, b: TimelineSpan) => TimelineSpan;
+export declare const subtractSpan: (a: TimelineSpan, b: TimelineSpan) => TimelineSpan;
+export declare const spanPx: (span: TimelineSpan, units: TimelineUnits) => number;
+/** The span as a CSS length over the `--k2b-timeline-<unit>` sizes the axis sets. */
+export declare const spanCss: (span: TimelineSpan) => string;
+export type TimelineSegment = {
+    kind: "head" | "row" | "wake" | "night" | "fold";
+    t0: number;
+    t1: number;
+    at: TimelineSpan;
+    size: TimelineSpan;
+    group: number;
+};
+type EntryBase = {
+    /** Entry id: the item id, or for a "+n" entry `more:<first hidden id>`, made unique among the item ids. */
+    id: string;
+    group: number;
+    /** The item's own times, also beyond the loaded range; for all-day entries, group indexes. */
+    start: number;
+    end: number;
+    /** Main-axis place relative to the group, and length. */
+    at: TimelineSpan;
+    size: TimelineSpan;
+    lane: number;
+    lanes: number;
+};
+export type TimelineItemEntry = EntryBase & {
+    kind: "band" | "marker" | "folded" | "all-day";
+    item: TimelineItem;
+    /** For all-day items: the first and last day of the item inside the range. */
+    firstKey: string;
+    lastKey: string;
+};
+export type TimelineMoreEntry = EntryBase & {
+    kind: "more";
+    area: "band" | "fold" | "all-day";
+    hidden: TimelineItemEntry[];
+};
+export type TimelineEntry = TimelineItemEntry | TimelineMoreEntry;
+export type TimelineGroup = {
+    index: number;
+    /** `day:<date>` or `fold:<first>:<last>`; stable while the group keeps its days. */
+    key: string;
+    kind: "day" | "fold";
+    firstKey: string;
+    lastKey: string;
+    t0: number;
+    t1: number;
+    /** Times the group's entries reach, beyond its own span for items in a neighbouring fold or over several days. */
+    reach: [number, number];
+    at: TimelineSpan;
+    size: TimelineSpan;
+    /** The group reserves a row for all-day items (vertical axis only). */
+    row: boolean;
+    today: boolean;
+    past: boolean;
+    /** List order: all-day items, then timed entries by start. */
+    entries: TimelineEntry[];
+    /** All-day entries of earlier groups that cover this group too. */
+    echoes: TimelineEntry[];
+    hours: Array<{
+        time: number;
+        at: TimelineSpan;
+    }>;
+    folds: Array<{
+        kind: "night" | "fold";
+        at: TimelineSpan;
+        size: TimelineSpan;
+    }>;
+    gaps: Array<{
+        at: TimelineSpan;
+        end: number;
+        hours: number;
+        long: boolean;
+    }>;
+};
+export type TimelineModel = {
+    from: number;
+    to: number;
+    segments: TimelineSegment[];
+    groups: TimelineGroup[];
+    total: TimelineSpan;
+    entries: Map<string, TimelineEntry>;
+    /** Keyboard order of every entry id. */
+    order: string[];
+    posOf: (time: number) => TimelineSpan;
+    /** The time at a pixel offset along the main axis. */
+    timeAt: (px: number, units: TimelineUnits) => number;
+};
+export declare const parseTimelineTime: (value: Date | string | undefined, context?: DateContext) => number;
+/** The day (`YYYY-MM-DD`) of an instant in the context's time zone. */
+export declare const timelineDayKey: (time: number, context?: DateContext) => string;
+export declare const shiftDayKey: (key: string, days: number) => string;
+/**
+ * The instant of a whole hour (0–24) on a day in the context's time zone. As stdlib's `compatible` disambiguation, a
+ * repeated hour resolves to its first occurrence and a skipped one to the time after the gap.
+ */
+export declare const timelineHourOf: (key: string, hour: number, context?: DateContext) => number;
+export type TimelineModelInput = {
+    from: number;
+    to: number;
+    /** The current day (`YYYY-MM-DD`), which always stays open. */
+    today: string;
+    items: readonly TimelineItem[];
+    context?: DateContext;
+};
+/**
+ * Builds the filmstrip: waking hours (6–22) are proportional, every night is one fold, and a run of days without
+ * timed items is one fold. Positions depend only on the times and the items, never on measurement.
+ */
+export declare const buildTimelineModel: ({ from, to, today, items, context }: TimelineModelInput) => TimelineModel;
+export {};

package/dist/types/feedback/dialog-core.d.ts

@@ -1,4 +1,4 @@
-import type { JSX } from "solid-js";
+import { type JSX } from "solid-js";
 export type DialogClose<T> = (result?: T) => void;
 export type OpenDialogOptions = {
     /** Close only this dialog when its owning operation is cancelled. */

package/dist/types/inputs/ChoiceChips.d.ts

@@ -0,0 +1,20 @@
+import type { JSX } from "solid-js";
+import type { ValueFieldProps } from "./field-contract";
+export type ChoiceChipOption<T extends string = string> = {
+    value: T;
+    label: string;
+    icon?: string;
+};
+export type ChoiceChipsProps<T extends string = string> = Omit<ValueFieldProps<T | null>, "onValueChange" | "onValueCommit"> & {
+    options: readonly ChoiceChipOption<T>[];
+    /** Receives the chosen value; choosing never reports `null`. */
+    onValueChange?: (value: T) => void;
+    onValueCommit?: (value: T) => void;
+};
+/**
+ * A labeled single choice shown as one row of chips, for a handful of quick picks such as a preset or a proposed date.
+ * The row scrolls sideways instead of wrapping, so its height stays the same on every screen and for every selection.
+ * `null` selects no chip; the first chip then holds the tab stop. Use `Select` for long or searchable lists and
+ * `SegmentedControl` for switching between views or modes.
+ */
+export declare function ChoiceChips<T extends string = string>(props: ChoiceChipsProps<T>): JSX.Element;