drizzle-cube 0.7.1 → 0.8.1

package/dist/adapters/utils.cjs

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./utils-BoOeig94.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-BiKIg2tk.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;
     })[];
 }>;
@@ -354,11 +368,11 @@ export interface ValidateRequest {
 /**
  * Handle /suggest endpoint - generate query from natural language
  */
-export declare function handleSuggest(semanticLayer: SemanticLayerCompiler, body: SuggestRequest): Promise<QuerySuggestion>;
+export declare function handleSuggest(semanticLayer: SemanticLayerCompiler, securityContext: SecurityContext, body: SuggestRequest): Promise<QuerySuggestion>;
 /**
  * Handle /validate endpoint - validate query with corrections
  */
-export declare function handleValidate(semanticLayer: SemanticLayerCompiler, body: ValidateRequest, securityContext?: SecurityContext): Promise<AIValidationResult & {
+export declare function handleValidate(semanticLayer: SemanticLayerCompiler, securityContext: SecurityContext, body: ValidateRequest): Promise<AIValidationResult & {
     sql?: {
         sql: string;
         params?: any[];

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-DboNUT3A.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-BagURNRb.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/core/http-port.d.ts

@@ -7,8 +7,16 @@
  * (Hono/Next.js). Implementations are constructed per request by each adapter.
  *
  * This interface is public — third parties implement it to build adapters for
- * other frameworks. Add new capabilities as optional members or via a separate
- * extension interface; a new required member is a breaking change.
+ * other frameworks. Prefer optional members or a separate extension interface
+ * for new capabilities, because a new required member is a breaking change for
+ * those adapters.
+ *
+ * `setHeader` was promoted from {@link McpHttpPort} to this interface in the
+ * per-tenant cube sets release, so that the core can stamp `Cache-Control` on
+ * every REST response (see {@link withRestCacheHeaders}). Every REST body is now
+ * tenant-scoped, and that guarantee cannot be left to each adapter. The break is
+ * accepted for this release: third-party REST-only adapters must add
+ * `setHeader`, which all four first-party adapters already implemented.
  */
 export interface HttpPort<TRes> {
     /** Read a request header by (case-insensitive) name. Synchronous. */
@@ -17,23 +25,42 @@ export interface HttpPort<TRes> {
     getBody(): Promise<unknown>;
     /** Read a raw query-string value by name (used by GET). */
     getQueryParam(name: string): string | undefined;
+    /** Set a response header. Must be called before `send`/`sendSse`/`sendEmpty`. */
+    setHeader(name: string, value: string): void;
     /** Send a response with the given status and JSON body; returns the framework's response value. */
     send(status: number, body: unknown): TRes;
 }
 /**
- * Extension of {@link HttpPort} for the MCP POST handler, which needs to set
- * response headers (WWW-Authenticate, MCP-Session-Id), emit a single-event SSE
- * response, and send an empty-body acknowledgement (202 for notifications).
+ * Extension of {@link HttpPort} for the MCP POST handler, which needs to emit a
+ * single-event SSE response and send an empty-body acknowledgement (202 for
+ * notifications).
  *
  * Kept separate from the minimal REST port so third-party adapters only
  * implement these when they wire up MCP. New required members on this interface
  * are still a breaking change for MCP-capable adapters.
  */
 export interface McpHttpPort<TRes> extends HttpPort<TRes> {
-    /** Set a response header. Must be called before `send`/`sendSse`/`sendEmpty`. */
-    setHeader(name: string, value: string): void;
     /** Send a single-event SSE response (status 200): write the pre-serialized body, then end. */
     sendSse(status: number, body: string): TRes;
     /** Send an empty-body response (no JSON), e.g. a 202 notification acknowledgement. */
     sendEmpty(status: number): TRes;
 }
+/**
+ * `Cache-Control` stamped on every REST response.
+ *
+ * Every REST body varies by tenant: `/meta` returns the caller's cube set, and
+ * `/load`, `/sql`, `/dry-run`, `/batch` and `/explain` return that tenant's data
+ * or SQL. With no `Cache-Control` a shared cache may store and reuse these
+ * responses heuristically, which would cross-serve one tenant's cubes to
+ * another. `private` bars shared caches; `no-store` bars storage entirely.
+ */
+export declare const REST_CACHE_CONTROL = "private, no-store";
+/**
+ * Wrap a port so every response it sends carries {@link REST_CACHE_CONTROL}.
+ *
+ * Applied once over the whole REST surface in `createCubeHttpHandler`, not per
+ * route, so no endpoint can forget it — including the 400/500 error paths.
+ * Deliberately NOT applied to MCP: its SSE responses set their own
+ * `Cache-Control`, and JSON-RPC POSTs are not heuristically cacheable.
+ */
+export declare function withRestCacheHeaders<TRes>(port: HttpPort<TRes>): HttpPort<TRes>;

package/dist/cjs/adapters/core/index.d.ts

@@ -6,6 +6,7 @@
  * {@link createCubeHttpHandler}.
  */
 export type { HttpPort, McpHttpPort } from './http-port.js';
+export { withRestCacheHeaders, REST_CACHE_CONTROL } from './http-port.js';
 export { withLocaleFromHeaders, resolveSecurityContext, type HeaderReader, type BaseSecurityContextThunk } from './security-context.js';
 export { createCubeHttpHandler, type CubeHttpHandler, type CubeHttpHandlerOptions } from './cube-http-handler.js';
 export type { RestHandlers } from './rest-handlers.js';

package/dist/cjs/adapters/core/rest-handlers.d.ts

@@ -3,7 +3,7 @@ import { HttpPort } from './http-port.js';
 import { BaseSecurityContextThunk } from './security-context.js';
 /** REST handlers keyed by endpoint; each closes over the shared semantic layer. */
 export interface RestHandlers {
-    handleMetaGet<TRes>(port: HttpPort<TRes>): TRes;
+    handleMetaGet<TRes>(port: HttpPort<TRes>, getBaseSecurityContext: BaseSecurityContextThunk): Promise<TRes>;
     handleSqlGet<TRes>(port: HttpPort<TRes>, getBaseSecurityContext: BaseSecurityContextThunk): Promise<TRes>;
     handleSqlPost<TRes>(port: HttpPort<TRes>, getBaseSecurityContext: BaseSecurityContextThunk): Promise<TRes>;
     handleDryRunGet<TRes>(port: HttpPort<TRes>, getBaseSecurityContext: BaseSecurityContextThunk): Promise<TRes>;

package/dist/cjs/adapters/express/index.d.ts

@@ -2,15 +2,24 @@ import { Router, Request, Response, Express } from 'express';
 import { CorsOptions } from 'cors';
 import { SemanticQuery, SecurityContext, DatabaseExecutor, DrizzleDatabase, Cube, CacheConfig, RLSSetupFn } from '../../server/index.js';
 import { AgentConfig } from '../../server/agent/types.js';
+import { SemanticLayerCompiler } from '../../server/compiler.js';
 import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
 import { MySql2Database } from 'drizzle-orm/mysql2';
 import { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
 import { MCPOptions } from '../utils.js';
 export interface ExpressAdapterOptions {
     /**
-     * Array of cube definitions to register
+     * Pre-configured SemanticLayerCompiler instance.
+     * When provided, skips creating a new compiler and cube registration (caller
+     * manages it). Required to use per-tenant cube sets, since the caller must own
+     * the compiler to call `registerCubeSet` — see docs/per-tenant-cube-sets.md.
      */
-    cubes: Cube[];
+    semanticLayer?: SemanticLayerCompiler;
+    /**
+     * Array of cube definitions to register.
+     * Required unless `semanticLayer` is provided.
+     */
+    cubes?: Cube[];
     /**
      * Drizzle database instance (REQUIRED)
      * This is the core of drizzle-cube - Drizzle ORM integration

package/dist/cjs/adapters/fastify/index.d.ts

@@ -2,15 +2,24 @@ import { FastifyPluginCallback, FastifyRequest, FastifyInstance } from 'fastify'
 import { FastifyCorsOptions } from '@fastify/cors';
 import { SemanticQuery, SecurityContext, DatabaseExecutor, DrizzleDatabase, Cube, CacheConfig, RLSSetupFn } from '../../server/index.js';
 import { AgentConfig } from '../../server/agent/types.js';
+import { SemanticLayerCompiler } from '../../server/compiler.js';
 import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
 import { MySql2Database } from 'drizzle-orm/mysql2';
 import { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
 import { MCPOptions } from '../utils.js';
 export interface FastifyAdapterOptions {
     /**
-     * Array of cube definitions to register
+     * Pre-configured SemanticLayerCompiler instance.
+     * When provided, skips creating a new compiler and cube registration (caller
+     * manages it). Required to use per-tenant cube sets, since the caller must own
+     * the compiler to call `registerCubeSet` — see docs/per-tenant-cube-sets.md.
      */
-    cubes: Cube[];
+    semanticLayer?: SemanticLayerCompiler;
+    /**
+     * Array of cube definitions to register.
+     * Required unless `semanticLayer` is provided.
+     */
+    cubes?: Cube[];
     /**
      * Drizzle database instance (REQUIRED)
      * This is the core of drizzle-cube - Drizzle ORM integration

package/dist/cjs/adapters/mcp-tools-handlers.d.ts

@@ -6,9 +6,16 @@ export interface CubeToolHandlerDeps {
     wrapContent: (result: unknown) => MCPToolResult;
     wrapError: (error: unknown) => MCPToolResult;
 }
-/** Execute the `discover` tool. */
-export declare function runDiscoverTool(deps: CubeToolHandlerDeps, args: unknown): Promise<MCPToolResult>;
-/** Execute the `validate` tool — security context is optional (SQL omitted without auth). */
+/**
+ * Execute the `discover` tool. Reads the caller's cube set, so it resolves a
+ * security context first — discovery has no unauthenticated mode.
+ */
+export declare function runDiscoverTool(deps: CubeToolHandlerDeps, args: unknown, meta?: unknown): Promise<MCPToolResult>;
+/**
+ * Execute the `validate` tool. The security context is required: validation is
+ * against the caller's cube set, so a caller whose context cannot be resolved
+ * gets an error rather than a base-set answer with the SQL omitted.
+ */
 export declare function runValidateTool(deps: CubeToolHandlerDeps, args: unknown, meta?: unknown): Promise<MCPToolResult>;
 /**
  * Execute the `load` / `chart` tools. Both run the same query path; `chart`

package/dist/cjs/adapters/mcp-transport.d.ts

@@ -172,5 +172,16 @@ export declare function resolveMcpResources(resources?: MCPResourceResolver): MC
  *   project-specific guidance like custom cube semantics).
  */
 export declare function resolveMcpInstructions(instructions?: MCPInstructionsResolver): string;
-export declare function buildMcpSchemaResource(semanticLayer: SemanticLayerCompiler): MCPResource;
-export declare function buildMcpResources(semanticLayer: SemanticLayerCompiler, resources?: MCPResourceResolver): MCPResource[];
+/**
+ * The `drizzle-cube://schema` resource: this caller's cube metadata as JSON.
+ *
+ * Its body is tenant-specific, so it must be built per request under the
+ * caller's security context. Building it once at handler construction — as this
+ * used to be — would freeze every tenant's view to the base set.
+ */
+export declare function buildMcpSchemaResource(semanticLayer: SemanticLayerCompiler, securityContext: SecurityContext): MCPResource;
+/**
+ * Static resources plus this caller's schema resource. Call per request, never
+ * at setup time — see {@link buildMcpSchemaResource}.
+ */
+export declare function buildMcpResources(semanticLayer: SemanticLayerCompiler, securityContext: SecurityContext, resources?: MCPResourceResolver): MCPResource[];

package/dist/cjs/adapters/nextjs/index.d.ts

@@ -26,9 +26,12 @@ export interface NextCorsOptions {
 }
 export interface NextAdapterOptions {
     /**
-     * Array of cube definitions to register
+     * Array of cube definitions to register.
+     * Required unless `semanticLayer` is provided — `createSemanticLayer` returns
+     * an injected compiler untouched, so a caller managing their own (which
+     * per-tenant cube sets require) supplies no cubes here.
      */
-    cubes: Cube[];
+    cubes?: Cube[];
     /**
      * Drizzle database instance (REQUIRED)
      * This is the core of drizzle-cube - Drizzle ORM integration

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;
     })[];
 }>;
@@ -354,11 +368,11 @@ export interface ValidateRequest {
 /**
  * Handle /suggest endpoint - generate query from natural language
  */
-export declare function handleSuggest(semanticLayer: SemanticLayerCompiler, body: SuggestRequest): Promise<QuerySuggestion>;
+export declare function handleSuggest(semanticLayer: SemanticLayerCompiler, securityContext: SecurityContext, body: SuggestRequest): Promise<QuerySuggestion>;
 /**
  * Handle /validate endpoint - validate query with corrections
  */
-export declare function handleValidate(semanticLayer: SemanticLayerCompiler, body: ValidateRequest, securityContext?: SecurityContext): Promise<AIValidationResult & {
+export declare function handleValidate(semanticLayer: SemanticLayerCompiler, securityContext: SecurityContext, body: ValidateRequest): Promise<AIValidationResult & {
     sql?: {
         sql: string;
         params?: any[];

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/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;