@k2b/ui 0.1.0-rc.0 → 0.1.1

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

@@ -0,0 +1,20 @@
+import { type JSX } from "solid-js";
+export type SegmentOption<T extends string = string> = {
+    value: T;
+    label: JSX.Element;
+    icon?: string;
+    disabled?: boolean;
+};
+export type SegmentedControlProps<T extends string = string> = {
+    options: readonly SegmentOption<T>[];
+    value: T | (() => T);
+    onValueChange: (value: T) => void;
+    disabled?: boolean;
+    ariaLabel?: string;
+    label?: string;
+    size?: "sm" | "md";
+    class?: string;
+};
+/** Controlled radio group with automatic selection during arrow-key navigation. */
+export declare function SegmentedControl<T extends string = string>(props: SegmentedControlProps<T>): JSX.Element;
+export default SegmentedControl;

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

@@ -0,0 +1,13 @@
+import { type JSX } from "solid-js";
+import { type ButtonProps } from "./Button";
+import { type DropdownItem, type DropdownPosition } from "./Dropdown";
+export type SplitButtonProps = ButtonProps & {
+    /** Actions shown from the secondary menu trigger. */
+    items: readonly DropdownItem[];
+    /** Accessible name and title for the icon-only menu trigger. */
+    menuLabel: string;
+    menuPosition?: DropdownPosition | (() => DropdownPosition);
+    menuWidth?: string;
+};
+/** One primary button action with a separate menu of related alternatives. */
+export declare function SplitButton(props: SplitButtonProps): JSX.Element;

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

@@ -0,0 +1,25 @@
+import type { JSX } from "solid-js";
+import type { PromptSearchInput, PromptSearchItem, PromptSearchOptions } from "../feedback/prompts";
+export declare const SPOTLIGHT_SHORTCUT = "mod+shift+k";
+export declare const SPOTLIGHT_SHORTCUT_LABEL = "\u21E7\u2318K";
+export declare const SPOTLIGHT_SHORTCUT_TITLE = "Mod+Shift+K";
+export type SpotlightSearchResolver<T = unknown> = (input: PromptSearchInput) => Promise<PromptSearchItem<T>[]> | PromptSearchItem<T>[];
+export type SpotlightSearchOptions<T = unknown> = PromptSearchOptions & {
+    resolve: SpotlightSearchResolver<T>;
+};
+export type SpotlightButtonVariant = "default" | "compact" | "chip" | "sidebar" | "sidebar-mobile" | "icon";
+export type SpotlightButtonProps = {
+    variant?: SpotlightButtonVariant;
+    label?: string;
+    title?: string;
+    icon?: string;
+    shortcutLabel?: string | false;
+    ariaLabel?: string;
+    disabled?: boolean;
+    class?: string;
+    onClick: () => void | Promise<void>;
+};
+export declare const isSpotlightShortcut: (event: KeyboardEvent) => boolean;
+export declare const openSpotlightSearch: <T = unknown>(options: SpotlightSearchOptions<T>) => Promise<PromptSearchItem<T> | undefined>;
+export declare function SpotlightButton(props: SpotlightButtonProps): JSX.Element;
+export default SpotlightButton;

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

@@ -0,0 +1,27 @@
+import { type JSX } from "solid-js";
+import type { MaybeAccessor } from "../inputs/field-contract";
+export type TabOption<T extends string = string> = {
+    value: T;
+    label: JSX.Element;
+    icon?: string;
+    disabled?: boolean;
+    panel?: JSX.Element;
+};
+export type TabsItemProps<T extends string = string> = Omit<TabOption<T>, "panel"> & {
+    children?: JSX.Element;
+};
+export type TabsProps<T extends string = string> = {
+    value: MaybeAccessor<T>;
+    onValueChange: (value: T) => void;
+    ariaLabel: string;
+    orientation?: "horizontal" | "vertical";
+    class?: string;
+    /** Data-driven alternative to colocated `Tabs.Item` children. */
+    options?: readonly TabOption<T>[];
+    children?: JSX.Element;
+};
+type TabsComponent = (<T extends string = string>(props: TabsProps<T>) => JSX.Element) & {
+    Item: <T extends string = string>(props: TabsItemProps<T>) => JSX.Element;
+};
+export declare const Tabs: TabsComponent;
+export default Tabs;

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

