@altertable/data-app 0.65.0 → 0.67.0

package/dist/types/react/ui/DataApp.d.ts

@@ -1,61 +1,20 @@
-import { type ComponentProps, type ReactNode } from 'react';
-import type { DisclosedQuery } from '../../core/contract.js';
-import type { DataAppConfig } from '../../core/config.js';
-import type { CsvExport } from './csv-export.js';
-import { type DisplayedSnapshot } from '../../core/data-view.js';
-import { type AboutEmpty } from './AboutData.js';
-import { AppLayout } from './AppLayout.js';
-import { type AppToolbarProps } from './AppToolbar.js';
-import type { DataContext } from './data-context.js';
-import type { BoundStory } from './story.js';
-import { type SectionResult } from './DataSection.js';
-import type { EmptyContent } from './presentation.js';
-type DataAppBaseProps = {
-    config: DataAppConfig;
-    dataContext: DataContext;
-    aboutEmpty?: AboutEmpty;
-    description?: ReactNode;
-    /** Display names only; config.scope remains the connection identity. */
-    scopeLabels?: {
-        organization?: string;
-        environment?: string;
+import { type RegisteredBinding } from '../bindings.js';
+import type { DisplayedSnapshot } from '../../core/data-view.js';
+import { type ExportDataset } from '../bindings.js';
+import type { StoryFinding } from './story.js';
+import { type DataAppBaseProps } from './DataAppFrame.js';
+import { type DeclaredView } from '../view-runtime.js';
+export type DataAppProps<Data, Input = unknown> = Omit<DataAppBaseProps, 'dataContext'> & {
+    view: DeclaredView<Data, Input> & {
+        scope(snapshot: DisplayedSnapshot<Data, Input>): string;
     };
-    toolbarActions?: ReactNode;
-    footerActions?: ReactNode;
-    layoutProps?: Omit<ComponentProps<typeof AppLayout>, 'children' | 'footerActions'>;
+    story: (snapshot: DisplayedSnapshot<Data, Input>) => readonly (Omit<StoryFinding, 'evidence'> & {
+        evidence: RegisteredBinding;
+    })[];
+    datasets: readonly [
+        ExportDataset<Data, Input>,
+        ...ExportDataset<Data, Input>[]
+    ];
 };
-export type DataAppRequest<Data, Input> = SectionResult<Data, Input> & {
-    queries?: DisclosedQuery[];
-    refresh?: AppToolbarProps['refresh'];
-    empty: EmptyContent;
-    controls?: ReactNode;
-};
-export type DataAppProps<Data = unknown, Input = unknown> = DataAppBaseProps & ({
-    request: DataAppRequest<Data, Input>;
-    /** Findings are always derived from the result currently visible to the reader. */
-    story: BoundStory<Data, Input>;
-    /** Every analytical view exports every distinct dataset in its displayed result. */
-    csvExport: (snapshot: DisplayedSnapshot<Data, Input>) => CsvExport;
-    children: (data: Data, displayedInput: Input) => ReactNode;
-    loading?: ReactNode;
-    label?: string;
-    queries?: never;
-    refresh?: never;
-    variables?: never;
-} | {
-    request?: never;
-    story?: never;
-    csvExport?: CsvExport;
-    children: ReactNode;
-    queries?: DisclosedQuery[];
-    refresh?: AppToolbarProps['refresh'];
-    variables?: ReactNode;
-    loading?: never;
-    empty?: never;
-    label?: never;
-});
-/** Owns the page title, header, gutter, and width; body content uses section headings.
- * The primary request owns controls, empty state, displayed input, refresh, and inspection.
- * Without a request, the shell accepts authored children for setup or static views. */
+/** Executes the primary view and owns its controls, inspection, exports, and stories. */
 export declare function DataApp<Data, Input>(props: DataAppProps<Data, Input>): import("react").JSX.Element;
-export {};

package/dist/types/react/ui/DataAppFrame.d.ts

@@ -0,0 +1,41 @@
+import { type ReactNode } from 'react';
+import type { DisclosedQuery } from '../../core/contract.js';
+import type { CsvExport } from './csv-export.js';
+import { type DisplayedSnapshot } from '../../core/data-view.js';
+import type { DataContext } from './data-context.js';
+import type { BoundStory } from './story.js';
+import type { SectionResult } from './DataSectionBoundary.js';
+export type DataAppBaseProps = {
+    children: ReactNode;
+    dataContext: DataContext;
+    /** Override the declared subtitle; null hides it. */
+    description?: ReactNode;
+    toolbarActions?: ReactNode;
+    footerActions?: ReactNode;
+};
+export type DataAppRequest<Data, Input> = SectionResult<Data, Input> & {
+    queries?: DisclosedQuery[];
+    /** Actual request activity, including retries with retained data. */
+    refreshing?: boolean;
+    cancel?: () => unknown;
+    controls?: ReactNode;
+};
+export type StaticDataAppProps = DataAppBaseProps & {
+    csvExport?: CsvExport;
+    queries?: DisclosedQuery[];
+};
+export type DataAppProps<Data = unknown, Input = unknown> = (DataAppBaseProps & {
+    request: DataAppRequest<Data, Input>;
+    /** Findings are always derived from the result currently visible to the reader. */
+    story: BoundStory<Data, Input>;
+    /** Export every distinct dataset in the displayed result. */
+    csvExport: (snapshot: DisplayedSnapshot<Data, Input>) => CsvExport;
+    queries?: never;
+}) | (StaticDataAppProps & {
+    request?: never;
+    story?: never;
+});
+/** Owns the page title, header, gutter, and width; body content uses section headings.
+ * The primary request binds the toolbar, controls, refresh, and inspection.
+ * Children always render; compose DataSection boundaries around independently loading content. */
+export declare function DataAppFrame<Data, Input>(props: DataAppProps<Data, Input>): import("react").JSX.Element;

package/dist/types/react/ui/DataBoundary.d.ts

@@ -2,14 +2,13 @@ import type { ComponentPropsWithRef, ReactNode } from 'react';
 import type { DataView } from '../../core/data-view.js';
 export type DataBoundaryProps<T, Input = unknown> = {
     view: DataView<T, Input>;
-    loading: ReactNode;
-    empty: ReactNode;
+    loadingFallback: ReactNode;
+    emptyFallback: ReactNode;
     error: (error: Error) => ReactNode;
     staleError?: (error: Error) => ReactNode;
     notice?: 'inline' | 'none';
-    dimOnUpdate?: boolean;
     children: (data: T, displayedInput: Input) => ReactNode;
 } & Omit<ComponentPropsWithRef<'div'>, 'children'>;
 /** Render one request state at a time. Prior content remains readable during an update.
- * Local boundaries can opt into an inline notice and delayed dimming. */
-export declare function DataBoundary<T, Input>({ view, loading, empty, error, staleError, notice, dimOnUpdate, children, className, ...props }: DataBoundaryProps<T, Input>): import("react").JSX.Element;
+ * Feedback ownership is supplied by the containing section. */
+export declare function DataBoundary<T, Input>({ view, loadingFallback, emptyFallback, error, staleError, notice, children, className, ...props }: DataBoundaryProps<T, Input>): import("react").JSX.Element;

package/dist/types/react/ui/DataSection.d.ts

@@ -1,26 +1,14 @@
-import type { ComponentPropsWithRef, ReactNode } from 'react';
-import type { DataView } from '../../core/data-view.js';
+import { type ViewContent } from '../content.js';
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
 import type { EmptyContent } from './presentation.js';
-export type SectionResult<Data, Input> = {
-    view: DataView<Data, Input>;
-    refetch: () => unknown;
-};
 export type DataSectionProps<Data, Input = unknown> = {
-    result: SectionResult<Data, Input>;
-    empty: EmptyContent;
-    children: (data: Data, displayedInput: Input) => ReactNode;
-    /** Placeholder layout for an initial request; use the ready view's grid without copied values. */
-    loading?: ReactNode;
+    content: ViewContent<Data, Input>;
+    emptyFallback?: EmptyContent;
     error?: {
         title: ReactNode;
         description?: ReactNode;
         onRetry?: () => void;
     };
     label?: string;
-    /** DataApp suppresses this local notice in favor of its page-level toast. */
-    notice?: 'inline' | 'none';
-    dimOnUpdate?: boolean;
-} & Omit<ComponentPropsWithRef<'div'>, 'children'>;
-/** One request boundary for any number of cards. `DataBoundary` exposes the lower-level
- * view-state slots for custom composition. */
-export declare function DataSection<Data, Input>({ result, children, empty, loading, error, label, notice, dimOnUpdate, ...props }: DataSectionProps<Data, Input>): import("react").JSX.Element;
+} & Omit<ComponentPropsWithRef<'div'>, 'children' | 'content'>;
+export declare function DataSection<Data, Input>({ content, ...presentation }: DataSectionProps<Data, Input>): import("react").JSX.Element;

package/dist/types/react/ui/DataSectionBoundary.d.ts

@@ -0,0 +1,30 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+import type { DataView } from '../../core/data-view.js';
+import type { EmptyContent } from './presentation.js';
+export type SectionResult<Data, Input> = {
+    view: DataView<Data, Input>;
+    refetch: () => unknown;
+};
+export type DataSectionProps<Data, Input = unknown> = {
+    children: (data: Data, displayedInput: Input) => ReactNode;
+    /** Placeholder layout for an initial request; use the ready view's grid without copied values. */
+    loadingFallback: ReactNode;
+    error?: {
+        title: ReactNode;
+        description?: ReactNode;
+        onRetry?: () => void;
+    };
+    label?: string;
+    notice?: 'none' | 'inline';
+} & ({
+    result: SectionResult<Data, Input> & {
+        emptyFallback: EmptyContent;
+    };
+    emptyFallback?: EmptyContent;
+} | {
+    result: SectionResult<Data, Input>;
+    emptyFallback: EmptyContent;
+}) & Omit<ComponentPropsWithRef<'div'>, 'children'>;
+/** One request boundary for any number of cards. `DataBoundary` exposes the lower-level
+ * view-state slots internally. The primary DataApp request uses page-level feedback. */
+export declare function DataSectionBoundary<Data, Input>({ result, children, emptyFallback, loadingFallback, error, label, notice: feedback, ...props }: DataSectionProps<Data, Input>): import("react").JSX.Element;

package/dist/types/react/ui/DataValue.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+import type { DataReading } from '../../core/reading.js';
+export type DataValueProps<Value> = {
+    reading: DataReading<Value>;
+    loadingFallback: ReactNode;
+    children: (value: Value) => ReactNode;
+} & Omit<ComponentPropsWithRef<'span'>, 'children'>;
+/** Bind inline content to displayed data. Keep static wording outside this span. */
+export declare function DataValue<Value>({ reading, loadingFallback, children, ...props }: DataValueProps<Value>): import("react").JSX.Element;

package/dist/types/react/ui/DataWidget.d.ts

@@ -4,6 +4,7 @@ import type { EmptyContent, BoundWidgetReading } from './presentation.js';
 import type { WidgetEvidence } from './WidgetEvidence.js';
 type DataWidgetBaseProps = {
     title: ReactNode;
+    annotationId?: string;
     count?: number;
     description?: ReactNode;
     evidence?: WidgetEvidence;
@@ -22,7 +23,7 @@ export type DataWidgetProps<Data = unknown> = DataWidgetBaseProps & ((BoundWidge
     reading?: never;
     isEmpty?: never;
     skeleton?: never;
-    empty?: EmptyContent;
+    emptyFallback?: EmptyContent;
     children: ReactNode;
 });
 export declare function DataWidget<Data>(props: DataWidgetProps<Data>): import("react").JSX.Element;

package/dist/types/react/ui/DateTimeTooltip.d.ts

@@ -6,4 +6,4 @@ export type DateTimeTooltipProps = {
     children?: ReactNode;
 } & Omit<HelpPopoverProps, 'trigger' | 'triggerLabel' | 'label' | 'children'>;
 /** Pass the viewer's account time zone when known; the popover also exposes UTC and Unix time. */
-export declare function DateTimeTooltip({ date, timeZone, children, triggerClassName, panelClassName, ...props }: DateTimeTooltipProps): import("react").JSX.Element;
+export declare function DateTimeTooltip({ date, timeZone, children, panelProps, ...props }: DateTimeTooltipProps): import("react").JSX.Element;

package/dist/types/react/ui/DimensionPicker.d.ts

@@ -1,5 +1,5 @@
 import type { DimensionOption, DimensionSelection, DimensionValue, DimensionVariable } from '../../core/dimension.js';
-/** Adapts the typed dimension contract to the shared Combobox control. */
+/** Adapts the typed dimension contract to the shared ChoicePicker control. */
 export declare function DimensionPicker<T extends DimensionValue>({ filter, value, onChange, options: suppliedOptions, loading, error, onRetry, }: {
     filter: DimensionVariable<T>;
     value: DimensionSelection<T>;

package/dist/types/react/ui/ExportControl.d.ts

@@ -1,4 +1,4 @@
 import { type CsvExport } from './csv-export.js';
 export declare function ExportControl({ csv }: {
-    csv: CsvExport;
+    csv?: CsvExport;
 }): import("react").JSX.Element;

package/dist/types/react/ui/FilterActions.d.ts

@@ -0,0 +1,10 @@
+export type FilterActionsProps = {
+    onClear?: () => void;
+} & ({
+    onApply: () => void;
+    onCancel: () => void;
+} | {
+    onApply?: never;
+    onCancel?: never;
+});
+export declare function FilterActions({ onClear, onApply, onCancel, }: FilterActionsProps): import("react").JSX.Element;

package/dist/types/react/ui/FilterBar.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentPropsWithRef } from 'react';
+export type FilterBarProps = ComponentPropsWithRef<'div'>;
+export declare function FilterBar({ className, role, 'aria-label': label, ...props }: FilterBarProps): import("react").JSX.Element;

package/dist/types/react/ui/GettingStarted.d.ts

@@ -1,8 +1,6 @@
-import type { DataAppConfig } from '../../core/config.js';
 import type { DataContext } from './data-context.js';
 /** Query-backed connection state and next steps for a newly created app. Mount within
- * `DataAppProvider` and register `connection: connectionCheck()` on the server. */
-export declare function GettingStarted({ config, dataContext, }: {
-    config: DataAppConfig;
+ * `DataAppProvider` and register `connection: connectionCheck(app.queries)` on the server. */
+export declare function GettingStarted({ dataContext }: {
     dataContext: DataContext;
 }): import("react").JSX.Element;

package/dist/types/react/ui/HelpPopover.d.ts

@@ -1,14 +1,13 @@
 import { type ComponentPropsWithRef, type ReactNode, type RefObject } from 'react';
 import { type Placement } from '@floating-ui/react';
-export type HelpPopoverTriggerProps = Omit<ComponentPropsWithRef<'button'>, 'children' | 'type'>;
+import type { DataAppStyleHooks } from '../style-contract.js';
+export type HelpPopoverTriggerProps = Omit<ComponentPropsWithRef<'button'>, 'children' | 'type'> & DataAppStyleHooks;
 export type HelpPopoverPanelProps = Omit<ComponentPropsWithRef<'section'>, 'children' | 'role'>;
 export type HelpPopoverProps = {
     trigger: ReactNode;
     triggerLabel: string;
     label: string;
     children: ReactNode;
-    triggerClassName?: string;
-    panelClassName?: string;
     placement?: Placement;
     portalRoot?: RefObject<HTMLElement | null>;
     triggerProps?: HelpPopoverTriggerProps;
@@ -19,4 +18,4 @@ export type HelpPopoverProps = {
 /** A supplemental explanation that opens on click, Enter, or a deliberate mouse hover. Tabbing
  * past the trigger does not open it, and a click keeps a hover-opened panel in place.
  * triggerProps and panelProps target its two surfaces. */
-export declare function HelpPopover({ trigger, triggerLabel, label, children, triggerClassName, panelClassName, portalRoot, triggerProps, panelProps, placement, open: openProp, onOpenChange, }: HelpPopoverProps): import("react").JSX.Element;
+export declare function HelpPopover({ trigger, triggerLabel, label, children, portalRoot, triggerProps, panelProps, placement, open: openProp, onOpenChange, }: HelpPopoverProps): import("react").JSX.Element;

package/dist/types/react/ui/InspectionContext.d.ts

@@ -1,8 +1,10 @@
+import type { DataView } from '../../core/data-view.js';
 import type { DisclosedQuery } from '../../core/contract.js';
 import type { AboutEmpty } from './AboutData.js';
 import type { DataContext } from './data-context.js';
 export type InspectionDefaults = {
     dataContext: DataContext;
+    primaryView?: DataView<unknown, unknown>;
     empty?: AboutEmpty;
     queries?: DisclosedQuery[];
 };

package/dist/types/react/ui/InspectionProvider.d.ts

@@ -0,0 +1,29 @@
+import { type ReactNode, type RefObject } from 'react';
+import { type AboutDataProps, type AboutTab } from './AboutData.js';
+type Inspection = {
+    key: string;
+    id: string;
+    props: AboutDataProps;
+    trigger: RefObject<HTMLButtonElement | null>;
+};
+type Selection = {
+    inspection: Inspection;
+    open: boolean;
+    tab: AboutTab;
+} | null;
+export declare const InspectionOwner: import("react").Context<{
+    subscribe(this: void, listener: () => void): () => void;
+    snapshot: () => Selection;
+    sync: () => void;
+    register(inspection: Inspection): void;
+    remove(key: string): void;
+    open(inspection: Inspection): void;
+    close(key: string): void;
+    controlled(inspection: Inspection, open: boolean | undefined): void;
+    selectTab(this: void, tab: AboutTab): void;
+} | null>;
+export declare const InspectionVisual: import("react").Context<boolean>;
+export declare function InspectionProvider({ children }: {
+    children: ReactNode;
+}): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | Iterable<ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | null | undefined;
+export {};

package/dist/types/react/ui/LineChart.d.ts

@@ -0,0 +1,7 @@
+import type { ChartItem, ValueChartProps } from './chart-data.js';
+export type LineChartItem = ChartItem;
+export type LineChartProps = ValueChartProps;
+/** Equally spaced finite samples in supplied order; fill missing periods explicitly.
+ * Supports negative values, single points, and horizontal scrolling for long series.
+ * Compose inside VisualizationWidget; hover/touch tooltips need no caller state. */
+export declare function LineChart(props: LineChartProps): import("react").JSX.Element;

package/dist/types/react/ui/Menu.d.ts

@@ -0,0 +1,12 @@
+import type { ComponentPropsWithRef } from 'react';
+import { MenuTrigger, MenuSection, Popover, Separator, type MenuProps, type MenuItemProps, type MenuTriggerProps } from 'react-aria-components';
+export { MenuTrigger, MenuSection };
+export { PressButton as MenuButton } from './Button.js';
+export type { MenuProps, MenuItemProps, MenuTriggerProps };
+export type MenuPopoverProps = ComponentPropsWithRef<typeof Popover>;
+/** Anchored popup for a Menu; the surrounding MenuTrigger owns focus and dismissal. */
+export declare function MenuPopover({ className, placement, ...props }: MenuPopoverProps): import("react").JSX.Element;
+/** Actions by default; single selection creates radio items, multiple creates checkbox items. */
+export declare function Menu<T extends object>({ className, ...props }: MenuProps<T>): import("react").JSX.Element;
+export declare function MenuItem<T extends object>({ className, children, ...props }: MenuItemProps<T>): import("react").JSX.Element;
+export declare function MenuSeparator({ className, ...props }: ComponentPropsWithRef<typeof Separator>): import("react").JSX.Element;

package/dist/types/react/ui/MetricWidget.d.ts

@@ -1,17 +1,17 @@
 import type { ComponentPropsWithRef, ReactNode } from 'react';
-import { type WidgetStatus } from './RequestHint.js';
+import type { WidgetStatus } from './RequestHint.js';
 import type { WidgetEvidence } from './WidgetEvidence.js';
-import { type MetricComparison } from './comparison.js';
+import { type MetricComparison } from './metric-comparison.js';
 import { type MetricFormat } from '../../core/format.js';
 import type { MetricReading } from '../../core/reading.js';
 import { type MetricDefinition } from './metric.js';
 type MetricWidgetBaseProps = {
     label: string;
+    annotationId?: string;
     description?: ReactNode;
     comparison?: MetricComparison;
     evidence?: WidgetEvidence;
     action?: ReactNode;
-    insight?: ReactNode;
     status?: WidgetStatus;
     visual?: ReactNode;
 } & Omit<ComponentPropsWithRef<'div'>, 'about' | 'children'>;
@@ -31,6 +31,7 @@ type UnboundMetricWidgetProps = MetricWidgetBaseProps & ({
     value?: never;
     format?: never;
 })));
+/** VisualizationWidget with a formatted metric, optional comparison, and evidence. */
 export type MetricWidgetProps = UnboundMetricWidgetProps | (Omit<MetricWidgetBaseProps, 'label' | 'comparison' | 'evidence'> & {
     metric: MetricDefinition;
     reading: MetricReading;

package/dist/types/react/ui/NumberField.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentPropsWithRef } from 'react';
+import { NumberField as AriaNumberField } from 'react-aria-components';
+export type NumberFieldProps = Omit<ComponentPropsWithRef<typeof AriaNumberField>, 'value' | 'onChange' | 'className'> & {
+    label: string;
+    value: number | null;
+    onChange: (value: number | null) => void;
+    className?: string;
+};
+/** Localized numeric entry. Empty input is null rather than zero. */
+export declare function NumberField({ label, value, onChange, className, ...props }: NumberFieldProps): import("react").JSX.Element;
+export type NumberRange = {
+    min?: number;
+    max?: number;
+};
+export type NumberRangeFieldProps = {
+    label: string;
+    value: NumberRange;
+    onChange: (value: NumberRange) => void;
+    /** Reports whether the current draft interval can be committed. */
+    onValidityChange?: (valid: boolean) => void;
+    min?: number;
+    max?: number;
+    disabled?: boolean;
+    className?: string;
+};
+/** Commit valid intervals; retain invalid draft bounds so users can correct them. */
+export declare function NumberRangeField({ label, value, onChange, onValidityChange, min, max, disabled, className, }: NumberRangeFieldProps): import("react").JSX.Element;

package/dist/types/react/ui/NumberFilterPicker.d.ts

@@ -0,0 +1,9 @@
+import { type NumberFilter, type NumberSelection } from '../../core/filters.js';
+export type NumberFilterPickerProps = {
+    filter: NumberFilter;
+    value: NumberSelection;
+    onChange: (value: NumberSelection) => void;
+    disabled?: boolean;
+};
+/** Edit a numeric predicate in a panel. Apply commits one complete value; dismissing discards the draft. */
+export declare function NumberFilterPicker({ filter, value, onChange, disabled, }: NumberFilterPickerProps): import("react").JSX.Element;

package/dist/types/react/ui/PieChart.d.ts

@@ -0,0 +1,11 @@
+import type { ChartItem, ValueChartProps } from './chart-data.js';
+export type PieChartItem = ChartItem;
+export type PieChartProps = ValueChartProps & {
+    /** Omit the built-in key when composing a separate ChartLegend. */
+    showLegend?: boolean;
+};
+/** Nonnegative, mutually exclusive parts; shares use the sum of supplied items.
+ * Include Other to represent the whole. Zero values remain in the legend; all-zero
+ * data shows an empty circle. Colors follow item order. Compose inside VisualizationWidget;
+ * hover/touch tooltips coordinate slice and legend emphasis without caller state. */
+export declare function PieChart({ items, unit, ariaLabel, showLegend, formatValue, }: PieChartProps): import("react").JSX.Element;

package/dist/types/react/ui/PresentStory.d.ts

@@ -20,14 +20,11 @@ export type PresentStoryProps = {
     scope?: ReactNode;
     dataContext: DataContext;
     theme?: ThemeController;
-    launcherProps?: Omit<ComponentPropsWithRef<'span'>, 'children'>;
-    dialogProps?: Omit<ComponentPropsWithRef<'dialog'>, 'children' | 'aria-labelledby' | 'open'>;
     headerActions?: ReactNode;
     footer?: ReactNode;
 } & Omit<ComponentPropsWithRef<'button'>, 'title'>;
 /**
  * Uses an already loaded snapshot. Navigation is stored in `?present=1&step=`, and step
- * inspection uses `?about=`. `launcherProps` targets the outer span; `dialogProps` targets the
- * modal.
+ * inspection uses `?about=`. The presentation owns its modal structure.
  */
-export declare function PresentStory({ title, findings, empty, scope, dataContext, theme, launcherProps, dialogProps, headerActions, footer, children, className, onClick, disabled, ref, ...props }: PresentStoryProps): import("react").JSX.Element;
+export declare function PresentStory({ title, findings, empty, scope, dataContext, theme, headerActions, footer, children, className, onClick, disabled, ref, ...props }: PresentStoryProps): import("react").JSX.Element;

package/dist/types/react/ui/RadioGroup.d.ts

@@ -0,0 +1,18 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+import { RadioGroup as AriaRadioGroup, Radio as AriaRadio } from 'react-aria-components';
+import { type ChoiceOption } from '../../core/variables.js';
+export type RadioGroupProps = Omit<ComponentPropsWithRef<typeof AriaRadioGroup>, 'className' | 'children'> & {
+    children: ReactNode;
+    label: string;
+    className?: string;
+};
+export declare function RadioGroup({ label, className, children, ...props }: RadioGroupProps): import("react").JSX.Element;
+export type RadioProps = Omit<ComponentPropsWithRef<typeof AriaRadio>, 'className'> & {
+    className?: string;
+};
+export declare function Radio({ className, children, ...props }: RadioProps): import("react").JSX.Element;
+export type SegmentedControlProps = Omit<RadioGroupProps, 'children'> & {
+    options: readonly ChoiceOption[];
+};
+/** A compact radio group; arrow keys follow standard radio selection behavior. */
+export declare function SegmentedControl({ options, className, ...props }: SegmentedControlProps): import("react").JSX.Element;

package/dist/types/react/ui/RefreshControl.d.ts

@@ -3,8 +3,7 @@ export type RefreshControlProps = {
     refreshing: boolean;
     children: ReactNode;
     label?: string;
-    statusProps?: Omit<ComponentPropsWithRef<'div'>, 'children' | 'role'>;
     status?: ReactNode;
 } & Omit<ComponentPropsWithRef<'div'>, 'children'>;
 /** Show refresh progress just before its action after a short delay. */
-export declare function RefreshControl({ refreshing, children, label, statusProps, status, className, ...props }: RefreshControlProps): import("react").JSX.Element;
+export declare function RefreshControl({ refreshing, children, label, status, className, ...props }: RefreshControlProps): import("react").JSX.Element;

package/dist/types/react/ui/ScatterChart.d.ts

@@ -0,0 +1,17 @@
+import type { ScatterChartItem } from './chart-data.js';
+export type { ScatterChartItem } from './chart-data.js';
+export type ScatterChartProps = {
+    items: readonly ScatterChartItem[];
+    xLabel: string;
+    yLabel: string;
+    xUnit: string;
+    yUnit: string;
+    ariaLabel: string;
+    formatX?: (value: number) => string;
+    formatY?: (value: number) => string;
+};
+/** Independent finite X/Y observations on linear axes that include zero.
+ * Negative and constant coordinates are supported. Axis labels and units describe
+ * tooltips as well as the plot; formatX/formatY format ticks and tooltip values.
+ * Compose inside VisualizationWidget; hover/touch tooltips need no caller state. */
+export declare function ScatterChart({ items, xLabel, yLabel, xUnit, yUnit, ariaLabel, formatX, formatY, }: ScatterChartProps): import("react").JSX.Element;

package/dist/types/react/ui/SearchField.d.ts

@@ -12,11 +12,10 @@ export type SearchFieldProps = {
     busy?: boolean;
     resetValue?: string;
     inputProps?: Omit<ComponentPropsWithRef<'input'>, 'type' | 'value' | 'children'>;
-    clearButtonProps?: Omit<ComponentPropsWithRef<'button'>, 'type' | 'children'>;
     children?: ReactNode;
 } & Omit<ComponentPropsWithRef<'form'>, 'onChange' | 'onSubmit' | 'children'>;
 /**
  * The caller owns filtering, URL state, and whether search runs while typing or on submit.
  * Escape and Clear reset the query.
  */
-export declare function SearchField({ label, value, onChange, onSubmit, placeholder, showLabel, size, description, status, busy, resetValue, inputProps, clearButtonProps, children, className, ...props }: SearchFieldProps): import("react").JSX.Element;
+export declare function SearchField({ label, value, onChange, onSubmit, placeholder, showLabel, size, description, status, busy, resetValue, inputProps, children, className, ...props }: SearchFieldProps): import("react").JSX.Element;

package/dist/types/react/ui/SearchInput.d.ts

@@ -1,7 +1,9 @@
 import type { ComponentPropsWithRef, ReactNode } from 'react';
 /** One search control surface for picker search and table/page search. */
-export declare function SearchInput({ size, endAction, loading, className, onKeyDown, ...props }: Omit<ComponentPropsWithRef<'input'>, 'size' | 'children'> & {
+export declare function SearchInput({ focusRing, size, endAction, loading, className, ...props }: Omit<ComponentPropsWithRef<'input'>, 'size' | 'children'> & {
     size?: 'default' | 'compact';
+    /** Picker search delegates focus indication to the active option. */
+    focusRing?: boolean;
     endAction?: ReactNode;
     /** Replaces the search glyph in its existing space; input and results remain usable. */
     loading?: boolean;

package/dist/types/react/ui/Select.d.ts

@@ -0,0 +1,14 @@
+import { type ChoiceOption } from '../../core/variables.js';
+export type SelectProps = {
+    label: string;
+    options: readonly ChoiceOption[];
+    value: string;
+    onChange: (value: string) => void;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    id?: string;
+    className?: string;
+};
+/** Labeled single selection with keyboard navigation and a styled listbox. */
+export declare function Select({ label, options, value, onChange, disabled, required, className, ...props }: SelectProps): import("react").JSX.Element;

package/dist/types/react/ui/SelectionMark.d.ts

@@ -1,4 +1,5 @@
 /** Decorative selection indicator; the containing control owns its accessible semantics. */
-export declare function SelectionMark({ selected }: {
+export declare function SelectionMark({ selected, multiple, }: {
     selected: boolean;
+    multiple?: boolean;
 }): import("react").JSX.Element;

package/dist/types/react/ui/Sheet.d.ts

@@ -9,10 +9,11 @@ export type SheetProps = {
     headerActions?: ReactNode;
     footer?: ReactNode;
     wide?: boolean;
+    placement?: 'side' | 'center';
     returnFocus?: RefObject<HTMLElement | null>;
 } & SheetDialogProps;
 /**
  * Uses the native dialog top layer and focus trap. Closing keeps the modal mounted until its
  * exit transition completes.
  */
-export declare function Sheet({ open, onOpenChange, title, description, children, headerActions, footer, wide, returnFocus, className, onCancel, onClose, onClick, onTransitionEnd, ref, ...props }: SheetProps): import("react").JSX.Element;
+export declare function Sheet({ open, onOpenChange, title, description, children, headerActions, footer, wide, placement, returnFocus, className, onCancel, onClose, onClick, onTransitionEnd, ref, ...props }: SheetProps): import("react").JSX.Element;

package/dist/types/react/ui/Skeleton.d.ts

@@ -1,5 +1,8 @@
 import type { ComponentPropsWithRef } from 'react';
-export type SkeletonProps = Omit<ComponentPropsWithRef<'span'>, 'children' | 'aria-hidden'>;
+export type SkeletonProps = Omit<ComponentPropsWithRef<'span'>, 'children' | 'aria-hidden'> & {
+    /** Align a text-sized placeholder with surrounding prose. */
+    inline?: boolean;
+};
 /** Decorative loading placeholder that fades in only when loading takes a moment.
  * Put the accessible status on its container. */
-export declare function Skeleton({ className, ...props }: SkeletonProps): import("react").JSX.Element;
+export declare function Skeleton({ inline, className, ...props }: SkeletonProps): import("react").JSX.Element;

package/dist/types/react/ui/StaticDataApp.d.ts

@@ -0,0 +1,4 @@
+import { type StaticDataAppProps } from './DataAppFrame.js';
+export type DataAppProps = StaticDataAppProps;
+/** Setup and static screens; fetched data uses the declared-view DataApp. */
+export declare function DataApp(props: DataAppProps): import("react").JSX.Element;