@usetheo/ui 0.22.1 → 0.26.0

package/dist/components/composites/annotation-input/annotation-input.d.ts

@@ -0,0 +1,38 @@
+import type { AnnotationCategoricalConfig, AnnotationContinuousConfig, AnnotationFreeformConfig } from "./types.js";
+/**
+ * AnnotationInput — a controlled, config-driven human annotation input (M12).
+ * Dispatches on `config.type` (Phoenix's three-type model): categorical →
+ * RadioGroup over named options; continuous → number input bounded by the
+ * config; freeform → textarea. Fully controlled (`value` + `onValueChange`);
+ * the consumer owns the config (fixture or backend store) and the submission.
+ * Composes the DS form primitives — zero new dependency (M12 ADR D2).
+ *
+ *   <AnnotationInput name="Quality" config={qualityConfig}
+ *                    value={v} onValueChange={setV} />
+ */
+interface AnnotationInputCommon {
+    /** The score name — rendered as the field label / radiogroup accessible name. */
+    name: string;
+    /** Overrides the generated control id (for external label association). */
+    id?: string;
+    /** Optional helper text, wired via aria-describedby. */
+    description?: string;
+    required?: boolean;
+    disabled?: boolean;
+    className?: string;
+}
+export type AnnotationInputProps = (AnnotationInputCommon & {
+    config: AnnotationCategoricalConfig;
+    value: string | null;
+    onValueChange: (value: string | null) => void;
+}) | (AnnotationInputCommon & {
+    config: AnnotationContinuousConfig;
+    value: number | null;
+    onValueChange: (value: number | null) => void;
+}) | (AnnotationInputCommon & {
+    config: AnnotationFreeformConfig;
+    value: string | null;
+    onValueChange: (value: string | null) => void;
+});
+declare function AnnotationInput(props: AnnotationInputProps): import("react").JSX.Element;
+export { AnnotationInput };

package/dist/components/composites/annotation-input/index.d.ts

@@ -0,0 +1,4 @@
+export { AnnotationInput } from "./annotation-input.js";
+export type { AnnotationInputProps } from "./annotation-input.js";
+export type { CategoricalOption, AnnotationCategoricalConfig, AnnotationContinuousConfig, AnnotationFreeformConfig, AnnotationConfig, } from "./types.js";
+export { isCategoricalConfig, isContinuousConfig, isFreeformConfig } from "./types.js";

package/dist/components/composites/annotation-input/types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Annotation config types — the named-score-type contract for AnnotationInput
+ * (M12). Follows Phoenix's three-type model (categorical / continuous /
+ * freeform); Langfuse's BOOLEAN is categorical-of-two and CORRECTION is
+ * system-only, so neither adds to a controlled human input. The config is a
+ * plain descriptor the consumer owns (fixture or backend store) — the DS
+ * component is config-driven and stateless.
+ */
+/** One named categorical choice; `score` optionally maps the label to a numeric value on submit. */
+export interface CategoricalOption {
+    label: string;
+    score?: number | null;
+}
+export interface AnnotationCategoricalConfig {
+    type: "categorical";
+    options: CategoricalOption[];
+}
+export interface AnnotationContinuousConfig {
+    type: "continuous";
+    min: number;
+    max: number;
+    step?: number;
+}
+export interface AnnotationFreeformConfig {
+    type: "freeform";
+    maxLength?: number;
+}
+export type AnnotationConfig = AnnotationCategoricalConfig | AnnotationContinuousConfig | AnnotationFreeformConfig;
+export declare function isCategoricalConfig(c: AnnotationConfig): c is AnnotationCategoricalConfig;
+export declare function isContinuousConfig(c: AnnotationConfig): c is AnnotationContinuousConfig;
+export declare function isFreeformConfig(c: AnnotationConfig): c is AnnotationFreeformConfig;

package/dist/components/composites/attributes-table/attributes-table.d.ts