@@ -0,0 +1,23 @@
+import { type JSX } from "solid-js";
+export type ToolbarProps = {
+    children: JSX.Element;
+    label: string;
+    orientation?: "horizontal" | "vertical";
+    wrap?: boolean;
+    class?: string;
+};
+export type ToolbarGroupProps = {
+    children: JSX.Element;
+    label?: string;
+    class?: string;
+};
+export type ToolbarSeparatorProps = {
+    class?: string;
+};
+type ToolbarComponent = ((props: ToolbarProps) => JSX.Element) & {
+    Group: (props: ToolbarGroupProps) => JSX.Element;
+    Separator: (props: ToolbarSeparatorProps) => JSX.Element;
+    Spacer: () => JSX.Element;
+};
+export declare const Toolbar: ToolbarComponent;
+export default Toolbar;

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

@@ -0,0 +1,24 @@
+export type { ButtonLinkProps, ButtonProps, ButtonSize, ButtonVariant, IconButtonLinkProps, IconButtonProps } from "./Button";
+export { Button, ButtonLink, IconButton, IconButtonLink } from "./Button";
+export type { CopyButtonProps, CopyButtonValue } from "./CopyButton";
+export { CopyButton } from "./CopyButton";
+export type { DisclosureProps } from "./Disclosure";
+export { Disclosure } from "./Disclosure";
+export type { DropdownAction, DropdownActionBase, DropdownChoice, DropdownItemProps, DropdownPosition, DropdownProps, DropdownSection, DropdownTriggerProps, } from "./Dropdown";
+export { Dropdown, DropdownItem, dropdownPosition } from "./Dropdown";
+export type { FilterChipOption, FilterChipProps, FilterChipSection } from "./FilterChip";
+export { FilterChip } from "./FilterChip";
+export type { ContextMenuProps } from "./ContextMenu";
+export { ContextMenu } from "./ContextMenu";
+export type { RemoveButtonProps } from "./RemoveButton";
+export { RemoveButton } from "./RemoveButton";
+export type { SpotlightButtonProps, SpotlightButtonVariant, SpotlightSearchOptions, SpotlightSearchResolver, } from "./SpotlightSearch";
+export { isSpotlightShortcut, openSpotlightSearch, SPOTLIGHT_SHORTCUT, SPOTLIGHT_SHORTCUT_LABEL, SPOTLIGHT_SHORTCUT_TITLE, SpotlightButton, } from "./SpotlightSearch";
+export type { SegmentedControlProps, SegmentOption } from "./SegmentedControl";
+export { SegmentedControl } from "./SegmentedControl";
+export type { SplitButtonProps } from "./SplitButton";
+export { SplitButton } from "./SplitButton";
+export type { TabOption, TabsItemProps, TabsProps } from "./Tabs";
+export { Tabs } from "./Tabs";
+export type { ToolbarGroupProps, ToolbarProps, ToolbarSeparatorProps } from "./Toolbar";
+export { Toolbar } from "./Toolbar";

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

