udi-yac 0.2.3 → 0.3.0

package/dist/src/app/ErrorBoundary.d.ts

@@ -14,6 +14,6 @@ export declare class ErrorBoundary extends Component<Props, State> {
     private handleCopy;
     private handleReset;
     private handleExport;
-    render(): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import('react').ReactPortal | import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null | undefined;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import('react').ReactPortal | import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
 }
 export {};

package/dist/src/app/UDIChatConfig.d.ts

@@ -19,6 +19,15 @@ export type TrackerFn = (name: string, properties?: Record<string, unknown>) =>
  */
 export interface UDIChatConfig {
     apiBaseUrl: string;
+    /**
+     * Name of a server-side data package (configured on the agent server's
+     * query backends). When set, the chat fetches introspected metadata from
+     * GET /v1/yac/metadata and routes all data queries through
+     * POST /v1/yac/query — no CSVs are loaded into the browser, and
+     * cross-filtering becomes non-interactive (commit on mouse-up with a
+     * loading overlay). Takes precedence over `dataPackage`/`dataPackagePath`.
+     */
+    remotePackage?: string;
     /** URL to fetch a datapackage_udi.json from. Ignored when `dataPackage` is provided. */
     dataPackagePath?: string;
     /** Provide a DataPackage object directly instead of fetching from a URL. Takes precedence over `dataPackagePath`. */

package/dist/src/app/validateConfig.d.ts

@@ -1,14 +1,2 @@
 import { UDIChatConfig } from '../../app/UDIChatConfig';
-/**
- * Lightweight runtime validation for the UDIChatConfig shape.
- *
- * Catches the most common consumer mistakes (missing apiBaseUrl, malformed
- * URL, no data source provided, malformed DataPackage) before they fail deep
- * inside Arquero or fetch with opaque stack traces. Errors are thrown so the
- * surrounding ErrorBoundary renders a useful message.
- *
- * This is intentionally NOT a full schema validator — it covers the failure
- * modes we've actually seen in practice. If a field has a bad type that React
- * itself will surface clearly, we don't duplicate that check here.
- */
 export declare function validateConfig(config: UDIChatConfig): void;

package/dist/src/components/FieldTooltipContent.d.ts

@@ -0,0 +1,12 @@
+interface FieldTooltipContentProps {
+    field: string;
+    dataType?: string | undefined;
+    description?: string | undefined;
+}
+/**
+ * The hover card for a data-package field: its name, its `udi:data_type`, and
+ * its description. Shared by the chat's field chips and the data overview's
+ * field list so a field looks the same wherever it is hovered.
+ */
+export declare function FieldTooltipContent({ field, dataType, description }: FieldTooltipContentProps): import("react").JSX.Element;
+export {};

package/dist/src/components/ui/accordion.d.ts

@@ -1,6 +1,13 @@
 import { Accordion as AccordionPrimitive } from '@base-ui/react/accordion';
 declare function Accordion({ className, ...props }: AccordionPrimitive.Root.Props): import("react").JSX.Element;
 declare function AccordionItem({ className, ...props }: AccordionPrimitive.Item.Props): import("react").JSX.Element;
-declare function AccordionTrigger({ className, children, ...props }: AccordionPrimitive.Trigger.Props): import("react").JSX.Element;
+declare function AccordionTrigger({ className, headerClassName, children, ...props }: AccordionPrimitive.Trigger.Props & {
+    /**
+     * Applied to the wrapping `<Header>` rather than the trigger button. Lets a
+     * consumer make the header `sticky` — which has to sit on the header, since
+     * the button is a flex child of it.
+     */
+    headerClassName?: string;
+}): import("react").JSX.Element;
 declare function AccordionContent({ className, children, ...props }: AccordionPrimitive.Panel.Props): import("react").JSX.Element;
 export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };

package/dist/src/features/chat/components/BrushFilterWidgets.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Renders an adjustment widget in the chat for each active visualization brush
+ * filter. Each one is presented like an LLM-originated `FilterData` filter, so
+ * a brush filter reads as a chat message. Brush selections live in the shared
+ * Pinia store (mirrored into `dataFiltersStore.internalDataSelections`), not
+ * the conversation, so these never leak into the LLM message history.
+ */
+export declare function BrushFilterWidgets(): import("react").JSX.Element | null;

package/dist/src/features/dashboard/components/VizTweakComponent.types.d.ts

@@ -5,9 +5,18 @@
  * introspect without depending on the full upstream type graph.
  */
 export interface TweakableParam {
+    /** Value shown in the dropdown: the source field (field/dimension) or, for a
+     * measure, the rollup's input field. */
     field: string;
     encoding: string;
     options: string[];
+    /** How a swap is applied:
+     *  - 'field': plain encoding rewrite (setMappingFieldByEncoding)
+     *  - 'dimension': group-by field, rewrite encoding + groupby (swapDimensionField)
+     *  - 'measure': aggregated rollup input, rewrite via swapMeasureField */
+    kind: 'field' | 'dimension' | 'measure';
+    /** For 'measure': the rollup output column the encoding is bound to. */
+    outputKey?: string;
 }
 export interface MappingLike {
     field?: string;

package/dist/src/features/dashboard/hooks/useBrushFilters.d.ts

@@ -0,0 +1,45 @@
+import { DataSelection, DataSelections } from '../stores/dataFiltersStore';
+import { ActiveVisualization } from '../stores/dashboardStore';
+export interface BrushFilter {
+    /** Stable identity for chips/widgets and per-filter clearing: the viz uuid
+     *  for interval brushes, `${uuid}::${field}` for point selections (which
+     *  are split into one filter per field). */
+    id: string;
+    /** Selection key — the source visualization's uuid. */
+    uuid: string;
+    /** Dashboard key of the source visualization (for remount/hover coordination). */
+    vizKey: string;
+    /** Human-readable label for the source visualization. */
+    title: string;
+    /** For point selections: the single field this filter covers. Edits and
+     *  clears must merge back into the uuid's full multi-field selection. */
+    field?: string;
+    /** For point filters, narrowed to `field`; the full selection for interval. */
+    selection: DataSelection;
+}
+/**
+ * Whether a brush selection currently constrains anything. An interval brush
+ * always has a range; a point brush with every value unchecked is "present but
+ * empty" — its widget should persist for re-selection, but it shouldn't render
+ * a (valueless) toolbar chip.
+ */
+export declare function brushHasValue(selection: DataSelection): boolean;
+/**
+ * Pure derivation of brush filters from the store's `internalDataSelections`
+ * (brush/click selections mirrored out of the shared Pinia DataSourcesStore,
+ * keyed by the source viz's uuid) + the active visualizations. Gated to
+ * currently-active vizzes so a closed viz's stale selection never shows, and
+ * to a present (non-null) selection. A point brush whose values are all
+ * unchecked is kept so its chat widget persists; callers that only want
+ * value-carrying filters (e.g. the toolbar) filter with `brushHasValue`.
+ * Exported for unit testing.
+ */
+export declare function selectBrushFilters(internalSelections: DataSelections, activeVisualizations: Map<string, ActiveVisualization>): BrushFilter[];
+/**
+ * Brush/click selections created by interacting with a visualization are
+ * mirrored into `dataFiltersStore.internalDataSelections` (keyed by the source
+ * viz's uuid) by `DashboardCard`'s selection handler. This hook surfaces them
+ * as first-class filters for the filter toolbar and the chat adjustment
+ * widgets.
+ */
+export declare function useBrushFilters(): BrushFilter[];

package/dist/src/features/dashboard/hooks/useBrushFilters.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/features/dashboard/index.d.ts

@@ -7,4 +7,5 @@ export { VizTweakComponent } from './components/VizTweakComponent';
 export { createDashboardStore, extractAllUdiSpecsFromMessage, type DashboardState, type ActiveVisualization, } from './stores/dashboardStore';
 export { createDataFiltersStore, extractFilterSpecFromMessage, messageFilterKeyWithToolCall, messageFilterKey, type DataFiltersState, type DataSelection, type DataSelections, } from './stores/dataFiltersStore';
 export { createMemoryBankStore, type MemoryBankState } from './stores/memoryBankStore';
+export { useBrushFilters, selectBrushFilters, brushHasValue, type BrushFilter, } from './hooks/useBrushFilters';
 export type { DownloadAction, DownloadActionContext, EntityIconComponent, EntityIconMap, } from './types';

package/dist/src/features/dashboard/utils/relevantTableMapping.d.ts

@@ -0,0 +1,21 @@
+import { UDIGrammar } from 'udi-toolkit/react';
+interface RowMappingEntry {
+    encoding: 'text';
+    mark: 'text';
+    field: string;
+    type: 'quantitative' | 'ordinal' | 'nominal';
+}
+/**
+ * Build the "relevant fields" row mapping for a visualization's table view:
+ * the entity's key columns (primary/foreign/unique) followed by the fields
+ * the chart maps — e.g. a donor height×weight scatterplot tables as
+ * [uuid, hubmap_id, height, weight] instead of all 40+ columns.
+ *
+ * Key columns are omitted when the pipeline aggregates (rollup/kde): the
+ * output rows are groups, not entities, so key columns don't exist there.
+ *
+ * Returns null when nothing useful can be derived (no represented fields) —
+ * callers fall back to the all-fields default (`field: '*'`).
+ */
+export declare function buildRelevantRowMapping(spec: UDIGrammar, keyFields: string[]): RowMappingEntry[] | null;
+export {};

package/dist/src/features/dashboard/utils/relevantTableMapping.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/features/dashboard/utils/tweakability.d.ts

@@ -1,20 +1,37 @@
 import { UDIGrammar } from 'udi-toolkit/react';
+import { TweakableParam } from '../components/VizTweakComponent.types';
+type FieldMap = Record<string, string[]> | null;
 /**
- * Returns true if the spec has at least one mapping whose field could
- * be swapped via the tweak UI — a complete mapping (field + encoding +
- * type) bound to a real source field, not locked by a schema-defining
- * transformation (groupby / binby / kde / rollup.field / join.on), and
- * not a duplicate encoding within the same spec.
+ * Compute the tweakable parameters for a spec — the single source of truth
+ * shared by VizTweakComponent (renders one dropdown per param) and
+ * hasTweakableFields (gates the gear button). Keeping both on this function
+ * means the panel and the gate can't drift.
  *
- * DashboardCard calls this to decide whether the tweak-toggle button
- * is actionable; without it the user could open a panel that just
- * silently rendered `null` (count-of-groupby charts, binned / kde over
- * locked fields, etc.). Keeping the check in lockstep with
- * VizTweakComponent's `tweakableParams` memo means we won't drift if
- * the filter rules change there.
+ * Each representation mapping (first per encoding, `row` marks skipped) is
+ * classified into one of three kinds:
+ *   - 'measure':   the mapping is bound to a rollup *output* column that has an
+ *                  input field (mean/sum/… — not count/frequency). The swap
+ *                  changes the aggregated input field; options are quantitative.
+ *   - 'dimension': the mapping field is a group-by dimension in the raw schema.
+ *                  The swap rewrites the groupby too; options are categorical.
+ *   - 'field':     a plain in-schema field, not locked, not aggregated. Options
+ *                  follow the mapping's type.
+ * Mappings referencing a locked field (binby/kde/join) or a derived column with
+ * no supported swap (e.g. a bare count output) are dropped.
  *
- * Lives in `utils/` rather than alongside VizTweakComponent so the
- * component file stays component-only — exporting non-component
- * helpers from a `.tsx` breaks react-refresh.
+ * The option-list maps may be null (e.g. hasTweakableFields only needs to know
+ * whether any param exists); in that case options come back empty.
+ */
+export declare function computeTweakableParams(spec: UDIGrammar, sourceFields: FieldMap, quantitativeSourceFields: FieldMap, categoricalSourceFields: FieldMap): TweakableParam[];
+/**
+ * Returns true if the spec has at least one tweakable parameter. DashboardCard
+ * calls this to decide whether the gear-toggle button is actionable — without
+ * it the user could open a panel that just rendered `null`. Option lists aren't
+ * needed to decide existence, so callers pass only `sourceFields`.
+ *
+ * Lives in `utils/` rather than alongside VizTweakComponent so the component
+ * file stays component-only — exporting non-component helpers from a `.tsx`
+ * breaks react-refresh.
  */
 export declare function hasTweakableFields(spec: UDIGrammar, sourceFields: Record<string, string[]> | null): boolean;
+export {};

package/dist/src/features/data-package/components/DataOverviewPanel.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Data Overview: what is actually in the loaded data package. One accordion
+ * item per entity (ranges for numeric fields, leading categories for
+ * categorical ones, relationships, and the rows left after active filters),
+ * below a tree of how the entities join.
+ *
+ * Everything comes from `dataPackageStore`, so it renders the same for
+ * CSV-backed and server-side (remote) packages.
+ */
+export declare function DataOverviewPanel(): import("react").JSX.Element;

package/dist/src/features/data-package/components/DataOverviewPanel.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/features/data-package/components/EntityOverview.d.ts

@@ -0,0 +1,10 @@
+interface EntityOverviewProps {
+    entity: string;
+}
+/**
+ * Body of one entity's accordion item: its foreign-key relationships, every
+ * field with its range or leading categories, and a table of the rows that
+ * survive the currently active filters.
+ */
+export declare function EntityOverview({ entity }: EntityOverviewProps): import("react").JSX.Element | null;
+export {};

package/dist/src/features/data-package/index.d.ts

@@ -3,5 +3,6 @@
  * must go through this barrel; intra-feature imports use relative paths.
  */
 export { createDataPackageStore, type DataPackageState, type LoadingPhase, } from './stores/dataPackageStore';
+export { DataOverviewPanel } from './components/DataOverviewPanel';
 export { joinDataPath } from './utils/joinDataPath';
 export { evaluateStructuredText, hasStructuredReferences, type StructuredTextSegment, } from './utils/structuredTextParser';

package/dist/src/features/data-package/stores/dataPackageStore.d.ts

@@ -14,12 +14,26 @@ export interface DataPackageState {
     /** Maps entity names to canonical data URLs (from udi:path + resource.path). */
     sourceResolver: Record<string, string>;
     filteredData: Map<string, ExportRowSet>;
+    /** False when the package is served by a remote query backend — live
+     *  (per-brush-tick) cross-filtering is unavailable; brushes commit on
+     *  mouse-up with a server round-trip. */
+    interactiveMode: boolean;
+    /** True while a remote batched query round-trip is in flight. */
+    remoteQueryPending: boolean;
     fetchDataPackage: (path: string, fetchOptions?: RequestInit) => Promise<void>;
+    /** Load a server-side package: fetches introspected metadata from
+     *  GET /v1/yac/metadata and routes all queries through POST /v1/yac/query
+     *  instead of loading CSVs into the browser. */
+    fetchRemotePackage: (apiBaseUrl: string, packageName: string, authToken?: string) => Promise<void>;
     setDataPackage: (dataPackage: DataPackage, precomputedDomains?: DataFieldDomain[], fetchOptions?: RequestInit) => Promise<void>;
     getDomainForField: (entity: string, field: string) => DataFieldDomain | undefined;
     isValidIntervalFilter: (entity: string, field: string) => ValidStatus;
     isValidPointFilter: (entity: string, field: string, values: unknown[]) => ValidStatus;
     getEntityRelationship: (originSource: string, targetSource: string) => EntityRelationship | null;
+    /** Key columns of an entity — primary key, foreign keys, and udi:unique
+     *  fields, in schema field order. Used by the table view's "relevant
+     *  fields" mode so rows stay identifiable. */
+    getKeyFields: (entity: string) => string[];
     setFilteredData: (entity: string, data: ExportRowSet) => void;
 }
 export declare function createDataPackageStore(): import('zustand').StoreApi<DataPackageState>;

package/dist/src/features/data-package/utils/entityOverview.d.ts

@@ -0,0 +1,136 @@
+import { DataFieldDomain, DataPackage } from '../../../../types/dataPackage';
+export interface RelationshipLine {
+    /** `out`: this entity references `target`. `in`: `target` references it. */
+    direction: 'out' | 'in';
+    target: string;
+    /** Column on the entity being described. */
+    fromField: string;
+    /** Column on `target`. */
+    toField: string;
+    /** e.g. `many-to-one`, read from the entity's own perspective. */
+    cardinality?: string;
+}
+export interface SchemaNode {
+    name: string;
+    /** Distance from a root (an entity with no outgoing foreign keys). */
+    rank: number;
+    /** Index of this node within its rank. */
+    col: number;
+    rowCount: number;
+}
+export interface SchemaEdge {
+    from: string;
+    to: string;
+    cardinality?: string;
+}
+export interface SchemaGraph {
+    nodes: SchemaNode[];
+    edges: SchemaEdge[];
+    /** Number of ranks (rows) the diagram needs. */
+    rankCount: number;
+    /** Widest rank, in nodes. */
+    maxCols: number;
+}
+export interface SchemaTreeNode {
+    name: string;
+    rowCount: number;
+    /** Cardinality of the edge to this node's parent, read outward. */
+    cardinality?: string;
+    /**
+     * Edges nesting cannot express. Non-empty means this package is a graph, not
+     * a hierarchy — see {@link countCrossEdges}, which is what makes the panel
+     * render {@link buildJoinGroups} instead of the tree.
+     */
+    otherEdges: SchemaEdge[];
+    children: SchemaTreeNode[];
+}
+export interface JoinGroup {
+    entity: string;
+    rowCount: number;
+    /** This entity's outgoing foreign keys, in declaration order. Often empty. */
+    edges: SchemaEdge[];
+}
+/**
+ * Foreign keys touching `entity`, in both directions. Outgoing keys come from
+ * the entity's own schema; incoming ones are found by scanning every other
+ * resource for a reference back to it.
+ */
+export declare function describeRelationships(dataPackage: DataPackage | null, entity: string): RelationshipLine[];
+/**
+ * Lays the package out as ranked rows: entities with no outgoing foreign keys
+ * are roots, and every other entity sits one rank below the deepest thing it
+ * references. Yields `donors → samples → datasets` for the HuBMAP package and a
+ * `Patient` hub above its four child tables for the star-shaped pcx package.
+ *
+ * ponytail: rank-by-row placement with straight edges — no crossing
+ * minimisation. Reach for a layout library only if packages get much denser.
+ */
+export declare function buildSchemaGraph(dataPackage: DataPackage | null): SchemaGraph;
+/**
+ * Reshapes the schema graph into a forest for the overview panel.
+ *
+ * The panel is a ~376px column, so a box-and-line diagram laid out in ranked rows
+ * grows past it as soon as one rank is wide — pcx's four children of `Patient`
+ * needed 452px. Nesting turns breadth into rows instead, making the rendered
+ * width independent of how many entities the package has.
+ *
+ * Only used when the package really is a hierarchy: each node is parented to the
+ * referenced entity with the greatest rank strictly below its own, and any edge
+ * left over lands in `otherEdges` — one of those is enough for the panel to show
+ * the join list instead. That `<` is what keeps this a forest: parent ranks
+ * strictly decrease, so a cyclic package — which `buildSchemaGraph` already
+ * terminates on by treating a back edge as rank 0 — drops the back edge into
+ * `otherEdges` instead of forming a parent cycle.
+ *
+ * ponytail: composite keys stay unsupported, matching `describeRelationships`.
+ */
+export declare function buildSchemaTree(dataPackage: DataPackage | null): SchemaTreeNode[];
+/**
+ * How many foreign keys the tree had to demote to `otherEdges` — i.e. how far
+ * the package is from being a clean hierarchy. Zero means every relationship is
+ * expressible as nesting; anything else means the tree is telling a partial
+ * story and the panel should show the join list instead.
+ */
+export declare function countCrossEdges(nodes: SchemaTreeNode[]): number;
+/**
+ * One entry per entity, each carrying the foreign keys it declares. This is the
+ * view for packages that are graphs rather than hierarchies: unlike the tree it
+ * demotes nothing, so a junction table's four parents all read equally instead
+ * of one becoming an arbitrary parent and the rest becoming footnotes.
+ *
+ * Every entity gets an entry even when it declares no keys — a pure reference
+ * target like HuBMAP's `donors` would otherwise appear only as an arrow head,
+ * with no row count anywhere in the map. Resource order, so the list runs
+ * parallel to the accordion beneath it.
+ *
+ * Returns nothing when the package declares no relationships at all: with no
+ * edges to add, this would just be a second copy of that accordion.
+ */
+export declare function buildJoinGroups(dataPackage: DataPackage | null): JoinGroup[];
+/**
+ * Numeric range for an interval domain: `"1.2K – 4.1G"`.
+ *
+ * All-null columns reach us as `{ min: Infinity, max: -Infinity }` from the
+ * toolkit's domain worker, so non-finite bounds must degrade, not render.
+ */
+export declare function formatIntervalDomain(domain: DataFieldDomain): string;
+/**
+ * The distinct values of a categorical (point) domain, cleaned for display.
+ *
+ * The toolkit's domain worker builds these with `Array.from(new Set(values))`
+ * and casts to `string[]` without filtering, so nulls and blanks come through
+ * and the count is uncapped — an id-like column can carry one value per row.
+ */
+export declare function categoricalValues(domain: DataFieldDomain): string[];
+/**
+ * Fields that actually act as keys in this entity's relationships: its declared
+ * primary key, the columns of its own foreign keys, and the columns other
+ * entities point at.
+ *
+ * Deliberately narrower than `dataPackageStore.getKeyFields`, which also counts
+ * any field flagged `udi:unique`. That flag means "no repeated values", which a
+ * timestamp column satisfies by accident — marking it a key field is misleading.
+ * The store's broader notion still drives the row table's column projection,
+ * where an incidentally-unique column is a useful identifier.
+ */
+export declare function relationshipKeyFields(dataPackage: DataPackage | null, entity: string): Set<string>;

package/dist/src/features/data-package/utils/entityOverview.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/features/tool-calls/components/IntervalFilterComponent.d.ts

@@ -4,6 +4,13 @@ interface IntervalFilterComponentProps {
     fieldIndex: number;
     tweakable: boolean;
     filterKey: string;
+    /**
+     * Optional override for where an edit is written. Defaults to
+     * `dataFiltersStore.setDataSelection(filterKey, …)` (the LLM-filter path).
+     * Brush-originated filters pass a writer that targets the brush store
+     * instead, so the same widget can drive a visualization brush.
+     */
+    onCommit?: (selection: DataSelection) => void;
 }
-export declare function IntervalFilterComponent({ dataSelection, fieldIndex, tweakable, filterKey, }: IntervalFilterComponentProps): import("react").JSX.Element;
+export declare function IntervalFilterComponent({ dataSelection, fieldIndex, tweakable, filterKey, onCommit, }: IntervalFilterComponentProps): import("react").JSX.Element;
 export {};

package/dist/src/features/tool-calls/components/PointFilterComponent.d.ts

@@ -3,6 +3,12 @@ interface PointFilterComponentProps {
     dataSelection: DataSelection;
     tweakable: boolean;
     filterKey: string;
+    /**
+     * Optional override for where an edit is written. Defaults to
+     * `dataFiltersStore.setDataSelection(filterKey, …)` (the LLM-filter path).
+     * Brush-originated filters pass a writer that targets the brush store.
+     */
+    onCommit?: (selection: DataSelection) => void;
 }
-export declare function PointFilterComponent({ dataSelection, tweakable, filterKey, }: PointFilterComponentProps): import("react").JSX.Element;
+export declare function PointFilterComponent({ dataSelection, tweakable, filterKey, onCommit, }: PointFilterComponentProps): import("react").JSX.Element;
 export {};

package/dist/src/features/tool-calls/components/PointFilterComponent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/features/tool-calls/index.d.ts

@@ -3,4 +3,6 @@
  * must go through this barrel; intra-feature imports use relative paths.
  */
 export { ToolCallRenderer } from './components/ToolCallRenderer';
+export { IntervalFilterComponent } from './components/IntervalFilterComponent';
+export { PointFilterComponent } from './components/PointFilterComponent';
 export type { FreeTextExplainArgs, RebuffArgs, ClarifyVariableArgs, FilterDataArgs, TextSegment, CreateVisualizationArgs, } from './types';

package/dist/src/lib/chatRoot.d.ts

@@ -0,0 +1,7 @@
+import { RefObject } from 'react';
+export declare const ChatRootProvider: import('react').Provider<RefObject<HTMLElement | null> | null>;
+/**
+ * The chat root ref, or `undefined` when unmounted outside UDIChat — pass
+ * straight to a Base UI `Portal`'s `container` prop.
+ */
+export declare function useChatRoot(): RefObject<HTMLElement | null> | undefined;

package/dist/src/stores/globalStore.d.ts

@@ -1,6 +1,16 @@
 export interface GlobalState {
     debugMode: boolean;
     isProduction: boolean;
+    /** Whether the Data Overview view is showing in the left region. */
+    overviewOpen: boolean;
+    /** Entity whose overview accordion item should be expanded, if any. */
+    overviewEntity: string | null;
     toggleDebugMode: () => void;
+    /**
+     * Open/close the Data Overview and optionally pick the entity to expand.
+     * Omitting `entity` leaves the current one alone (so the header toggle
+     * reopens on whatever was last looked at); pass `null` to clear it.
+     */
+    setOverview: (open: boolean, entity?: string | null) => void;
 }
 export declare function createGlobalStore(): import('zustand').StoreApi<GlobalState>;

package/dist/src/utils/entityIcons.d.ts

@@ -0,0 +1,10 @@
+import { EntityIconMap } from '../../features/dashboard';
+/**
+ * Built-in entity → icon map, merged under any consumer-supplied icons from
+ * `useEntityIcons()`. Shared by the dashboard's count chips and the data
+ * overview panel, so it lives outside both — the fast-refresh rule forbids
+ * exporting it from a component module.
+ */
+export declare const DEFAULT_ENTITY_ICONS: EntityIconMap;
+/** Fallback for an entity with no icon of its own. */
+export declare const FALLBACK_ENTITY_ICON: import('react').ForwardRefExoticComponent<Omit<import('lucide-react').LucideProps, "ref"> & import('react').RefAttributes<SVGSVGElement>>;

package/dist/src/utils/highlightMatch.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+/**
+ * Wraps the first case-insensitive occurrence of `query` in `text` with a
+ * `<mark>`. Shared by the chat's field chips and the data overview's field list
+ * so that filtering looks the same wherever fields are listed.
+ */
+export declare function highlightMatch(text: string, query: string): ReactNode;

package/dist/src/utils/httpError.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Pull a human-readable detail out of a response body: FastAPI's `detail`
+ * (string or validation-error array), our handlers' `error`/`message`, or a
+ * short plain-text body. Returns '' when there's nothing safe to show (e.g. an
+ * HTML error page or a multi-line stack trace).
+ */
+export declare function extractErrorDetail(body: string): string;
+/** Format a status + body into `Label: detail` (or just `Label`). */
+export declare function formatHttpError(status: number, body: string): string;
+/** Read a failed Response and build a friendly Error to throw. */
+export declare function httpError(response: Response): Promise<Error>;

package/dist/src/utils/httpError.test.d.ts

@@ -0,0 +1 @@
+export {};