@@ -0,0 +1,20 @@
+export interface AttributesTableProps {
+    attrs?: Record<string, unknown>;
+    /** Predicate marking a key's value as sensitive (masked fail-closed). Default: nothing masked. */
+    maskedKeys?: (key: string) => boolean;
+    /** Whether the viewer is authorized to reveal masked values. Default false (fail-closed). */
+    canReveal?: boolean;
+    /** Keys promoted to a badge header above the namespace cards. */
+    promoted?: string[];
+    /** Namespace cards start expanded. Default true. */
+    defaultOpen?: boolean;
+}
+/**
+ * AttributesTable — namespace-grouped OTel span attributes with fail-closed
+ * PII masking. A `maskedKeys`-flagged value renders as `•••`; its raw string
+ * NEVER enters the DOM (no text node, no title/aria/data) until Reveal is
+ * clicked AND `canReveal` is true, and its CopyButton is withheld until then.
+ * When `!canReveal` the reveal control is a quiet "masked" hint, not an inert
+ * button. Object values fall back to the dependency-free `JsonViewer`.
+ */
+export declare function AttributesTable({ attrs, maskedKeys, canReveal, promoted, defaultOpen, }: AttributesTableProps): import("react").JSX.Element;

package/dist/components/composites/attributes-table/index.d.ts

@@ -0,0 +1 @@
+export { AttributesTable, type AttributesTableProps } from "./attributes-table.js";

package/dist/components/composites/histogram/histogram.d.ts

@@ -0,0 +1,19 @@
+import type { HTMLAttributes } from "react";
+import { type HistogramBin } from "../../../lib/chart/histogram.js";
+type HistogramData = {
+    bins: HistogramBin[];
+    values?: never;
+    binCount?: never;
+} | {
+    values: number[];
+    binCount: number;
+    bins?: never;
+};
+export type HistogramProps = HTMLAttributes<HTMLElement> & {
+    title: string;
+    height?: number;
+    /** Formats the count axis label and the bin bounds in the a11y table. */
+    valueFormatter?: (v: number) => string;
+} & HistogramData;
+declare const Histogram: import("react").ForwardRefExoticComponent<HistogramProps & import("react").RefAttributes<HTMLElement>>;
+export { Histogram };

package/dist/components/composites/histogram/index.d.ts

@@ -0,0 +1,2 @@
+export { Histogram } from "./histogram.js";
+export type { HistogramProps } from "./histogram.js";

package/dist/components/composites/io-cards/index.d.ts

@@ -0,0 +1,2 @@
+export { IOCards, type IOCardsProps } from "./io-cards.js";
+export { MessageCard, MessageItem, type RenderMarkdown } from "./message-card.js";

package/dist/components/composites/io-cards/io-cards.d.ts

@@ -0,0 +1,17 @@
+import { type RenderMarkdown } from "./message-card.js";
+export interface IOCardsProps {
+    /** Raw payload string: a chat-message-array JSON, other JSON, or plain text. */
+    value?: string;
+    /** Optional slot for rendering markdown bodies (e.g. react-markdown + sanitize). Default: plain text. */
+    renderMarkdown?: RenderMarkdown;
+    "data-testid"?: string;
+}
+/**
+ * IOCards — renders a span's input/output value. A chat-message array becomes
+ * role-labeled cards (with tool-call/result linkage and long-history
+ * collapse); a redacted marker and non-chat payloads fall back to a plain
+ * message or the dependency-free `JsonViewer`. Markdown bodies go through the
+ * optional `renderMarkdown` slot — the default renderer NEVER interprets HTML
+ * (XSS-safe by construction; no `dangerouslySetInnerHTML` anywhere).
+ */
+export declare function IOCards({ value, renderMarkdown, "data-testid": testId }: IOCardsProps): import("react").JSX.Element;

package/dist/components/composites/io-cards/message-card.d.ts

@@ -0,0 +1,21 @@
+import type { ReactNode } from "react";
+import type { ChatMessage, ToolCall } from "../../../lib/trace/types.js";
+export type RenderMarkdown = (text: string) => ReactNode;
+/** Props shared by the message-rendering components (kills the repeated `{message, renderMarkdown}` shape). */
+interface MessageProps {
+    message: ChatMessage;
+    renderMarkdown?: RenderMarkdown;
+}
+/** A bordered, role-labeled Card: role Badge + body (markdown slot or plain text) + raw-JSON toggle. */
+export declare function MessageCard({ message, renderMarkdown }: MessageProps): import("react").JSX.Element;
+/** A dedicated tool-call card: function name + call-id + JSON arguments. Linked to its result by id. */
+export declare function ToolCallCard({ call }: {
+    call: ToolCall;
+}): import("react").JSX.Element;
+/** A tool-result card, linked to its originating call by `tool_call_id`. */
+export declare function ToolResultCard({ message }: {
+    message: ChatMessage;
+}): import("react").JSX.Element;
+/** Render one chat message as its appropriate card kind (tool-result → tool-calls → plain message). */
+export declare function MessageItem({ message, renderMarkdown }: MessageProps): import("react").JSX.Element;
+export {};