@@ -0,0 +1,57 @@
+import { type JSX } from "solid-js";
+import type { ChatAction, ChatAttachment, ChatComposerState, ChatContextUsageData, ChatModelOption, ChatSubmitInput } from "./types";
+export type ChatCommandContext = {
+    setValue: (value: string) => void;
+    submit: () => void;
+    focus: () => void;
+};
+export type ChatCommand = {
+    name: string;
+    description: string;
+    icon?: string;
+    action: (context: ChatCommandContext) => void | Promise<void>;
+};
+export type ChatFileSelection = {
+    onSelect: (files: readonly File[]) => void | Promise<void>;
+    onError?: (error: unknown) => void;
+    accept?: string;
+    multiple?: boolean;
+    disabled?: boolean;
+    label?: string;
+};
+export type ChatPasteHandler = (event: ClipboardEvent & {
+    currentTarget: HTMLTextAreaElement;
+    target: Element;
+}) => void;
+export type ChatComposerProps = {
+    value: string;
+    onValueChange: (value: string) => void;
+    onSubmit: (input: ChatSubmitInput) => boolean | void | Promise<boolean | void>;
+    /** Submit intent used for drafts entered while a response is running. Defaults to `steer`. */
+    runningSubmitIntent?: "steer" | "queue";
+    onStop?: () => void | Promise<void>;
+    onError?: (error: unknown) => void;
+    state?: ChatComposerState;
+    attachments?: readonly ChatAttachment[];
+    onAttachmentsChange?: (attachments: readonly ChatAttachment[]) => void;
+    fileSelection?: ChatFileSelection;
+    /** Handle non-file clipboard content. Pasted files already use `fileSelection`. */
+    onPaste?: ChatPasteHandler;
+    menuActions?: readonly ChatAction[];
+    models?: readonly ChatModelOption[];
+    selectedModelId?: string | null;
+    onModelChange?: (modelId: string) => void;
+    commands?: readonly ChatCommand[];
+    contextUsage?: ChatContextUsageData;
+    contextActions?: readonly ChatAction[];
+    /** Additional compact controls rendered with the add/model controls. */
+    footerTools?: JSX.Element;
+    placeholder?: string;
+    label?: string;
+    inputLabel?: string;
+    disabled?: boolean;
+    error?: string;
+    focusToken?: unknown;
+    class?: string;
+};
+export declare function ChatComposer(props: ChatComposerProps): JSX.Element;

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

@@ -0,0 +1,48 @@
+import { type JSX } from "solid-js";
+import type { ChatAction, ChatActivityTone, ChatAttachment, ChatContextUsageData, ChatMessageStatus, ChatRole } from "./types";
+export type ChatMessageProps = {
+    role: ChatRole;
+    children?: JSX.Element;
+    label?: string;
+    createdAt?: string | Date;
+    timeLabel?: string;
+    status?: ChatMessageStatus;
+    attachments?: readonly ChatAttachment[];
+    actions?: readonly ChatAction[];
+    actionDisplay?: "auto" | "inline" | "menu";
+    anchorId?: string | number;
+    onActionError?: (error: unknown) => void;
+    class?: string;
+};
+export type ChatActivityProps = {
+    label: string;
+    description?: string;
+    icon?: string;
+    /** Optional host-owned leading visual rendered instead of the icon. */
+    leading?: JSX.Element;
+    /** Optional identity accent for the leading visual. Semantic tones still take precedence. */
+    accent?: string;
+    tone?: ChatActivityTone;
+    /** Marks the activity as running with the shared accent sweep. */
+    busy?: boolean;
+    trailing?: JSX.Element;
+    /** Controlled disclosure state. Omit to keep native details behavior. */
+    open?: boolean;
+    /** Reports disclosure changes when `open` is controlled by the host. */
+    onOpenChange?: (open: boolean) => void;
+    defaultOpen?: boolean;
+    /** Set to false when the body is a peer list that should align with the activity row. */
+    bodyInset?: boolean;
+    anchorId?: string | number;
+    children?: JSX.Element;
+    class?: string;
+};
+export type ChatContextUsageProps = ChatContextUsageData & {
+    /** Host-owned number formatting. The default is locale-independent and SSR-stable. */
+    formatNumber?: (value: number) => string;
+    class?: string;
+};
+export declare const formatChatTokens: (tokens: number) => string;
+export declare function ChatMessage(props: ChatMessageProps): JSX.Element;
+export declare function ChatActivity(props: ChatActivityProps): JSX.Element;
+export declare function ChatContextUsage(props: ChatContextUsageProps): JSX.Element;

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

