drizzle-cube 0.8.0 → 0.8.2

package/dist/adapters/utils.cjs

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./utils-BY0-KFyI.cjs");exports.buildTransformedQuery=e.t,exports.calculateQueryComplexity=e.n,exports.formatCubeResponse=e.r,exports.formatErrorResponse=e.i,exports.formatMetaResponse=e.a,exports.formatSqlResponse=e.o,exports.formatSqlString=e.S,exports.generateRequestId=e.s,exports.getDatabaseType=e.c,exports.handleBatchRequest=e.l,exports.handleDiscover=e.p,exports.handleDryRun=e.u,exports.handleLoad=e.m,exports.handleSuggest=e.d,exports.handleValidate=e.f,exports.normalizeQueryFields=e.h;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./utils-C1JpSDOX.cjs");exports.buildTransformedQuery=e.t,exports.calculateQueryComplexity=e.n,exports.formatCubeResponse=e.r,exports.formatErrorResponse=e.i,exports.formatMetaResponse=e.a,exports.formatSqlResponse=e.o,exports.formatSqlString=e.S,exports.generateRequestId=e.s,exports.getDatabaseType=e.c,exports.handleBatchRequest=e.l,exports.handleDiscover=e.p,exports.handleDryRun=e.u,exports.handleLoad=e.m,exports.handleSuggest=e.d,exports.handleValidate=e.f,exports.normalizeQueryFields=e.h;

package/dist/adapters/utils.d.ts

@@ -1,4 +1,4 @@
-import { SemanticLayerCompiler, SemanticQuery, SecurityContext, QuerySuggestion, AIValidationResult } from '../server/index.js';
+import { SemanticLayerCompiler, SemanticQuery, SecurityContext, QuerySuggestion, AIValidationResult, QueryValidationIssue } from '../server/index.js';
 import { normalizeQueryFields } from '../server/query-handlers.js';
 import { MCPPromptResolver, MCPResourceResolver, MCPInstructionsResolver } from './mcp-transport.js';
 export { handleDiscover, handleLoad } from '../server/query-handlers.js';