package/dist/components/composites/percentile-chart/index.d.ts

@@ -0,0 +1,2 @@
+export { PercentileChart } from "./percentile-chart.js";
+export type { PercentileBucket, PercentileChartProps } from "./percentile-chart.js";

package/dist/components/composites/percentile-chart/percentile-chart.d.ts

@@ -0,0 +1,37 @@
+import type { HTMLAttributes } from "react";
+/**
+ * PercentileChart — p50/p95/p99 over time as shaded BANDS (not three flat
+ * lines), pure-SVG (M3 anti-chart-lib ADR upheld, M11 ADR D1). The p50–p95 and
+ * p95–p99 spans render as filled areas + a p50 reference line, so the spread is
+ * read at a glance (phoenix `TraceLatencyPercentilesTimeSeries` pattern, M11
+ * ADR D2 — the upgrade over the lens' current three-line overlay). Reuses
+ * `linScale`/`niceMax`/`seriesPath` from TrendChart — zero new chart dep.
+ *
+ *   <PercentileChart title="Latency" buckets={latencyBuckets}
+ *                    valueFormatter={(v) => `${v}ms`} />
+ */
+export interface PercentileBucket {
+    /** p50 value for this time bucket. */
+    p50: number;
+    /** p95 value for this time bucket. */
+    p95: number;
+    /** p99 value for this time bucket. */
+    p99: number;
+    /** Optional bucket label (read in the a11y table). */
+    label?: string;
+}
+export type PercentileChartProps = HTMLAttributes<HTMLElement> & {
+    title: string;
+    buckets: PercentileBucket[];
+    height?: number;
+    /** Formats the y-axis label and the a11y table cells. */
+    valueFormatter?: (v: number) => string;
+};
+declare const PercentileChart: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLElement> & {
+    title: string;
+    buckets: PercentileBucket[];
+    height?: number;
+    /** Formats the y-axis label and the a11y table cells. */
+    valueFormatter?: (v: number) => string;
+} & import("react").RefAttributes<HTMLElement>>;
+export { PercentileChart };

package/dist/components/composites/session-summary/index.d.ts

@@ -0,0 +1 @@
+export { SessionSummary, type SessionSummaryProps } from "./session-summary.js";

package/dist/components/composites/session-summary/session-summary.d.ts

@@ -0,0 +1,18 @@
+import type { SessionMetrics, SessionTraceItem } from "../../../lib/session/types.js";
+export interface SessionSummaryProps {
+    /** The session's traces — aggregated internally. Supply `metrics` instead to pass a pre-aggregate. */
+    items?: SessionTraceItem[];
+    /** Pre-computed metrics (overrides `items`). */
+    metrics?: SessionMetrics;
+    /** USD cost formatter. Default `$0.0000`. */
+    formatCostUsd?: (usd: number) => string;
+    className?: string;
+    "aria-label"?: string;
+}
+/**
+ * SessionSummary — a `<dl>` of honest aggregate metrics over a session's traces: trace count, the
+ * session wall-clock window, ∑ cost, ∑ tokens, error count (highlighted destructive when > 0), and
+ * the distinct models. Sums of zero are honest (`$0.0000`, `0`), never an em-dash. Pass `items` (it
+ * aggregates via `aggregateSession`) or a pre-computed `metrics`.
+ */
+export declare function SessionSummary({ items, metrics, formatCostUsd, className, "aria-label": ariaLabel, }: SessionSummaryProps): import("react").JSX.Element;

package/dist/components/composites/session-timeline/index.d.ts

@@ -0,0 +1 @@
+export { SessionTimeline, type SessionTimelineProps } from "./session-timeline.js";

package/dist/components/composites/session-timeline/session-timeline.d.ts