@@ -0,0 +1,7 @@
+import type { JSX } from "solid-js";
+export type ChatRootProps = {
+    children: JSX.Element;
+    class?: string;
+    label?: string;
+};
+export declare function ChatRoot(props: ChatRootProps): JSX.Element;

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

@@ -0,0 +1,52 @@
+import { type JSX } from "solid-js";
+import type { ChatAction, ChatActivityTone, ChatAttachment, ChatMessageStatus, ChatRole } from "./types";
+export type ChatMessageItem = {
+    kind: "message";
+    id: string;
+    role: ChatRole;
+    content?: JSX.Element;
+    label?: string;
+    createdAt?: string | Date;
+    timeLabel?: string;
+    status?: ChatMessageStatus;
+    attachments?: readonly ChatAttachment[];
+    actions?: readonly ChatAction[];
+    actionDisplay?: "auto" | "inline" | "menu";
+    anchorId?: string | number;
+    class?: string;
+};
+export type ChatActivityItem = {
+    kind: "activity";
+    id: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    leading?: JSX.Element;
+    accent?: string;
+    tone?: ChatActivityTone;
+    busy?: boolean;
+    trailing?: JSX.Element;
+    defaultOpen?: boolean;
+    anchorId?: string | number;
+    content?: JSX.Element;
+    class?: string;
+};
+export type ChatTimelineItem = ChatMessageItem | ChatActivityItem;
+export type ChatTimelineProps = {
+    items: readonly ChatTimelineItem[];
+    conversationKey?: string | null;
+    loading?: boolean;
+    hasMore?: boolean;
+    loadingOlder?: boolean;
+    onLoadOlder?: () => boolean | void | Promise<boolean | void>;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    navigation?: JSX.Element;
+    onActionError?: (error: unknown) => void;
+    viewportRef?: (element: HTMLDivElement) => void;
+    contentRef?: (element: HTMLDivElement) => void;
+    label?: string;
+    followThreshold?: number;
+    class?: string;
+};
+export declare function ChatTimeline(props: ChatTimelineProps): JSX.Element;

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

@@ -0,0 +1,29 @@
+import type { ChatAction } from "./types";
+export declare const filterChatCommands: <T extends {
+    name: string;
+}>(value: string, commands: readonly T[]) => T[];
+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;
+export declare const restoredChatScrollTop: (previousScrollTop: number, previousScrollHeight: number, nextScrollHeight: number) => number;
+export type ChatSubmissionRun = {
+    /** Clears the controlled draft (and attachments) before the handler runs. */
+    clear: () => void;
+    /**
+     * The application handler. A synchronous throw, a rejected promise, and a
+     * `false` result all count as a rejected submission.
+     */
+    perform: () => boolean | void | Promise<boolean | void>;
+    /** Restores the cleared draft (and attachments) after a rejected submission. */
+    restore: () => void;
+    onError?: (error: unknown) => void;
+};
+/**
+ * Runs one composer submission with optimistic clearing. Resolves to `true`
+ * when the handler accepted the submission. A synchronous throw is handled
+ * exactly like a rejected promise so a controlled draft is never lost.
+ */
+export declare const runChatSubmission: (run: ChatSubmissionRun) => Promise<boolean>;
+/** Reports a handler failure without letting a synchronous throw escape. */
+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>;

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