@@ -45,9 +45,11 @@ export declare function formatCubeResponse(query: SemanticQuery, result: {
         measures?: string[];
         suggestion?: string;
     }>;
+    total?: number;
 }, semanticLayer: SemanticLayerCompiler): {
     queryType: string;
     results: {
+        total?: number | undefined;
         warnings?: {
             code: string;
             message: string;
@@ -86,6 +88,7 @@ export declare function formatCubeResponse(query: SemanticQuery, result: {
         order?: Record<string, "asc" | "desc">;
         fillMissingDatesValue?: number | null;
         ungrouped?: boolean;
+        total?: boolean;
         funnel?: import('../server/index.js').FunnelQueryConfig;
         flow?: import('../server/types/flow.js').FlowQueryConfig;
         retention?: import('../server/index.js').RetentionQueryConfig;
@@ -167,9 +170,16 @@ export declare function formatMetaResponse(metadata: any): {
     };
 };
 /**
- * Standard error response format
+ * Standard error response format.
+ *
+ * `issues` is additive: the `error` string keeps its exact shape for existing
+ * clients, while a caller that needs to act on a *particular* unknown member —
+ * a dashboard dropping the column for a deleted attribute, say — has something
+ * structured to read. Splitting the joined string back apart is not reliable,
+ * since the per-field hints contain the same separator.
  */
-export declare function formatErrorResponse(error: string | Error, status?: number): {
+export declare function formatErrorResponse(error: string | Error, status?: number, issues?: QueryValidationIssue[]): {
+    issues?: QueryValidationIssue[] | undefined;
     error: string;
     status: number;
 };
@@ -197,6 +207,7 @@ export declare function handleBatchRequest(queries: SemanticQuery[], securityCon
     results: ({
         queryType: string;
         results: {
+            total?: number | undefined;
             warnings?: {
                 code: string;
                 message: string;
@@ -235,6 +246,7 @@ export declare function handleBatchRequest(queries: SemanticQuery[], securityCon
             order?: Record<string, "asc" | "desc">;
             fillMissingDatesValue?: number | null;
             ungrouped?: boolean;
+            total?: boolean;
             funnel?: import('../server/index.js').FunnelQueryConfig;
             flow?: import('../server/types/flow.js').FlowQueryConfig;
             retention?: import('../server/index.js').RetentionQueryConfig;
@@ -242,10 +254,12 @@ export declare function handleBatchRequest(queries: SemanticQuery[], securityCon
         slowQuery: boolean;
         success: boolean;
         error?: undefined;
+        issues?: undefined;
         query?: undefined;
     } | {
         success: boolean;
         error: string;
+        issues: QueryValidationIssue[] | undefined;
         query: SemanticQuery;
     })[];
 }>;

package/dist/adapters/utils.js

@@ -1,2 +1,2 @@
-import { S as e, a as t, c as n, d as r, f as i, h as a, i as o, l as s, m as c, n as l, o as u, p as d, r as f, s as p, t as m, u as h } from "./utils-DkmShl5f.js";
+import { S as e, a as t, c as n, d as r, f as i, h as a, i as o, l as s, m as c, n as l, o as u, p as d, r as f, s as p, t as m, u as h } from "./utils-BhlkVCzZ.js";
 export { m as buildTransformedQuery, l as calculateQueryComplexity, f as formatCubeResponse, o as formatErrorResponse, t as formatMetaResponse, u as formatSqlResponse, e as formatSqlString, p as generateRequestId, n as getDatabaseType, s as handleBatchRequest, d as handleDiscover, h as handleDryRun, c as handleLoad, r as handleSuggest, i as handleValidate, a as normalizeQueryFields };

package/dist/cjs/adapters/utils.d.ts

@@ -1,4 +1,4 @@
-import { SemanticLayerCompiler, SemanticQuery, SecurityContext, QuerySuggestion, AIValidationResult } from '../server/index.js';
+import { SemanticLayerCompiler, SemanticQuery, SecurityContext, QuerySuggestion, AIValidationResult, QueryValidationIssue } from '../server/index.js';
 import { normalizeQueryFields } from '../server/query-handlers.js';
 import { MCPPromptResolver, MCPResourceResolver, MCPInstructionsResolver } from './mcp-transport.js';
 export { handleDiscover, handleLoad } from '../server/query-handlers.js';
@@ -45,9 +45,11 @@ export declare function formatCubeResponse(query: SemanticQuery, result: {
         measures?: string[];
         suggestion?: string;
     }>;
+    total?: number;
 }, semanticLayer: SemanticLayerCompiler): {
     queryType: string;
     results: {
+        total?: number | undefined;
         warnings?: {
             code: string;
             message: string;
@@ -86,6 +88,7 @@ export declare function formatCubeResponse(query: SemanticQuery, result: {
         order?: Record<string, "asc" | "desc">;
         fillMissingDatesValue?: number | null;
         ungrouped?: boolean;
+        total?: boolean;
         funnel?: import('../server/index.js').FunnelQueryConfig;
         flow?: import('../server/types/flow.js').FlowQueryConfig;
         retention?: import('../server/index.js').RetentionQueryConfig;
@@ -167,9 +170,16 @@ export declare function formatMetaResponse(metadata: any): {
     };
 };
 /**
- * Standard error response format
+ * Standard error response format.
+ *
+ * `issues` is additive: the `error` string keeps its exact shape for existing
+ * clients, while a caller that needs to act on a *particular* unknown member —
+ * a dashboard dropping the column for a deleted attribute, say — has something
+ * structured to read. Splitting the joined string back apart is not reliable,
+ * since the per-field hints contain the same separator.
  */
-export declare function formatErrorResponse(error: string | Error, status?: number): {
+export declare function formatErrorResponse(error: string | Error, status?: number, issues?: QueryValidationIssue[]): {
+    issues?: QueryValidationIssue[] | undefined;
     error: string;
     status: number;
 };
@@ -197,6 +207,7 @@ export declare function handleBatchRequest(queries: SemanticQuery[], securityCon
     results: ({
         queryType: string;
         results: {
+            total?: number | undefined;
             warnings?: {
                 code: string;
                 message: string;
@@ -235,6 +246,7 @@ export declare function handleBatchRequest(queries: SemanticQuery[], securityCon
             order?: Record<string, "asc" | "desc">;
             fillMissingDatesValue?: number | null;
             ungrouped?: boolean;
+            total?: boolean;
             funnel?: import('../server/index.js').FunnelQueryConfig;
             flow?: import('../server/types/flow.js').FlowQueryConfig;
             retention?: import('../server/index.js').RetentionQueryConfig;
@@ -242,10 +254,12 @@ export declare function handleBatchRequest(queries: SemanticQuery[], securityCon
         slowQuery: boolean;
         success: boolean;
         error?: undefined;
+        issues?: undefined;
         query?: undefined;
     } | {
         success: boolean;
         error: string;
+        issues: QueryValidationIssue[] | undefined;
         query: SemanticQuery;
     })[];
 }>;

package/dist/cjs/client/charts/chartConfigRegistry.d.ts

@@ -7,6 +7,13 @@ import { ChartTypeConfig, ChartConfigRegistry } from './chartConfigs.js';
  * stay here in full because the server agent reads them synchronously.
  */
 export declare const chartConfigRegistry: ChartConfigRegistry;
+/**
+ * Whether a chart lists records rather than aggregates, and so needs an
+ * `ungrouped` query.
+ *
+ * Reads the eager registry so the query builders need no chart-type switch.
+ */
+export declare function isRecordGrainChart(chartType: string): boolean;
 /**
  * Register a custom chart config into the registry.
  * Used by the chart plugin system.

package/dist/cjs/client/charts/chartConfigs.d.ts

@@ -18,6 +18,13 @@ export interface AxisDropZoneConfig {
     emptyText?: string;
     /** Enable L/R axis toggle for items in this drop zone (for dual Y-axis support) */
     enableDualAxis?: boolean;
+    /**
+     * Keep this zone out of automatic chart-config inference (the agent's
+     * `inferChartConfig`). For zones whose meaning is subtractive or opt-in — the
+     * records table's hidden columns being the case in point — filling them from
+     * the query changes what renders rather than completing a partial config.
+     */
+    excludeFromInference?: boolean;
 }
 /**
  * Configuration for a single display option
@@ -28,7 +35,7 @@ export interface DisplayOptionConfig {
     /** Display label for the option */
     label: string;
     /** Type of input control to render */
-    type: 'boolean' | 'string' | 'number' | 'select' | 'color' | 'paletteColor' | 'axisFormat' | 'stringArray' | 'buttonGroup' | 'thresholdBands';
+    type: 'boolean' | 'string' | 'number' | 'select' | 'color' | 'paletteColor' | 'axisFormat' | 'stringArray' | 'buttonGroup' | 'thresholdBands' | 'columnFormats' | 'rowLink';
     /** Default value for the option */
     defaultValue?: any;
     /** Placeholder text for string/number inputs */
@@ -125,6 +132,15 @@ export interface ChartTypeConfig {
      * Omit to mean "always available".
      */
     isAvailable?: (ctx: ChartAvailabilityContext) => ChartAvailability;
+    /**
+     * This chart lists individual records rather than aggregates, so the query
+     * built for it must be `ungrouped`.
+     *
+     * Declared here rather than switched on a chart type inside the query
+     * builders, and read from the eager registry so those stay data-driven — and
+     * so a custom chart can opt in through the same flag.
+     */
+    recordGrain?: boolean;
 }
 /**
  * Registry of all chart type configurations

package/dist/cjs/client/client/CubeClient.d.ts

@@ -1,4 +1,14 @@
-import { CubeQuery, CubeApiOptions, CubeResultSet, ExplainResult, ExplainOptions } from '../types.js';
+import { CubeQuery, CubeApiOptions, CubeResultSet, CubeValidationIssue, ExplainResult, ExplainOptions } from '../types.js';
+/**
+ * A failed query, carrying the server's structured validation detail when it
+ * sent any. A caller can then react to one dead member — dropping a column for
+ * a deleted attribute, say — instead of only seeing prose.
+ */
+export declare class CubeQueryError extends Error {
+    readonly status?: number;
+    readonly issues?: CubeValidationIssue[];
+    constructor(message: string, status?: number, issues?: CubeValidationIssue[]);
+}
 export declare class CubeClient {
     private apiUrl;
     private headers;

package/dist/cjs/client/components/AnalysisBuilder/AnalysisDisplayConfigPanel.d.ts

@@ -1,11 +1,13 @@
-import { ChartType, ChartDisplayConfig, ColorPalette } from '../../types.js';
+import { ChartAxisConfig, ChartType, ChartDisplayConfig, ColorPalette } from '../../types.js';
 interface AnalysisDisplayConfigPanelProps {
     chartType: ChartType;
     displayConfig: ChartDisplayConfig;
     colorPalette?: ColorPalette;
+    /** Passed to options that are keyed by field, such as the records table's column formats. */
+    chartConfig?: ChartAxisConfig;
     onDisplayConfigChange: (config: ChartDisplayConfig) => void;
     /** Keys to exclude from displayOptionsConfig rendering (e.g., ['content'] when content is managed elsewhere) */
     excludeKeys?: string[];
 }
-export default function AnalysisDisplayConfigPanel({ chartType, displayConfig, colorPalette, onDisplayConfigChange, excludeKeys, }: AnalysisDisplayConfigPanelProps): import("react").JSX.Element;
+export default function AnalysisDisplayConfigPanel({ chartType, displayConfig, colorPalette, chartConfig, onDisplayConfigChange, excludeKeys, }: AnalysisDisplayConfigPanelProps): import("react").JSX.Element;
 export {};

package/dist/cjs/client/components/AnalysisBuilder/ColumnFormatsEditor.d.ts

@@ -0,0 +1,10 @@
+import { ChartAxisConfig, ColorPalette, ColumnFormatConfig } from '../../types.js';
+interface ColumnFormatsEditorProps {
+    value: Record<string, ColumnFormatConfig>;
+    chartConfig?: ChartAxisConfig;
+    colorPalette?: ColorPalette;
+    onChange: (value: Record<string, ColumnFormatConfig> | undefined) => void;
+    t: (key: string, params?: Record<string, string | number>) => string;
+}
+export default function ColumnFormatsEditor({ value, chartConfig, colorPalette, onChange, t }: ColumnFormatsEditorProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/AnalysisBuilder/DisplayOptionControl.d.ts

@@ -1,10 +1,11 @@
-import { ChartDisplayConfig, ColorPalette } from '../../types.js';
+import { ChartAxisConfig, ChartDisplayConfig, ColorPalette } from '../../types.js';
 import { DisplayOptionConfig } from '../../charts/chartConfigs.js';
 interface DisplayOptionControlProps {
     option: DisplayOptionConfig;
     displayConfig: ChartDisplayConfig;
     colorPalette?: ColorPalette;
+    chartConfig?: ChartAxisConfig;
     onDisplayConfigChange: (config: ChartDisplayConfig) => void;
 }
-export default function DisplayOptionControl({ option, displayConfig, colorPalette, onDisplayConfigChange, }: DisplayOptionControlProps): import("react").JSX.Element | null;
+export default function DisplayOptionControl({ option, displayConfig, colorPalette, chartConfig, onDisplayConfigChange, }: DisplayOptionControlProps): import("react").JSX.Element | null;
 export {};

package/dist/cjs/client/components/AnalysisBuilder/utils/queryUtils.d.ts

@@ -4,7 +4,13 @@ import { MetricItem, BreakdownItem } from '../types.js';
  * Convert metrics and breakdowns to CubeQuery format
  * Handles comparison mode by building compareDateRange for time dimensions
  */
-export declare function buildCubeQuery(metrics: MetricItem[], breakdowns: BreakdownItem[], filters: Filter[], order?: Record<string, 'asc' | 'desc'>, preserveComparisonFilters?: boolean, limit?: number): CubeQuery;
+export declare function buildCubeQuery(metrics: MetricItem[], breakdowns: BreakdownItem[], filters: Filter[], order?: Record<string, 'asc' | 'desc'>, preserveComparisonFilters?: boolean, limit?: number, 
+/**
+ * Record-grain charts list rows rather than aggregates — see
+ * `ChartTypeConfig.recordGrain`. Without this, editing a records-table
+ * portlet in the builder silently rebuilds its query as a grouped one.
+ */
+ungrouped?: boolean): CubeQuery;
 /**
  * Check if a query has any content
  */

package/dist/cjs/client/components/analyticsPortlet/PortletChart.d.ts

@@ -1,4 +1,4 @@
-import { ChartAxisConfig, ChartDisplayConfig, ChartType, CubeQuery } from '../../types.js';
+import { ChartAxisConfig, ChartDisplayConfig, ChartPagination, ChartType, CubeQuery } from '../../types.js';
 import { FlowChartData } from '../../types/flow.js';
 import { RetentionChartData } from '../../types/retention.js';
 import { ColorPalette } from '../../utils/colorPalettes.js';
@@ -22,6 +22,7 @@ export interface PortletChartProps {
     chartConfig?: ChartAxisConfig;
     displayConfig?: ChartDisplayConfig;
     activeQuery: CubeQuery | null;
+    pagination?: ChartPagination;
     colorPalette?: ColorPalette;
     drillEnabled: boolean;
     currentChartConfig?: ChartAxisConfig | null;

package/dist/cjs/client/components/analyticsPortlet/PortletChartView.d.ts

@@ -1,4 +1,4 @@
-import { ChartAxisConfig, ChartDisplayConfig, ChartType, CubeQuery } from '../../types.js';
+import { ChartAxisConfig, ChartDisplayConfig, ChartPagination, ChartType, CubeQuery } from '../../types.js';
 import { FlowChartData } from '../../types/flow.js';
 import { RetentionChartData } from '../../types/retention.js';
 import { ColorPalette } from '../../utils/colorPalettes.js';
@@ -26,6 +26,9 @@ export interface PortletChartViewProps {
     flowChartData: FlowChartData | null;
     retentionChartData: RetentionChartData | null;
     activeQuery: CubeQuery | null;
+    pagination?: ChartPagination;
+    /** Members dropped because the model no longer has them; surfaced as a note. */
+    droppedMembers?: string[];
     drill: DrillInteraction;
     isDrillEnabled: boolean;
     onNavigateBack: () => void;

package/dist/cjs/client/components/analyticsPortlet/usePortletDeadMembers.d.ts

@@ -0,0 +1,24 @@
+import { CubeQuery } from '../../types.js';
+export interface UsePortletDeadMembersParams {
+    queryObject: CubeQuery | null;
+    /** The error from the last attempt, if it failed. */
+    error: unknown;
+}
+export interface UsePortletDeadMembersResult {
+    /** The query with dead members removed — the original when there are none. */
+    query: CubeQuery | null;
+    /** Members dropped so far, for the note shown above the chart. */
+    droppedMembers: string[];
+}
+/**
+ * Pull the prunable members out of a failed query, or `null` when the failure
+ * is not one we may recover from.
+ *
+ * A single unknown *filter* member makes the whole error unrecoverable, even
+ * alongside prunable ones: re-running without the dead columns would still
+ * carry the dead filter.
+ */
+export declare function prunableMembers(error: unknown): string[] | null;
+/** Remove members from everything that projects or orders by them. */
+export declare function withoutMembers(query: CubeQuery, members: string[]): CubeQuery;
+export declare function usePortletDeadMembers({ queryObject, error }: UsePortletDeadMembersParams): UsePortletDeadMembersResult;

package/dist/cjs/client/components/analyticsPortlet/usePortletPagination.d.ts

@@ -0,0 +1,21 @@
+import { ChartPagination, ChartType, CubeQuery } from '../../types.js';
+/** Fixed page sizes, matching the records table's own `pageSize` option. */
+export declare const PAGE_SIZE_OPTIONS: number[];
+export interface UsePortletPaginationParams {
+    chartType: ChartType;
+    /** The query to paginate — the drilled query when one is active, else the base query. */
+    activeQuery: CubeQuery | null;
+    /** Authored page size from the portlet's display config. */
+    pageSize?: number;
+}
+export interface UsePortletPaginationResult {
+    /** `activeQuery` with limit/offset/order/total merged in, or it unchanged when paging is off. */
+    paginatedQuery: CubeQuery | null;
+    /**
+     * Passed to the chart as `ChartProps.pagination`; undefined when paging is
+     * off. `total` is left unset here — it arrives with the response, so the
+     * caller fills it in from the result set.
+     */
+    pagination?: Omit<ChartPagination, 'total'>;
+}
+export declare function usePortletPagination({ chartType, activeQuery, pageSize: authoredPageSize }: UsePortletPaginationParams): UsePortletPaginationResult;

package/dist/cjs/client/components/charts/DotStripChart.config.d.ts

@@ -0,0 +1,15 @@
+import { ChartTypeConfig } from '../../charts/chartConfigs.js';
+/**
+ * Configuration for the dot strip (beeswarm) chart type.
+ *
+ * Eager metadata (`label`, `description`, `useCase`, `isAvailable`) lives in the
+ * unified `chartRegistry` entry (the single source of truth) — see
+ * `src/client/charts/chartRegistry.ts`. This file owns the lazy-loaded shape:
+ * drop zones, display options, clickable elements, validation.
+ *
+ * The zone *keys* are the standard `xAxis` / `yAxis` / `series` (so no
+ * `ChartAxisConfig` change is needed), but the visual axes are transposed —
+ * bands are rows and the measure runs horizontally — so the labels name the
+ * roles rather than the axes.
+ */
+export declare const dotStripChartConfig: ChartTypeConfig;

package/dist/cjs/client/components/charts/DotStripChart.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ChartProps } from '../../types.js';
+declare const DotStripChart: React.MemoExoticComponent<({ data, chartConfig, displayConfig, height, colorPalette, onDataPointClick, drillEnabled, }: ChartProps) => React.JSX.Element>;
+export default DotStripChart;

package/dist/cjs/client/components/charts/DotStripChart.helpers.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Layout maths for the dot strip (beeswarm) chart.
+ *
+ * Kept out of the component — like `ScatterChart.helpers.ts` and
+ * `BubbleChart.render.ts` — so the swarm packing can be unit-tested without a
+ * DOM. Everything here is pure: same input, same output, every time.
+ */
+/** Hard caps so one pathological band cannot blow up the layout. */
+export declare const MAX_BANDS = 50;
+export declare const MAX_DOTS_PER_BAND = 500;
+export declare const MAX_LANES = 8;
+export declare const MIN_ROW_HEIGHT = 44;
+export declare const MAX_ROW_HEIGHT = 220;
+/** Vertical breathing room added above and below the outermost lanes. */
+export declare const ROW_VERTICAL_PADDING = 12;
+export declare const DOT_RADIUS: Record<'small' | 'medium' | 'large', number>;
+/** Gap between the edges of two adjacent dots in the same lane. */
+export declare const DOT_GAP = 1.5;
+export interface DotDatum {
+    /** Raw numeric value of the measure. */
+    value: number;
+    /** Identity label for the dot (from the optional series dimension). */
+    label: string;
+    /** The source row, handed back on click. */
+    row: Record<string, unknown>;
+}
+export interface PlacedDot extends DotDatum {
+    /** Pixel x within the plot area. */
+    x: number;
+    /** Lane index: 0 is the centre line, then +1, -1, +2, -2, … */
+    lane: number;
+    /** Pixel y offset from the band's centre line. */
+    y: number;
+}
+export interface BandStats {
+    /** The band's own label (the value of the band dimension). */
+    label: string;
+    dots: PlacedDot[];
+    count: number;
+    median: number | null;
+    min: number | null;
+    max: number | null;
+    /**
+     * max / min. `null` when it cannot be stated meaningfully — fewer than two
+     * dots, or a non-positive minimum (the ratio is infinite or sign-flipped).
+     */
+    spread: number | null;
+    /** True when the band has rows but not one usable numeric value. */
+    noData: boolean;
+    /** Rendered height of this band's row, in px. */
+    height: number;
+    /** True when the band's dots were truncated at MAX_DOTS_PER_BAND. */
+    truncated: boolean;
+}
+export declare function parseNumeric(v: unknown): number | null;
+export declare function median(sortedValues: number[]): number | null;
+/**
+ * Greedy deterministic beeswarm packing.
+ *
+ * Dots are sorted by x (ties broken by label, so the output is stable for a
+ * given input rather than dependent on row order) and each is dropped into the
+ * first lane — searched outward from the centre — where it clears every dot
+ * already in that lane by at least `2r + gap`. Beyond `MAX_LANES` the dot is
+ * forced onto the outermost lane and simply overlaps; the surface-coloured
+ * stroke keeps that readable.
+ *
+ * A force simulation would do this too, but it settles asynchronously and
+ * non-deterministically, which makes it untestable and jittery on re-render.
+ */
+export declare function packSwarm(dots: DotDatum[], scale: (v: number) => number, radius: number): PlacedDot[];
+/** Row height needed to show every lane the swarm used. */
+export declare function swarmHeight(placed: PlacedDot[], radius: number): number;
+/** max / min, or null when the ratio would be meaningless. */
+export declare function computeSpread(min: number | null, max: number | null, count: number): number | null;
+export type BandSort = 'none' | 'valueDesc' | 'valueAsc' | 'count';
+/**
+ * Group rows into bands, in the order requested. Sorting happens before the
+ * swarm is packed so row heights follow the rows the user actually sees.
+ */
+export declare function groupIntoBands(rows: Record<string, unknown>[], bandField: string, valueField: string, labelField: string | undefined, sort: BandSort): Array<{
+    label: string;
+    values: DotDatum[];
+    truncated: boolean;
+}>;
+/** Nicely padded numeric domain across every dot in every band. */
+export declare function computeDomain(values: number[]): {
+    min: number;
+    max: number;
+};
+/** Evenly spaced axis ticks across the domain. */
+export declare function computeTicks(min: number, max: number, count?: number): number[];

package/dist/cjs/client/components/charts/RecordsTable.config.d.ts

@@ -0,0 +1,10 @@
+import { ChartTypeConfig } from '../../charts/chartConfigs.js';
+/**
+ * Configuration for the records table.
+ *
+ * Eager metadata (`label`, `description`, `useCase`, `isAvailable`) lives in the
+ * unified `chartRegistry` entry — see `src/client/charts/chartRegistry.ts`. This
+ * file owns the lazy-loaded shape: drop zones, display options, clickable
+ * elements, validation.
+ */
+export declare const recordsTableConfig: ChartTypeConfig;

package/dist/cjs/client/components/charts/RecordsTable.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ChartProps } from '../../types.js';
+declare const RecordsTable: React.MemoExoticComponent<({ data, chartConfig, displayConfig, queryObject, colorPalette, height, onDataPointClick, drillEnabled, pagination }: ChartProps) => React.JSX.Element>;
+export default RecordsTable;

package/dist/cjs/client/components/charts/recordsTableHooks.d.ts

@@ -0,0 +1,68 @@
+import { default as React } from 'react';
+import { ChartAxisConfig, ChartPagination, CubeQuery } from '../../types.js';
+export declare const DEFAULT_PAGE_SIZE = 25;
+/**
+ * Which columns to render, in which order.
+ *
+ * The author's arrangement comes from the Columns drop zone; a viewer can drag
+ * a header on top of it, and that order is remembered per column set. It is
+ * *reconciled* rather than substituted, so a column the author adds later still
+ * appears instead of being swallowed by a stale local order.
+ */
+export declare function useRecordsColumns(params: {
+    rows: Record<string, unknown>[];
+    chartConfig?: ChartAxisConfig;
+    queryObject?: CubeQuery;
+}): {
+    columns: string[];
+    storageKey: string;
+    draggedColumn: string | null;
+    didDragRef: React.MutableRefObject<boolean>;
+    startColumnDrag: (column: string) => void;
+    endColumnDrag: () => void;
+    dropColumn: (target: string) => void;
+};
+/**
+ * Drag-resizable column widths, remembered per column set.
+ *
+ * A chart has no portlet id and no write path back to `displayConfig`, so an
+ * authored `columnWidths` acts as the default a viewer's own drags layer over —
+ * the same arrangement the data browser uses.
+ */
+export declare function useColumnWidths(params: {
+    columns: string[];
+    storageKey: string;
+    authored?: Record<string, number>;
+}): {
+    columnWidths: Record<string, number>;
+    totalWidth: number | undefined;
+    tableRef: React.RefObject<HTMLTableElement>;
+    didResizeRef: React.MutableRefObject<boolean>;
+    startResize: (event: React.MouseEvent, column: string) => void;
+};
+/**
+ * Sorting and paging, server-side when the host offers it.
+ *
+ * With a `pagination` prop the host re-queries, so both must go through it:
+ * sorting only the loaded page would put the wrong rows on page 1. Without one
+ * — the AnalysisBuilder preview, the notebook, plugin hosts — the table sorts
+ * and pages over the rows it already has.
+ */
+export declare function useRecordsPaging(params: {
+    rows: Record<string, unknown>[];
+    pagination?: ChartPagination;
+    authoredPageSize?: number;
+}): {
+    sort: {
+        column: string;
+        direction: "asc" | "desc";
+    } | null;
+    toggleSort: (column: string) => void;
+    visibleRows: Record<string, unknown>[];
+    page: number;
+    pageSize: number;
+    pageCount: number;
+    rowCount: number;
+    goToPage: (next: number) => void;
+    showPager: boolean;
+};

package/dist/cjs/client/icons/types.d.ts

@@ -80,6 +80,7 @@ export interface IconRegistry {
     chartRadialBar: IconDefinition;
     chartTreemap: IconDefinition;
     chartTable: IconDefinition;
+    chartRecordsTable: IconDefinition;
     chartActivityGrid: IconDefinition;
     chartKpiNumber: IconDefinition;
     chartKpiDelta: IconDefinition;
@@ -91,6 +92,7 @@ export interface IconRegistry {
     chartHeatmap: IconDefinition;
     chartRetention: IconDefinition;
     chartBoxPlot: IconDefinition;
+    chartDotStrip: IconDefinition;
     chartWaterfall: IconDefinition;
     chartCandlestick: IconDefinition;
     chartMeasureProfile: IconDefinition;

package/dist/cjs/client/index.d.ts

@@ -33,7 +33,7 @@ useCubeFeatures } from './providers/CubeProvider.js';
 export { ScrollContainerProvider, useScrollContainer } from './providers/ScrollContainerContext.js';
 export { useCubeFieldLabel } from './hooks/useCubeFieldLabel.js';
 export { createCubeClient } from './client/CubeClient.js';
-export { CubeClient } from './client/CubeClient.js';
+export { CubeClient, CubeQueryError } from './client/CubeClient.js';
 export { useCubeMetaQuery, useCubeLoadQuery, useCubeQuery, useMultiCubeLoadQuery, useDryRunQuery, useMultiDryRunQueries, useDryRunQueries, useExplainQuery, createExplainQueryKey, useExplainAI, useFunnelQuery, createFunnelQueryKey, useFlowQuery, createFlowQueryKey, } from './hooks/queries/index.js';
 export type { UseCubeMetaQueryOptions, UseCubeMetaQueryResult, UseCubeLoadQueryOptions, UseCubeLoadQueryResult, UseMultiCubeLoadQueryOptions, UseMultiCubeLoadQueryResult, DebugDataEntry, UseExplainQueryOptions, UseExplainQueryResult, UseExplainAIOptions, UseExplainAIResult, UseFlowQueryOptions, UseFlowQueryResult, } from './hooks/queries/index.js';
 export { useAnalysisBuilder } from './hooks/useAnalysisBuilderHook.js';
@@ -55,7 +55,7 @@ export { useTheme } from './hooks/useTheme.js';
 export { useScrollDetection } from './hooks/useScrollDetection.js';
 export { useElementVisibility } from './hooks/useElementVisibility.js';
 export { useDrillInteraction } from './hooks/useDrillInteraction.js';
-export type { PortletConfig, ChartType, BuiltInChartType, ChartAxisConfig, ChartDisplayConfig, ChartProps, ColorPalette, CubeQuery, CubeQueryOptions, CubeApiOptions, DashboardConfig, PortletGroup, PortletGroupCell, FeaturesConfig, XlsExportFeatureConfig, ThumbnailFeatureConfig, MultiQueryConfig, QueryMergeStrategy, FunnelBindingKey, FunnelBindingKeyMapping, FunnelStep, FunnelConfig, FunnelStepResult, FunnelExecutionResult, FunnelChartData, FunnelValidationError, FunnelValidationResult, UseFunnelQueryOptions, UseFunnelQueryResult, ServerFlowQuery, FlowQueryConfig, FlowChartData, FlowSliceState, SankeyNode, SankeyLink, FlowStartingStep, FlowResultRow, } from './types.js';
+export type { PortletConfig, ChartType, BuiltInChartType, ChartAxisConfig, ChartDisplayConfig, ChartProps, ColorPalette, CubeQuery, CubeQueryOptions, CubeApiOptions, CubeValidationIssue, ChartPagination, ColumnFormatConfig, ColumnFormatKind, RowLinkConfig, DashboardConfig, PortletGroup, PortletGroupCell, FeaturesConfig, XlsExportFeatureConfig, ThumbnailFeatureConfig, MultiQueryConfig, QueryMergeStrategy, FunnelBindingKey, FunnelBindingKeyMapping, FunnelStep, FunnelConfig, FunnelStepResult, FunnelExecutionResult, FunnelChartData, FunnelValidationError, FunnelValidationResult, UseFunnelQueryOptions, UseFunnelQueryResult, ServerFlowQuery, FlowQueryConfig, FlowChartData, FlowSliceState, SankeyNode, SankeyLink, FlowStartingStep, FlowResultRow, } from './types.js';
 export { isQueryConfig, isFunnelConfig, isFlowConfig, isRetentionConfig, isMultiQuery, isSingleQuery, isValidAnalysisConfig, createDefaultQueryConfig, createDefaultFunnelConfig, createDefaultFlowConfig, createDefaultRetentionConfig, createDefaultConfig, isValidAnalysisWorkspace, createDefaultWorkspace } from './types/analysisConfig.js';
 export type { AnalysisConfig, QueryAnalysisConfig, FunnelAnalysisConfig, FlowAnalysisConfig, RetentionAnalysisConfig, AnalysisWorkspace } from './types/analysisConfig.js';
 export { isMultiQueryConfig, isServerFunnelQuery, isServerFlowQuery, isSankeyData } from './types.js';