@@ -0,0 +1,22 @@
+import type { SessionTraceItem } from "../../../lib/session/types.js";
+export interface SessionTimelineProps {
+    /** The session's traces (rendered in start-time order regardless of input order). */
+    items: SessionTraceItem[];
+    selectedId: string | null;
+    onSelect: (id: string) => void;
+    /** ns → label for the row timestamp. Default ISO datetime. */
+    formatTimestamp?: (ns: bigint) => string;
+    /** USD cost formatter. Default `$0.0000`. */
+    formatCostUsd?: (usd: number) => string;
+    /** Row count at/above which the virtualized path engages. Default 200. */
+    virtualizeThreshold?: number;
+    className?: string;
+    "aria-label"?: string;
+}
+/**
+ * SessionTimeline — a temporal replay of a session: one row per trace, sorted by start time, each
+ * showing the timestamp, name, a duration bar relative to the session window (via the trace-core
+ * `computeBarLayout`), status, and cost. Controlled selection; virtualizes above the threshold.
+ * Escaped text only.
+ */
+export declare function SessionTimeline({ items, selectedId, onSelect, formatTimestamp, formatCostUsd, virtualizeThreshold, className, "aria-label": ariaLabel, }: SessionTimelineProps): import("react").JSX.Element;

package/dist/components/composites/span-graph/index.d.ts

@@ -0,0 +1 @@
+export { SpanGraph, type SpanGraphProps } from "./span-graph.js";

package/dist/components/composites/span-graph/span-graph.d.ts

@@ -0,0 +1,19 @@
+import type { TraceSpan } from "../../../lib/trace/types.js";
+export interface SpanGraphProps {
+    root: TraceSpan;
+    selectedId: string | null;
+    onSelect: (id: string) => void;
+    /** Max spans before the honest "too large" state renders. Default 200. */
+    nodeCap?: number;
+    className?: string;
+    "aria-label"?: string;
+}
+/**
+ * SpanGraph — a deterministic, dependency-free SVG rendering of the trace as a
+ * layered agent graph (depth = distance from root, order = index within
+ * depth). Edges follow parent/call order; the root→selected path is
+ * highlighted. Over `nodeCap` spans it renders an honest "too large" state
+ * instead of an unreadable hairball. No layout lib (elkjs/d3) — SVG-pure by
+ * ADR D4. Nodes are focusable buttons; selection is controlled.
+ */
+export declare function SpanGraph({ root, selectedId, onSelect, nodeCap, className, "aria-label": ariaLabel, }: SpanGraphProps): import("react").JSX.Element;

package/dist/components/composites/span-tree/index.d.ts

@@ -0,0 +1,2 @@
+export { SpanTree, type SpanTreeProps, type SpanTreeRenderCtx } from "./span-tree.js";
+export { SpanTreeRow, type SpanTreeRowProps } from "./span-tree-row.js";

package/dist/components/composites/span-tree/span-tree-row.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from "react";
+import type { TraceSpan } from "../../../lib/trace/types.js";
+export interface SpanTreeRowProps {
+    span: TraceSpan;
+    depth: number;
+    selected: boolean;
+    collapsed: boolean;
+    hasChildren: boolean;
+    posinset: number;
+    setsize: number;
+    showMetrics?: boolean;
+    /** Optional trace window for the inline timeline bar. */
+    bounds?: {
+        startNs: bigint;
+        endNs: bigint;
+    };
+    onSelect: (id: string) => void;
+    onToggle: (id: string) => void;
+    renderBadge?: (span: TraceSpan) => ReactNode;
+}
+/** The single clickable row for a span — shared by the recursive and virtualized paths. */
+export declare function SpanTreeRow({ span, depth, selected, collapsed, hasChildren, posinset, setsize, showMetrics, bounds, onSelect, onToggle, renderBadge, }: SpanTreeRowProps): import("react").JSX.Element;

package/dist/components/composites/span-tree/span-tree-virtual.d.ts

@@ -0,0 +1,7 @@
+import type { FlatSpan } from "../../../lib/trace/types.js";
+import type { SpanTreeRenderCtx } from "./span-tree.js";
+export interface SpanTreeVirtualProps extends SpanTreeRenderCtx {
+    flat: FlatSpan[];
+}
+/** Virtualized flat-list tree (large traces at/above the threshold), reusing @tanstack/react-virtual. */
+export declare function SpanTreeVirtual({ flat, selectedId, collapsed, showMetrics, bounds, onSelect, onToggle, renderBadge, }: SpanTreeVirtualProps): import("react").JSX.Element;

package/dist/components/composites/span-tree/span-tree.d.ts