@@ -0,0 +1,21 @@
+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 { ChatActivityProps, ChatContextUsageProps, ChatMessageProps } from "./ChatPrimitives";
+export { formatChatTokens } from "./ChatPrimitives";
+export type { ChatRootProps } from "./ChatRoot";
+export type { ChatActivityItem, ChatMessageItem, ChatTimelineItem, ChatTimelineProps } from "./ChatTimeline";
+export type { ChatAction, ChatActivityTone, ChatAttachment, ChatComposerState, ChatContextUsageData, ChatMessageStatus, ChatModelOption, ChatRole, ChatSubmitInput, ChatSubmitIntent, ChatUsage, } from "./types";
+/**
+ * Portable, controlled chat surface. Applications own storage, streaming,
+ * authorization, rich message rendering, and domain actions.
+ */
+export declare const Chat: typeof ChatRoot & {
+    Timeline: typeof ChatTimeline;
+    Message: typeof ChatMessage;
+    Activity: typeof ChatActivity;
+    Composer: typeof ChatComposer;
+    ContextUsage: typeof ChatContextUsage;
+};

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

@@ -0,0 +1,62 @@
+export type ChatRole = "user" | "assistant" | "system" | "tool";
+export type ChatMessageStatus = "pending" | "streaming" | "complete" | "error";
+export type ChatActivityTone = "neutral" | "ai" | "success" | "danger";
+type ChatActionBase = {
+    id: string;
+    label: string;
+    icon?: string;
+    variant?: "danger";
+    disabled?: boolean;
+    /** Toggle state for persistent message actions such as feedback. */
+    pressed?: boolean;
+};
+/** Exactly one executable behavior for every chat action. */
+export type ChatAction = ChatActionBase & ({
+    onSelect: () => void | Promise<void>;
+    copyText?: never;
+} | {
+    copyText: string;
+    onSelect?: never;
+});
+export type ChatAttachment = {
+    id: string;
+    name: string;
+    size?: number;
+    kind?: "file" | "image" | "resource";
+    icon?: string;
+    previewUrl?: string;
+    alt?: string;
+    /** Optional destination represented by this attachment. */
+    href?: string;
+    /** Opaque application-owned payload returned unchanged with ChatSubmitInput. */
+    data?: unknown;
+    /** Optional application-owned action presented below the attachment label. */
+    action?: ChatAction;
+};
+export type ChatUsage = {
+    input?: number;
+    output?: number;
+    total?: number;
+};
+export type ChatContextUsageData = {
+    usage?: ChatUsage | null;
+    loopUsage?: ChatUsage | null;
+    contextWindow?: number;
+    modelLabel?: string;
+};
+export type ChatModelOption = {
+    id: string;
+    label: string;
+    description?: string;
+    image?: string;
+    icon?: string;
+    capabilities?: readonly string[];
+};
+export type ChatComposerState = "idle" | "submitting" | "running" | "stopping";
+export type ChatSubmitIntent = "send" | "steer" | "queue";
+export type ChatSubmitInput = {
+    intent: ChatSubmitIntent;
+    text: string;
+    attachments: readonly ChatAttachment[];
+};
+export {};

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

