@k2b/ui 0.26.0 → 0.28.0

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

@@ -14,4 +14,12 @@ export type ContextMenuProps = {
 };
 /** Right-click menu with keyboard invocation, one-open-at-a-time behavior, and viewport clamping. */
 export declare function ContextMenu(props: ContextMenuProps): JSX.Element;
+/**
+ * Package-internal, not exported from the package index: `openAt` lets GestureMenu open the menu at a held finger, and
+ * `title` names what was pressed above the entries, since the finger covers it.
+ */
+export declare function ContextMenuBase(props: ContextMenuProps & {
+    openAt?: (open: (x: number, y: number) => void) => void;
+    title?: string;
+}): JSX.Element;
 export default ContextMenu;

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

@@ -23,6 +23,12 @@ export type DropdownAction = (DropdownActionBase & {
      * the focus stays on the row. Defaults to `true`.
      */
     closeOnSelect?: boolean;
+    /**
+     * In a phone sheet, run while the tap still counts as the person's gesture, before the sheet closes, as browsers
+     * require for clipboard writes. Other actions run after the sheet has left the history. Such an action must
+     * not navigate or open a dialog.
+     */
+    immediate?: boolean;
     href?: never;
     external?: never;
 }) | (DropdownActionBase & {
@@ -41,6 +47,7 @@ export type DropdownChoice = DropdownActionBase & {
     action: () => void;
     checked: boolean | (() => boolean);
     choice: "checkbox" | "radio";
+    href?: string;
     closeOnSelect?: boolean;
     color?: string;
 };
@@ -74,6 +81,11 @@ export type DropdownProps = {
     disabled?: boolean;
     label?: string;
     align?: "start" | "end";
+    /**
+     * `sheet` opens the same items as a bottom sheet on phones (below 48rem) instead of a menu beside the trigger.
+     * Defaults to `menu`. A controlled menu (`open`) always stays a menu.
+     */
+    phone?: "menu" | "sheet";
 };
 export type DropdownTriggerProps = Omit<ButtonProps, "aria-controls" | "aria-expanded" | "aria-haspopup" | "children" | "disabled" | "onClick" | "onKeyDown"> & {
     children: JSX.Element;
@@ -104,11 +116,6 @@ export type DropdownItemProps = {
     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/GestureMenu.d.ts

@@ -13,14 +13,15 @@ export type GestureMenuSection = Omit<DropdownSection, "items"> & {
 export type GestureMenuItem = GestureMenuAction | DropdownAction | DropdownChoice | GestureMenuSection;
 export type GestureMenuProps = {
     /**
-     * The menu. A long press opens it as a bottom sheet, a right-click, the Context Menu key, or Shift+F10 as a menu.
+     * The menu. A long press opens a BottomSheet below 48rem and the same menu at the finger from 48rem.
+     * Right-click opens it at the pointer; the Context Menu key and Shift+F10 open it beside the focused element.
      * An item with `gesture` is also run by that gesture, so every gesture has its entry here.
      */
     items: readonly GestureMenuItem[];
     /** Names the element and its menu, for example "Message from Nora, 10:42". */
     label: string;
     children: JSX.Element;
-    /** Shown above the menu in the long-press sheet, for example a row of quick reactions. `close` closes the sheet. */
+    /** Shown only above the menu in the phone sheet, for example a row of quick reactions. `close` closes the sheet. */
     sheetTop?: (close: () => void) => JSX.Element;
     /** Tab order of the element. A list that moves focus between its rows itself passes -1. */
     tabIndex?: number;
@@ -30,8 +31,9 @@ export type GestureMenuProps = {
 };
 /**
  * Touch gestures for an element, each the shortcut of an entry in its menu: a horizontal swipe, a double tap, and a
- * long press that opens the whole menu as a `BottomSheet`. A mouse double-click runs the double-tap action; a
- * right-click and the keyboard open the menu beside the element. Vertical scrolling never turns into a swipe.
+ * long press that opens a `BottomSheet` below 48rem and the same menu at the finger from 48rem. A mouse double-click
+ * runs the double-tap action; right-click opens the menu at the pointer, the keyboard beside the focused element.
+ * Vertical scrolling never turns into a swipe.
  */
 export declare function GestureMenu(props: GestureMenuProps): JSX.Element;
 export default GestureMenu;

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

@@ -4,6 +4,24 @@ export type ToolbarProps = {
     label: string;
     orientation?: "horizontal" | "vertical";
     wrap?: boolean;
+    /** `floating` floats the toolbar at the bottom of its column. Defaults to `inline`. */
+    variant?: "inline" | "floating";
+    class?: string;
+};
+export type ToolbarActionProps = {
+    /** Accessible name, tooltip text, and the row label in the More menu. */
+    label: string;
+    /** Icon class, such as "ti ti-archive". */
+    icon: string;
+    /** Shortcut hint, tooltip suffix, and aria-keyshortcuts; does not register a shortcut handler. */
+    keys?: string;
+    /** 1 is most important. Larger numbers move first; ties move later DOM actions first. Omit to keep fixed. */
+    priority?: number;
+    disabled?: boolean;
+    onClick?: () => void;
+};
+export type ToolbarLabelProps = {
+    children: JSX.Element;
     class?: string;
 };
 export type ToolbarGroupProps = {
@@ -15,6 +33,8 @@ export type ToolbarSeparatorProps = {
     class?: string;
 };
 type ToolbarComponent = ((props: ToolbarProps) => JSX.Element) & {
+    Action: (props: ToolbarActionProps) => JSX.Element;
+    Label: (props: ToolbarLabelProps) => JSX.Element;
     Group: (props: ToolbarGroupProps) => JSX.Element;
     Separator: (props: ToolbarSeparatorProps) => JSX.Element;
     Spacer: () => JSX.Element;

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

@@ -22,5 +22,5 @@ export type { SpotlightButtonProps, SpotlightButtonVariant, SpotlightSearchOptio
 export { openSpotlightSearch, SpotlightButton, } from "./SpotlightSearch";
 export type { TabOption, TabsItemProps, TabsProps } from "./Tabs";
 export { Tabs } from "./Tabs";
-export type { ToolbarGroupProps, ToolbarProps, ToolbarSeparatorProps } from "./Toolbar";
+export type { ToolbarActionProps, ToolbarGroupProps, ToolbarLabelProps, ToolbarProps, ToolbarSeparatorProps } from "./Toolbar";
 export { Toolbar } from "./Toolbar";

package/dist/types/actions/menu-rows.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 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;

package/dist/types/actions/menu-sheet.d.ts

@@ -0,0 +1,22 @@
+import { type JSX } from "solid-js";
+import type { DropdownItem } from "./Dropdown";
+/** Phones, where a menu opens as a bottom sheet instead of beside its trigger. */
+export declare const PHONE_SHEET_QUERY = "(max-width: 47.999rem)";
+export declare const prefersMenuSheet: () => boolean;
+export type MenuSheetOptions = {
+    /** Renders the rows: the dropdown's own `DropdownItems`, passed in so this module does not import it back. */
+    Items: (props: {
+        items: readonly DropdownItem[];
+        close: (restoreFocus?: boolean) => void;
+    }) => JSX.Element;
+    items: readonly DropdownItem[];
+    /** Names the sheet and its menu. */
+    label: string;
+    /** The render locale of the opener; the sheet renders outside its tree. */
+    locale: string;
+    /** Shown above the menu, for example a row of quick reactions. `close` closes the sheet. */
+    top?: (close: () => void) => JSX.Element;
+    signal?: AbortSignal;
+};
+/** Opens menu items as a bottom sheet; resolves after the sheet closed and the chosen action ran. */
+export declare const openMenuSheet: (options: MenuSheetOptions) => Promise<void>;

package/dist/types/actions/toolbar-messages.d.ts

@@ -0,0 +1,8 @@
+declare const toolbarMessages: import("@k2b/stdlib").Catalog<{
+    moreActions: string;
+}>;
+export type ToolbarMessages = ReturnType<(typeof toolbarMessages)["resolve"]>["t"];
+/** Resolved from the inherited render locale. */
+export declare const useToolbarMessages: () => (() => ToolbarMessages);
+export declare const checkToolbarMessages: () => import("@k2b/stdlib").CatalogIssue[];
+export {};

package/dist/types/chart-inspection.d.ts

@@ -0,0 +1,2 @@
+export { type ChartCursor, createChartCursor } from "./content/chart-cursor";
+export { type ChartDatumRef, type ChartInspection, type ChartKind, type ChartSelection, type ChartTooltip, type ChartTooltipFormatter, type InspectChartOptions, inspectChart, isChartDatum, sameChartDatum, } from "./content/chart-inspection-core";

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

@@ -4,12 +4,59 @@ export type ChatCommandContext = {
     setValue: (value: string) => void;
     submit: () => void;
     focus: () => void;
+    openModelSelection: () => Promise<string | null>;
+};
+/** An action can cancel and restore its token, or report a short completion message. */
+export type ChatCommandResult = void | "cancelled" | {
+    done: string;
+};
+/** A fixed place in the slash list. Sections keep the given order, also while searching. */
+export type ChatCommandSection = {
+    id: string;
+    label: string;
+    /** Rows come from `searchCommands`: loading keeps a heading spinner; empty placeholders reserve the first search or retained rows. */
+    searched?: boolean;
+    /** Only while searching or narrowed: absent from the overview (empty query), including its loading placeholder. */
+    searchOnly?: boolean;
+};
+/** First-word narrowing; Tab writes `words[0]` followed by a space. */
+export type ChatCommandScope = {
+    id: string;
+    title: string;
+    words: readonly string[];
+};
+/** Passed as the third argument to `searchCommands`. */
+export type ChatCommandSearch = {
+    scope?: string;
+    /** One list opening, unchanged across queries and narrowing; retries start another opening. */
+    opening: number;
 };
 export type ChatCommand = {
+    /** Section id; unknown or missing ids render in a trailing part without a heading. */
+    section?: string;
+    /** Tab writes this scope's first word; a row without an action or mention also narrows on Enter. */
+    scope?: string;
+    /** Absent from the overview; appears when searched, including its unavailable reason. */
+    hiddenUntilSearch?: boolean;
+    /** A chosen value, independent of the row marked by keyboard navigation. */
+    selected?: boolean;
+    /** Retry discovery in a new opening, retaining the token and currently displayed rows. */
+    searchAgain?: boolean;
+    /** Application name, searchable but not displayed. */
+    app?: string;
+    /** Stable row key for option ids, marking and de-duplication. Defaults to `name`. */
+    id?: string;
     name: string;
     description: string;
     icon?: string;
-    action?: (context: ChatCommandContext) => void | Promise<void>;
+    /** Extra search words, for example in German and English. */
+    keywords?: readonly string[];
+    /** Unavailable now; this short reason replaces the description. */
+    reason?: string;
+    /** Shown in the status line while the action runs. */
+    busyLabel?: string;
+    /** Failures restore an unchanged draft and appear once in the status line, without calling `onError`. */
+    action?: (context: ChatCommandContext) => ChatCommandResult | Promise<ChatCommandResult>;
     /** Selecting a reference inserts its display name and retains its opaque payload. */
     mention?: ChatAttachment;
     label?: string;
@@ -54,7 +101,9 @@ export type ChatComposerProps = {
     /** Compact application-owned details immediately after the model selector. */
     modelDetails?: JSX.Element;
     commands?: readonly ChatCommand[];
-    searchCommands?: (query: string, signal: AbortSignal) => Promise<readonly ChatCommand[]>;
+    commandSections?: readonly ChatCommandSection[];
+    commandScopes?: readonly ChatCommandScope[];
+    searchCommands?: (query: string, signal: AbortSignal, search: ChatCommandSearch) => Promise<readonly ChatCommand[]>;
     mentions?: readonly ChatMention[];
     onMentionsChange?: (mentions: readonly ChatMention[]) => void;
     /** Shared surface above the editor; suggestions temporarily replace this content. */

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

@@ -1,3 +1,4 @@
+import type { ChatCommand } from "./ChatComposer";
 import type { ChatAction } from "./types";
 export declare const nextChatCommandIndex: (index: number, length: number, direction: 1 | -1) => number;
 export declare const isChatNearBottom: (scrollHeight: number, scrollTop: number, clientHeight: number, threshold?: number) => boolean;
@@ -39,3 +40,6 @@ export declare const conversationEnterAction: (key: ChatEnterKey, context: {
     touchOnly: boolean;
     inCodeBlock: boolean;
 }) => "send" | "newline";
+/** Case- and accent-insensitive text for command discovery. */
+export declare const foldChatSearchText: (text: string) => string;
+export declare const chatCommandKey: (command: ChatCommand) => string;

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

@@ -1,4 +1,6 @@
-declare const chatMessages: import("@k2b/stdlib").Catalog<{
+export declare const chatMessages: import("@k2b/stdlib").Catalog<{
+    commandFailed: string;
+    commandSelected: string;
     attachments: string;
     assistant: string;
     addToChat: string;
@@ -7,6 +9,12 @@ declare const chatMessages: import("@k2b/stdlib").Catalog<{
     chat: string;
     chooseModel: string;
     commands: string;
+    commandsNothingFound: ({ query }: {
+        query: string;
+    }) => string;
+    commandSuggestions: ({ count }: {
+        count: number;
+    }) => string;
     dropFilesToAttach: string;
     conversation: string;
     jumpToLatest: string;
@@ -31,6 +39,14 @@ declare const chatMessages: import("@k2b/stdlib").Catalog<{
         own?: boolean;
     }) => string;
     messageAddReaction: string;
+    moreReactions: ({ count }: {
+        count: number;
+    }) => string;
+    reactionYou: string;
+    reactionAnd: string;
+    reactionMorePeople: ({ count }: {
+        count: number;
+    }) => string;
     messageReplies: ({ count }: {
         count: number;
     }) => string;
@@ -113,4 +129,3 @@ export type ChatMessages = ReturnType<(typeof chatMessages)["resolve"]>["t"];
 /** Resolved from the inherited render locale. */
 export declare const useChatMessages: () => (() => ChatMessages);
 export declare const checkChatMessages: () => import("@k2b/stdlib").CatalogIssue[];
-export {};

package/dist/types/chat/command-search.d.ts

@@ -0,0 +1,41 @@
+import type { ChatCommand, ChatCommandScope, ChatCommandSection } from "./ChatComposer";
+type Rank = {
+    rank: number;
+    highlight?: readonly [number, number];
+};
+export declare const rankChatCommand: (command: ChatCommand, query: string) => Rank | null;
+export declare function resolveChatCommandScope(word: string, scopes: readonly ChatCommandScope[]): ChatCommandScope | undefined;
+export declare function parseChatCommandQuery(query: string, scopes: readonly ChatCommandScope[]): {
+    scope?: ChatCommandScope;
+    query: string;
+};
+export type ChatCommandRow = {
+    command: ChatCommand;
+    server: boolean;
+    highlight?: readonly [number, number];
+};
+type Group = {
+    section?: ChatCommandSection;
+    scopeTitle?: string;
+    rows: ChatCommandRow[];
+    loading: boolean;
+    placeholder: boolean;
+};
+export declare function chatCommandListModel(input: {
+    query: string;
+    scopes?: readonly ChatCommandScope[];
+    sections?: readonly ChatCommandSection[];
+    commands: readonly ChatCommand[];
+    searchResults: readonly ChatCommand[];
+    searchResultsFresh: boolean;
+    searchSettled: boolean;
+    searching: boolean;
+}): {
+    scope?: ChatCommandScope;
+    groups: Group[];
+    rows: ChatCommandRow[];
+    empty: boolean;
+};
+/** Use the composer ranking rules to filter consumer-owned server rows. */
+export declare const matchesChatCommand: (command: ChatCommand, query: string) => boolean;
+export {};

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

@@ -6,7 +6,7 @@ import { ChatComposer } from "./ChatComposer";
 import { ChatActivity, ChatContextUsage, ChatMessage } from "./ChatPrimitives";
 import { ChatRoot } from "./ChatRoot";
 import { ChatTimeline } from "./ChatTimeline";
-export type { ChatCommand, ChatCommandContext, ChatComposerProps, ChatFileSelection, ChatPasteHandler } from "./ChatComposer";
+export type { ChatCommand, ChatCommandContext, ChatCommandResult, ChatCommandScope, ChatCommandSearch, ChatCommandSection, ChatComposerProps, ChatFileSelection, ChatPasteHandler, } from "./ChatComposer";
 export type { ChatActivityProps, ChatContextUsageProps, ChatMessageProps } from "./ChatPrimitives";
 export { formatChatTokens } from "./ChatPrimitives";
 export type { ChatRootProps } from "./ChatRoot";
@@ -26,4 +26,6 @@ export declare const Chat: typeof ChatRoot & {
     ContextPopup: typeof ChatContextPopup;
     ContextPanel: typeof ChatContextPanel;
 };
+export { matchesChatCommand } from "./command-search";
 export { reconcileChatMentions } from "./composer-document";
+export { type ReactionPeopleInput, reactionPeople } from "./reaction-people";

package/dist/types/chat/reaction-people.d.ts

@@ -0,0 +1,9 @@
+export type ReactionPeopleInput = {
+    /** Display names of the others who reacted, in the order they reacted; without the reader. */
+    names: readonly string[];
+    /** The reader reacted too; they come first as "You". */
+    own?: boolean;
+    /** How many reacted in total, the reader included. May exceed the names given. */
+    count: number;
+};
+export declare const reactionPeople: (input: ReactionPeopleInput, locale?: string) => string;

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

@@ -2,7 +2,7 @@ import type { MapViewport } from "@k2b/stdlib";
 import { charts } from "@k2b/stdlib";
 import type { JSX } from "solid-js";
 import type { ChartCursor } from "./chart-cursor";
-import { type ChartDatumRef, type ChartSelection, type ChartTooltipFormatter } from "./chart-inspection";
+import { type ChartDatumRef, type ChartKind, type ChartSelection, type ChartTooltipFormatter } from "./chart-inspection-core";
 import { type StateTimelineChartOptions, type StateTimelineDomain } from "./chart-state-timeline";
 /**
  * Chart — minimal Solid wrapper around `stdlib.charts`.
@@ -49,7 +49,7 @@ import { type StateTimelineChartOptions, type StateTimelineDomain } from "./char
  * ```
  */
 /** All chart kinds shipped by `stdlib.charts`. */
-export type ChartKind = keyof typeof charts;
+export type { ChartKind } from "./chart-inspection-core";
 export type ChartLabels = Partial<{
     empty: string;
     series: string;

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

@@ -1,4 +1,5 @@
 import { type JSX } from "solid-js";
+import { type ReactionBarItem } from "./ReactionBar";
 export type MessageRowAuthor = {
     /** Display name, shown at the start of a group and read before every message. */
     name: string;
@@ -25,16 +26,8 @@ export type MessageRowQuote = {
     /** Opens the quoted message, for example by scrolling to it. Without it, the quote is not a control. */
     onSelect?: () => void;
 };
-export type MessageRowReaction = {
-    /** Stable identity of the reaction, passed to `onToggleReaction`. */
-    key: string;
-    emoji: string;
-    count: number;
-    /** The reader reacted this way; the chip shows pressed. */
-    own?: boolean;
-    /** Who reacted, for example "Nora, Tobias". Read by screen readers and shown as a tooltip. */
-    label?: string;
-};
+/** Reaction labels are read by screen readers and shown in the names hint. */
+export type MessageRowReaction = ReactionBarItem;
 export type MessageRowThread = {
     /** Number of replies. */
     count: number;

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

@@ -0,0 +1,32 @@
+import { type JSX } from "solid-js";
+export type ReactionBarItem = {
+    /** Stable identity of the reaction, passed to `onToggle`. */
+    key: string;
+    emoji: string;
+    count: number;
+    /** The reader reacted this way; the chip shows pressed. */
+    own?: boolean;
+    /** Who reacted, for example from `reactionPeople`. Read by screen readers and shown in the names hint. */
+    label?: string;
+    /** A change of the reader's own reaction is still being saved; the chip carries `aria-busy`. */
+    busy?: boolean;
+};
+export type ReactionBarProps = {
+    reactions: readonly ReactionBarItem[];
+    /** Called with a reaction's key when the reader presses its chip. Without it, the chips are not controls. */
+    onToggle?: (key: string) => void;
+    /** Called by "Add reaction" with the button to anchor a picker to, such as `EmojiPicker.Popover`. Without it there is no button. */
+    onAdd?: (anchor: HTMLElement) => void;
+    /** "default": 26 px chips (chat, item detail). "compact": 24 px chips (cards). */
+    density?: "default" | "compact";
+    /** "scroll" (default): one line of fixed height that scrolls sideways. "wrap": every chip shows, lines wrap. */
+    overflow?: "scroll" | "wrap";
+    /** Shows at most this many chips and then "+n", n being the number of further emoji. The shown chips do not scroll. */
+    max?: number;
+    /** Screen-reader text of "+n"; defaults to "{n} more reactions". */
+    moreLabel?: (count: number) => string;
+    /** "always" (default) or "progressive": shown on hover and focus with a mouse or trackpad (k2b-progressive-action, inside the caller's k2b-progressive-row), kept while its picker is open, hidden on touch. Its place stays reserved. */
+    add?: "always" | "progressive";
+    class?: string;
+};
+export declare function ReactionBar(props: ReactionBarProps): JSX.Element;

package/dist/types/content/chart-inspection-core.d.ts

@@ -0,0 +1,61 @@
+import type { ChartDatum, charts } from "@k2b/stdlib";
+import type { ChartCursor } from "./chart-cursor";
+export type ChartKind = keyof typeof charts;
+export type ChartDatumRef = Pick<ChartDatum, "role" | "index" | "seriesIndex">;
+export declare const sameChartDatum: (a: ChartDatumRef, b: ChartDatumRef) => boolean;
+export type ChartSelection = {
+    kind: ChartKind;
+    datum: ChartDatum;
+};
+export type ChartTooltip = {
+    title?: string;
+    rows: readonly {
+        label: string;
+        value: string;
+    }[];
+};
+export type ChartTooltipFormatter = (selection: ChartSelection) => ChartTooltip;
+export declare function isChartDatum(value: unknown): value is ChartDatum;
+/** Enhances existing SVG nodes. Pointer/focus changes never rebuild the chart. */
+export declare function createChartInspector(options: {
+    container: () => HTMLElement | undefined;
+    cursor?: () => ChartCursor | undefined;
+    tooltip: () => HTMLSpanElement | undefined;
+    anchor: () => HTMLSpanElement | undefined;
+    kind: () => ChartKind;
+    enabled: () => boolean;
+    format: ChartTooltipFormatter;
+    select: (selection: ChartSelection) => void;
+}): {
+    selectDatum: (selected: ChartDatumRef | null | undefined) => void;
+    selectData: (selected: readonly ChartDatumRef[]) => void;
+    linkCursor: (cursor: ChartCursor | undefined) => (() => void);
+    destroy: () => void;
+    move: (event: PointerEvent) => void;
+    down: (event: PointerEvent) => void;
+    click: (event: MouseEvent) => void;
+    focus: (event: FocusEvent) => void;
+    key: (event: KeyboardEvent) => boolean;
+    close: () => void;
+    invalidate: () => void;
+    leave: () => void;
+};
+/** Dismiss inspection on outside interaction, but allow the tooltip itself to scroll. */
+export declare function closeChartInspectionOnOutside(options: {
+    container: () => HTMLElement | undefined;
+    tooltip: () => HTMLElement | undefined;
+    close: () => void;
+}): () => void;
+export type InspectChartOptions = {
+    kind: ChartKind;
+    format: ChartTooltipFormatter;
+    select?: (selection: ChartSelection) => void;
+    cursor?: ChartCursor;
+};
+export type ChartInspection = {
+    invalidate(): void;
+    close(): void;
+    destroy(): void;
+};
+/** Attach inspection to stdlib SVG rendered with inspect: true, without a framework. */
+export declare function inspectChart(container: HTMLElement, options: InspectChartOptions): ChartInspection;

package/dist/types/content/chart-inspection.d.ts

@@ -1,22 +1,6 @@
-import type { ChartDatum } from "@k2b/stdlib";
-import type { ChartKind } from "./Chart";
 import type { ChartCursor } from "./chart-cursor";
-export type ChartDatumRef = Pick<ChartDatum, "role" | "index" | "seriesIndex">;
-export declare const sameChartDatum: (a: ChartDatumRef, b: ChartDatumRef) => boolean;
-export type ChartSelection = {
-    kind: ChartKind;
-    datum: ChartDatum;
-};
-export type ChartTooltip = {
-    title?: string;
-    rows: readonly {
-        label: string;
-        value: string;
-    }[];
-};
-export type ChartTooltipFormatter = (selection: ChartSelection) => ChartTooltip;
-export declare function isChartDatum(value: unknown): value is ChartDatum;
-/** Enhances existing SVG nodes. Pointer/focus changes never rebuild the chart. */
+import { type ChartKind, type ChartSelection, type ChartTooltipFormatter } from "./chart-inspection-core";
+export type { ChartSelection } from "./chart-inspection-core";
 export declare function createChartInspection(options: {
     container: () => HTMLDivElement | undefined;
     cursor?: () => ChartCursor | undefined;
@@ -27,8 +11,8 @@ export declare function createChartInspection(options: {
     format: ChartTooltipFormatter;
     select: (selection: ChartSelection) => void;
 }): {
-    selectDatum: (selected: ChartDatumRef | null | undefined) => void;
-    selectData: (selected: readonly ChartDatumRef[]) => void;
+    selectDatum: (selected: import("./chart-inspection-core").ChartDatumRef | null | undefined) => void;
+    selectData: (selected: readonly import("./chart-inspection-core").ChartDatumRef[]) => void;
     move: (event: PointerEvent) => void;
     down: (event: PointerEvent) => void;
     click: (event: MouseEvent) => void;

package/dist/types/content/chart-snapshot.d.ts

@@ -1,6 +1,6 @@
 import { type ChartDatum } from "@k2b/stdlib";
 import { type ChartKind, type ChartRenderOptions } from "./Chart";
-import { type ChartSelection, type ChartTooltip, type ChartTooltipFormatter } from "./chart-inspection";
+import { type ChartSelection, type ChartTooltip, type ChartTooltipFormatter } from "./chart-inspection-core";
 /** Trusted output of prepareChartSnapshot; never accept arbitrary user SVG. */
 export type ChartSnapshot = {
     kind: ChartKind;

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

@@ -13,7 +13,7 @@ export { default as CodeDisplay } from "./CodeDisplay";
 export { type ChartCursor, createChartCursor } from "./chart-cursor";
 export type { ChartExplorerCharts, ChartExplorerController, ChartExplorerData, ChartExplorerOptions, ChartExplorerRequest, ChartExplorerRow, ChartExplorerSnapshot, } from "./chart-explorer";
 export { createChartExplorer } from "./chart-explorer";
-export type { ChartDatumRef, ChartSelection, ChartTooltip, ChartTooltipFormatter } from "./chart-inspection";
+export type { ChartDatumRef, ChartSelection, ChartTooltip, ChartTooltipFormatter } from "./chart-inspection-core";
 export type { ChartSnapshot } from "./chart-snapshot";
 export { prepareChartSnapshot } from "./chart-snapshot";
 export type { StateTimelineChartOptions, StateTimelineDomain, StateTimelineInterval, StateTimelineRow, StateTimelineState, } from "./chart-state-timeline";
@@ -44,6 +44,7 @@ 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 { ReactionBar, type ReactionBarItem, type ReactionBarProps } from "./ReactionBar";
 export type { StepsProps } from "./Steps";
 export { Steps } from "./Steps";
 export type { StructuredDataPreviewMode, StructuredDataPreviewProps, StructuredDataValue } from "./StructuredDataPreview";

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

@@ -11,6 +11,8 @@ export type OpenDialogOptions = {
     /**
      * Add a same-URL history entry while the dialog is open, so the browser's or the phone's Back closes the dialog
      * instead of leaving the page. Closing the dialog removes the entry again; the returned promise settles after that.
+     * With the Navigation API, same-URL traversals between this core's entries and the page do not reach application popstate listeners.
+     * Without it, only the synthetic Back on close is suppressed.
      */
     history?: boolean;
 };
@@ -33,5 +35,18 @@ export type DialogCore = {
     close: (result?: unknown) => void;
     isOpen: () => boolean;
 };
-export declare const createDialogCore: () => DialogCore;
+export declare const createDialogCore: () => {
+    open: <T>(view: DialogRender<T>, options?: OpenDialogOptions) => Promise<T | undefined>;
+    close: (result?: unknown) => void;
+    isOpen: () => boolean;
+    holdHistory: (onBack: () => void) => (() => void);
+    historySettled: () => Promise<void>;
+};
 export declare const dialogCore: DialogCore;
+/**
+ * Internal: transient UI shares dialogs' Back handling without exposing another public dialog capability.
+ * Same-URL traversals are suppressed with the Navigation API; without it, only the synthetic Back on release is suppressed.
+ */
+export declare const holdDialogHistory: (onBack: () => void) => (() => void);
+/** Internal: waits until entries released through `holdDialogHistory` have left the history. */
+export declare const dialogHistorySettled: () => Promise<void>;

package/dist/types/index.d.ts

@@ -2,6 +2,7 @@ export * from "./actions";
 export * from "./chat";
 export * from "./content";
 export * from "./feedback";
+export { installInputModeController } from "./input-mode";
 export * from "./inputs";
 export { suppressTextSelection } from "./internal/text-selection";
 export * from "./intl";

package/dist/types/input-mode.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Records `data-k2b-input="touch" | "trackpad"` and the sticky
+ * `data-k2b-kbd="on"` on `<html>` of root after qualifying input events.
+ * Returns a function that removes listeners but keeps the attributes.
+ * No-op on the server; installing does not change the initial HTML.
+ */
+export declare const installInputModeController: (root?: Document | undefined) => (() => void);

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

@@ -9,9 +9,10 @@ export type FileDropTargetProps = FileDropOptions & {
     for?: Element;
 };
 /**
- * Turns an area into a drop target while files from outside the page are dragged over the window. A calm overlay
- * covers the area without moving anything and says what dropping does; a more specific target inside it, such as a
- * folder row or a `FileDropzone`, takes the drop and its sentence while the pointer is over it. Text, links, and
+ * Turns an area into a drop target while files from outside the page are dragged over the window. A calm tint covers
+ * the area without moving anything, and while the pointer is over it a chip at its bottom says what dropping does; a
+ * more specific target inside it, such as a folder row or a `FileDropzone`, takes the drop and its sentence while the
+ * pointer is over it. Text, links, and
  * elements dragged within the page never show it. Keep a visible upload button for keyboard and touch users.
  */
 export declare function FileDropTarget(props: FileDropTargetProps): JSX.Element;
@@ -21,3 +22,5 @@ export declare function FileDropTarget(props: FileDropTargetProps): JSX.Element;
  * sentence. Calling the ref again with new options replaces them.
  */
 export declare function fileDropTarget(options: FileDropOptions): (element: Element) => void;
+/** @internal A specific target that shows its drop sentence itself, as `FileDropzone` does; the area's chip then stays hidden. */
+export declare function labelledFileDropTarget(options: FileDropOptions): (element: Element) => void;