@@ -0,0 +1,34 @@
+import { type ReactNode } from "react";
+import type { TraceSpan } from "../../../lib/trace/types.js";
+/** Shared render context threaded to every row (kills per-node prop duplication). */
+export interface SpanTreeRenderCtx {
+    selectedId: string | null;
+    collapsed: Set<string>;
+    showMetrics?: boolean;
+    bounds?: {
+        startNs: bigint;
+        endNs: bigint;
+    };
+    onSelect: (id: string) => void;
+    onToggle: (id: string) => void;
+    renderBadge?: (span: TraceSpan) => ReactNode;
+}
+export interface SpanTreeProps extends Omit<SpanTreeRenderCtx, "onToggle"> {
+    /** Root span of the trace. */
+    root: TraceSpan;
+    /** Collapse toggle (controlled). */
+    onToggleCollapse: (id: string) => void;
+    /** Visible-row count at/above which the virtualized path engages. Default 200. */
+    virtualizeThreshold?: number;
+    className?: string;
+    "aria-label"?: string;
+}
+/**
+ * SpanTree — an accessible, controllable tree of trace spans with full
+ * WAI-ARIA APG TreeView semantics (treeitem / level / posinset / setsize /
+ * selected / expanded / group). Renders recursively for small traces and
+ * switches to a virtualized flat-list at/above `virtualizeThreshold`. The
+ * container is keyboard-navigable (↑/↓ move, Home/End jump, Enter/Space
+ * select). Fully controlled: selection + collapse live in the consumer.
+ */
+export declare function SpanTree({ root, selectedId, onSelect, collapsed, onToggleCollapse, showMetrics, bounds, virtualizeThreshold, renderBadge, className, "aria-label": ariaLabel, }: SpanTreeProps): import("react").JSX.Element;

package/dist/components/composites/span-waterfall/index.d.ts

@@ -0,0 +1 @@
+export { SpanWaterfall, type SpanWaterfallProps } from "./span-waterfall.js";

package/dist/components/composites/span-waterfall/span-waterfall.d.ts

@@ -0,0 +1,28 @@
+import type { TraceSpan } from "../../../lib/trace/types.js";
+type Bounds = {
+    startNs: bigint;
+    endNs: bigint;
+};
+export interface SpanWaterfallProps {
+    root: TraceSpan;
+    /** Trace window; defaults to the honest min-start/max-end envelope of the whole tree. */
+    bounds?: Bounds;
+    selectedId: string | null;
+    onSelect: (id: string) => void;
+    collapsed: Set<string>;
+    /** ns → label for the hover-needle. Default ISO datetime. */
+    formatTimestamp?: (ns: bigint) => string;
+    /** USD cost formatter for the ∑ rollup badge. Default `$0.0000`. */
+    formatCostUsd?: (usd: number) => string;
+    className?: string;
+    "aria-label"?: string;
+}
+/**
+ * SpanWaterfall — a nice-interval time axis over row-packed span bars, a
+ * hover-needle reading the absolute wall-clock time under the pointer, and a
+ * `∑` rollup-cost badge on parent rows. Bars are percentage-positioned via
+ * `computeBarLayout` (clock-skew / in-flight → dashed unbounded). Controlled:
+ * selection lives in the consumer. Escaped text only — no HTML injection.
+ */
+export declare function SpanWaterfall({ root, bounds, selectedId, onSelect, collapsed, formatTimestamp, formatCostUsd, className, "aria-label": ariaLabel, }: SpanWaterfallProps): import("react").JSX.Element;
+export {};

package/dist/components/composites/trace-compare/index.d.ts

@@ -0,0 +1 @@
+export { TraceCompare, type TraceCompareProps, type CompareLane } from "./trace-compare.js";

package/dist/components/composites/trace-compare/trace-compare.d.ts