@@ -0,0 +1,115 @@
+import { type LinkNavigateEvent } from "@k2b/ssr/nav";
+import { type DateContext } from "@k2b/stdlib";
+import type { JSX } from "solid-js";
+export type CalendarView = "day" | "week" | "month" | "year" | "mobile-month";
+export type CalendarEventColor = "blue" | "emerald" | "amber" | "red" | "violet" | "cyan" | "zinc";
+export type CalendarEvent = {
+    id: string;
+    title: string;
+    start: Date | string;
+    end?: Date | string;
+    allDay?: boolean;
+    color?: CalendarEventColor;
+    colorHex?: string;
+    href?: string;
+    dataSpaceItemId?: string;
+    meta?: string;
+    description?: string;
+    display?: "event" | "background";
+    location?: string;
+    calendarName?: string;
+    attendees?: CalendarAttendee[];
+    resources?: CalendarResource[];
+    recurrence?: CalendarRecurrence;
+};
+export type CalendarAttendee = {
+    name: string;
+    status?: "accepted" | "declined" | "tentative" | "needs-action";
+};
+export type CalendarResource = {
+    name: string;
+    kind?: "room" | "equipment" | "link" | "other";
+};
+export type CalendarRecurrence = {
+    rrule: string;
+    exdate?: Array<Date | string>;
+    recurrenceId?: Date | string;
+};
+export type CalendarLabels = Partial<{
+    today: string;
+    day: string;
+    week: string;
+    month: string;
+    year: string;
+    allDay: string;
+    noEvents: string;
+    previous: string;
+    next: string;
+}>;
+export type CalendarEventRenderContext = {
+    compact: boolean;
+    fill: boolean;
+    start: Date;
+    end: Date;
+    allDay: boolean;
+    durationHours: number;
+    timeLabel: string;
+};
+export type CalendarProps = {
+    date: Date | string;
+    events: CalendarEvent[];
+    view?: CalendarView;
+    views?: CalendarView[];
+    labels?: CalendarLabels;
+    /** stdlib date context used for timezone-aware rendering and calendar math. */
+    dateConfig?: DateContext;
+    /** Convenience override for dateConfig.timeZone. */
+    timeZone?: string;
+    firstDayOfWeek?: 0 | 1;
+    withWeekNumbers?: boolean;
+    startHour?: number;
+    endHour?: number;
+    visibleStartHour?: number;
+    visibleEndHour?: number;
+    allDayMaxHeightRem?: number;
+    hideAllDay?: boolean;
+    selectedDate?: Date | string;
+    selectedEventId?: string;
+    dayBadges?: Record<string, CalendarDayBadge>;
+    getViewHref?: (view: CalendarView) => string;
+    getDateHref?: (date: Date, view: CalendarView) => 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. */
+    onNavigate?: (event: LinkNavigateEvent) => void | Promise<void>;
+    /** Progressively enhance canonical links without a document view transition. */
+    onNavigateHref?: (href: string) => void;
+    /** 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;
+    /** One activation contract for pointer and keyboard input. */
+    onEventActivate?: (event: CalendarEvent) => void;
+    /** Pointer gesture used for activation. Keyboard activation is always immediate. */
+    eventActivation?: "single" | "double";
+    onEventDrop?: (event: CalendarEvent, next: CalendarEventTimeChange) => void;
+    onEventResize?: (event: CalendarEvent, next: CalendarEventTimeChange) => void;
+    onSlotActivate?: (slot: CalendarEventTimeChange) => void;
+    /** Pointer gesture used for empty slots. Keyboard activation is always immediate. */
+    slotActivation?: "single" | "double";
+    toolbarActions?: JSX.Element;
+    toolbarContent?: JSX.Element;
+    class?: string;
+};
+export type CalendarEventTimeChange = {
+    start: Date;
+    end: Date;
+    allDay?: boolean;
+};
+export type CalendarDayBadge = {
+    icon?: string;
+    label: string;
+};
+declare const Calendar: (props: CalendarProps) => JSX.Element;
+export default Calendar;

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

@@ -0,0 +1,90 @@
+import { charts } from "@k2b/stdlib";
+import type { JSX } from "solid-js";
+import { type StateTimelineChartOptions } from "./chart-state-timeline";
+/**
+ * Chart — minimal Solid wrapper around `stdlib.charts`.
+ *
+ * **Live-update story.** `charts.<kind>(opts)` returns an SVG string;
+ * Solid's `innerHTML` is reactive, so any time a prop (signal, store
+ * slice, derived value) changes, the SVG re-renders. No manual
+ * subscription, no imperative DOM patching. Trade-off: every change
+ * is a full SVG re-build, not a diff — fine for dashboard cadences
+ * (poll, websocket, store updates). Don't use this for 60fps streaming.
+ *
+ * **Sizing.** stdlib emits `<svg viewBox="0 0 W H">` with no width/
+ * height attributes, so the SVG would otherwise fall back to the
+ * browser's replaced-element default (300×150) and either overflow
+ * or look squished. We measure the wrapping `<div>` with a
+ * ResizeObserver and pass the actual pixel dimensions to stdlib —
+ * the viewBox matches the container, no aspect distortion, no
+ * letterboxing. Sizing the wrapper itself is the caller's job
+ * (`style={{ height: "14rem" }}`, an app class, a flex child, …).
+ * On SSR (no observer)
+ * the chart renders at stdlib's default size; the first client-side
+ * frame re-measures and re-renders.
+ *
+ * One documented exception: `kind: "stateTimeline"` derives its own
+ * initial height from the row count and legend via
+ * `stateTimelineHeight()`, because a timeline's height is a function of
+ * how many rows it has rather than of the layout around it. Every other
+ * kind starts at 280px until the observer reports the real box. Layout
+ * code that sizes charts uniformly must account for this.
+ *
+ * **Why so thin.** The props are a discriminated union over each
+ * stdlib chart function — `kind: "line"` brings in exactly the params
+ * `charts.line` expects, `kind: "bar"` brings in `charts.bar`'s, etc.
+ * Options stay aligned with stdlib without renaming. Shared interactive
+ * layers add bounded pan / zoom controls to maps and state timelines, plus
+ * nearest-point hover and keyboard inspection for line charts.
+ * If stdlib gains a new option, it's automatically available at every
+ * callsite.
+ *
+ * **Theming.** stdlib charts use `currentColor` for axes / ticks /
+ * tick labels — set the wrapping element's `color` and everything
+ * inherits. Series colors come from `--stdlib-chart-c1..c8` CSS
+ * custom properties; override on the parent for per-chart palettes.
+ *
+ * ```tsx
+ * <Chart kind="line" style={{ height: "12rem" }}
+ *        series={[{ data: points() }]}
+ *        yAxis={{ format: v => `€${v}k` }} />
+ *
+ * <Chart kind="donut" style={{ height: "12rem" }} data={slices()} />
+ *
+ * <Chart kind="sparkline" style={{ width: "6rem", height: "1.5rem" }} data={trend()} />
+ *
+ * <Chart kind="map" style={{ height: "16rem" }} series={locations()} interactive />
+ * ```
+ */
+/** All chart kinds shipped by `stdlib.charts`. */
+export type ChartKind = keyof typeof charts;
+export type ChartLabels = Partial<{
+    empty: string;
+    series: string;
+    interactiveMap: string;
+    interactiveTimeline: string;
+    interactiveLine: string;
+    zoomIn: string;
+    zoomOut: string;
+    resetMap: string;
+    resetTimeline: string;
+}>;
+/**
+ * Per-kind props: `kind` discriminator + the exact options that
+ * `charts.<kind>` accepts, **minus** `width` / `height` (the wrapper
+ * owns those — they're derived from container measurement). Solid's
+ * component model handles discriminated unions natively, so callsites
+ * get full type safety.
+ */
+export type ChartProps = {
+    [K in ChartKind]: {
+        kind: K;
+        class?: string;
+        style?: JSX.CSSProperties | string;
+        labels?: ChartLabels;
+    } & (K extends "stateTimeline" ? StateTimelineChartOptions : Omit<Parameters<(typeof charts)[K]>[0], "width" | "height"> & (K extends "map" | "line" ? {
+        interactive?: boolean;
+    } : {}));
+}[ChartKind];
+declare const Chart: (props: ChartProps) => JSX.Element;
+export default Chart;

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

@@ -0,0 +1,11 @@
+import { type CodeDisplayLanguage } from "./code-highlight";
+export type { CodeDisplayLanguage };
+export type CodeDisplayProps = {
+    code: string;
+    title?: string;
+    language?: CodeDisplayLanguage;
+    copy?: boolean;
+    lineNumbers?: boolean;
+    class?: string;
+};
+export default function CodeDisplay(props: CodeDisplayProps): import("solid-js").JSX.Element;