@@ -0,0 +1,27 @@
+import { type AlignRow } from "../../../lib/trace/align.js";
+import type { TraceSpan } from "../../../lib/trace/types.js";
+export interface CompareLane {
+    /** Display label (e.g. a trace id). */
+    id: string;
+    root: TraceSpan;
+    /** Data still loading — the lane renders a skeleton and no deltas compute. */
+    pending?: boolean;
+}
+export interface TraceCompareProps {
+    /** Baseline lane. */
+    laneA: CompareLane;
+    /** Compared lane (B vs A). */
+    laneB: CompareLane;
+    /** Custom aligner (default: structural `alignSpanTrees`). */
+    align?: (a: TraceSpan, b: TraceSpan) => AlignRow[];
+    /** USD cost formatter. Default `$0.0000`. */
+    formatCostUsd?: (usd: number) => string;
+    className?: string;
+}
+/**
+ * TraceCompare — two traces side by side (B vs A baseline): a metrics header
+ * per lane and a structural diff table. Deltas are honest — a span present in
+ * only one trace is marked `only in A/B` with no fabricated delta. The
+ * component receives DATA (lanes); fetching/URL live in the consumer.
+ */
+export declare function TraceCompare({ laneA, laneB, align, formatCostUsd, className, }: TraceCompareProps): import("react").JSX.Element;

package/dist/components/composites/trace-transcript/index.d.ts

@@ -0,0 +1 @@
+export { TraceTranscript, type TraceTranscriptProps } from "./trace-transcript.js";

package/dist/components/composites/trace-transcript/trace-transcript.d.ts

@@ -0,0 +1,26 @@
+import type { TraceSpan, TranscriptRow } from "../../../lib/trace/types.js";
+export interface TraceTranscriptProps {
+    /** Trace root — the row model is derived via `toTranscriptRows`. */
+    root: TraceSpan;
+    /** Pre-computed rows (overrides `root` derivation — mainly for tests / custom row models). */
+    rows?: TranscriptRow[];
+    selectedId: string | null;
+    onSelect: (id: string) => void;
+    /** Collapsed group ids (subagent subtrees). Uncontrolled-friendly: omit to keep all expanded. */
+    collapsedGroups?: Set<string>;
+    onToggleGroup?: (groupId: string) => void;
+    /** USD cost formatter for per-row stats. Default `$0.0000`. */
+    formatCostUsd?: (usd: number) => string;
+    /** Row count at/above which the virtualized path engages. Default 200. */
+    virtualizeThreshold?: number;
+    className?: string;
+    "aria-label"?: string;
+}
+/**
+ * TraceTranscript — a reader-mode feed of a trace: one card per span (role
+ * badge + name + output preview + micro-stats), with collapsible group
+ * headers for subagent subtrees. Virtualizes at/above `virtualizeThreshold`.
+ * Controlled selection; group collapse is controlled when `collapsedGroups`
+ * is supplied. Escaped text only.
+ */
+export declare function TraceTranscript({ root, rows: rowsProp, selectedId, onSelect, collapsedGroups, onToggleGroup, formatCostUsd, virtualizeThreshold, className, "aria-label": ariaLabel, }: TraceTranscriptProps): import("react").JSX.Element;

package/dist/components/primitives/combobox/combobox.d.ts

@@ -23,7 +23,7 @@ declare const Combobox: import("react").ForwardRefExoticComponent<ComboboxProps
         ref?: React.Ref<HTMLInputElement>;
     } & {
         asChild?: boolean;
-    }, "asChild" | "key" | keyof import("react").InputHTMLAttributes<HTMLInputElement>>, "type" | "value" | "onChange"> & {
+    }, "key" | "asChild" | keyof import("react").InputHTMLAttributes<HTMLInputElement>>, "type" | "value" | "onChange"> & {
         value?: string;
         onValueChange?: (search: string) => void;
     } & import("react").RefAttributes<HTMLInputElement>, "ref"> & import("react").RefAttributes<HTMLInputElement>>;
@@ -34,7 +34,7 @@ declare const Combobox: import("react").ForwardRefExoticComponent<ComboboxProps
         ref?: React.Ref<HTMLDivElement>;
     } & {
         asChild?: boolean;
-    }, "asChild" | "key" | keyof HTMLAttributes<HTMLDivElement>>, "disabled" | "value" | "onSelect"> & {
+    }, "key" | "asChild" | keyof HTMLAttributes<HTMLDivElement>>, "value" | "disabled" | "onSelect"> & {
         disabled?: boolean;
         onSelect?: (value: string) => void;
         value?: string;
@@ -47,7 +47,7 @@ declare const Combobox: import("react").ForwardRefExoticComponent<ComboboxProps
         ref?: React.Ref<HTMLDivElement>;
     } & {
         asChild?: boolean;
-    }, "asChild" | "key" | keyof HTMLAttributes<HTMLDivElement>> & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    }, "key" | "asChild" | keyof HTMLAttributes<HTMLDivElement>> & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
 };
 export { Combobox };
 export type { ComboboxProps, ComboboxContentProps, ComboboxInputProps, ComboboxItemProps };

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export { cn } from "./lib/cn.js";
+export { aggregateCost, asChat, contentText, isRedactedThinking, buildLayeredGraph, computeBarLayout, computeTraceBounds, deriveSpanKind, durationMs, flattenAll, flattenVisible, GRAPH_NODE_CAP, isSpanError, KIND_LABEL, niceAxisTicks, packRows, prettyValue, spanCostUsd, toNs, alignSpanTrees, groupByNamespace, traceMetrics, toTranscriptRows, VIRTUALIZE_THRESHOLD, } from "./lib/trace/index.js";
+export type { AlignDelta, AlignRow, AttributeGroup, AxisTick, BarLayout, ChatMessage, FlatSpan, GraphEdge, GraphNode, LayeredGraph, SpanKind, SpanStatus, ToolCall, TraceSpan, TranscriptRow, TranscriptRowStats, } from "./lib/trace/index.js";
 export { Button, buttonVariants, type ButtonProps } from "./components/primitives/button/index.js";
 export { Badge, badgeVariants, type BadgeProps } from "./components/primitives/badge/index.js";
 export { Breadcrumb, type BreadcrumbLinkProps, } from "./components/primitives/breadcrumb/index.js";
@@ -61,3 +63,31 @@ export { PreviewEnvCard, type PreviewEnv, type PreviewService, } from "./compone
 export { DomainConfig, type Domain, type DomainStatus, } from "./components/composites/domain-config/index.js";
 export { RollbackUI, type RollbackTarget, } from "./components/composites/rollback-ui/index.js";
 export { CommandPalette, type CommandItem, } from "./components/composites/command-palette/index.js";
+export { SpanTree, SpanTreeRow } from "./components/composites/span-tree/index.js";
+export type { SpanTreeProps, SpanTreeRowProps, SpanTreeRenderCtx, } from "./components/composites/span-tree/index.js";
+export { SpanWaterfall } from "./components/composites/span-waterfall/index.js";
+export type { SpanWaterfallProps } from "./components/composites/span-waterfall/index.js";
+export { AttributesTable } from "./components/composites/attributes-table/index.js";
+export type { AttributesTableProps } from "./components/composites/attributes-table/index.js";
+export { IOCards, MessageCard, MessageItem } from "./components/composites/io-cards/index.js";
+export type { IOCardsProps, RenderMarkdown } from "./components/composites/io-cards/index.js";
+export { TraceTranscript } from "./components/composites/trace-transcript/index.js";
+export type { TraceTranscriptProps } from "./components/composites/trace-transcript/index.js";
+export { SpanGraph } from "./components/composites/span-graph/index.js";
+export type { SpanGraphProps } from "./components/composites/span-graph/index.js";
+export { TraceCompare } from "./components/composites/trace-compare/index.js";
+export type { TraceCompareProps, CompareLane, } from "./components/composites/trace-compare/index.js";
+export { aggregateSession, sessionBounds } from "./lib/session/index.js";
+export type { SessionTraceItem, SessionMetrics } from "./lib/session/index.js";
+export { SessionSummary } from "./components/composites/session-summary/index.js";
+export type { SessionSummaryProps } from "./components/composites/session-summary/index.js";
+export { SessionTimeline } from "./components/composites/session-timeline/index.js";
+export type { SessionTimelineProps } from "./components/composites/session-timeline/index.js";
+export { computeHistogram } from "./lib/chart/index.js";
+export type { HistogramBin } from "./lib/chart/index.js";
+export { Histogram } from "./components/composites/histogram/index.js";
+export type { HistogramProps } from "./components/composites/histogram/index.js";
+export { PercentileChart } from "./components/composites/percentile-chart/index.js";
+export type { PercentileBucket, PercentileChartProps, } from "./components/composites/percentile-chart/index.js";
+export { AnnotationInput, isCategoricalConfig, isContinuousConfig, isFreeformConfig, } from "./components/composites/annotation-input/index.js";
+export type { AnnotationInputProps, CategoricalOption, AnnotationCategoricalConfig, AnnotationContinuousConfig, AnnotationFreeformConfig, AnnotationConfig, } from "./components/composites/annotation-input/index.js";