drizzle-cube 0.2.29 → 0.3.0

package/dist/client/components/AnalysisBuilder/types.d.ts

@@ -1,9 +1,10 @@
 import { MouseEvent, DragEvent } from 'react';
-import { CubeQuery, Filter, ChartType, ChartAxisConfig, ChartDisplayConfig, MultiQueryConfig, QueryMergeStrategy, FunnelBindingKey } from '../../types';
+import { CubeQuery, Filter, ChartType, ChartAxisConfig, ChartDisplayConfig, MultiQueryConfig, QueryMergeStrategy, FunnelBindingKey, AnalysisType, FunnelStepState } from '../../types';
 import { ColorPalette } from '../../utils/colorPalettes';
 import { MetaResponse, MetaField, MetaCube, QueryAnalysis } from '../../shared/types';
 import { ChartAvailabilityMap } from '../../shared/chartDefaults';
 import { MultiQueryValidationResult } from '../../utils/multiQueryValidation';
+import { ValidationResult } from '../../adapters/modeAdapter';
 export type { MetaResponse, MetaField, MetaCube, QueryAnalysis };
 /**
  * A selected metric (measure) with a letter label (A, B, C, ...)
@@ -76,12 +77,20 @@ export interface AIState {
         chartType: ChartType;
         chartConfig: ChartAxisConfig;
         displayConfig: ChartDisplayConfig;
+        /** Analysis type for restoring mode on cancel */
+        analysisType?: AnalysisType;
     } | null;
+    /** Full AnalysisConfig snapshot for complete restore (handles funnel mode properly) */
+    previousConfig?: import('../../types/analysisConfig').AnalysisConfig | null;
 }
 /**
  * Mode for the field search modal - determines which field types are shown
+ * - 'metrics': Only measures
+ * - 'breakdown': Only dimensions (including time dimensions)
+ * - 'filter': Both measures and dimensions
+ * - 'dimensionFilter': Only dimensions (for funnel step filters where measures don't work)
  */
-export type FieldSearchMode = 'metrics' | 'breakdown' | 'filter';
+export type FieldSearchMode = 'metrics' | 'breakdown' | 'filter' | 'dimensionFilter';
 /**
  * Field type categorization
  */
@@ -150,6 +159,10 @@ export interface FieldDetailPanelProps {
  * Tab options for the query panel
  */
 export type QueryPanelTab = 'query' | 'chart' | 'display';
+/**
+ * Tab options for the funnel panel
+ */
+export type FunnelPanelTab = 'steps' | 'display';
 /**
  * Props for the AnalysisQueryPanel component
  */
@@ -214,10 +227,42 @@ export interface AnalysisQueryPanelProps {
     combinedBreakdowns?: BreakdownItem[];
     /** Validation result for multi-query mode (errors and warnings) */
     multiQueryValidation?: MultiQueryValidationResult | null;
+    /** Validation result from adapter (NEW - Phase 5) */
+    adapterValidation?: ValidationResult | null;
     /** Binding key dimension that links funnel steps together */
     funnelBindingKey?: FunnelBindingKey | null;
     /** Callback when funnel binding key changes */
     onFunnelBindingKeyChange?: (bindingKey: FunnelBindingKey | null) => void;
+    /** Current analysis type (query, multi, funnel) */
+    analysisType?: AnalysisType;
+    /** Callback when analysis type changes */
+    onAnalysisTypeChange?: (type: AnalysisType) => void;
+    /** Selected cube for funnel mode (all steps use this cube) */
+    funnelCube?: string | null;
+    /** Dedicated funnel steps (separate from queryStates) */
+    funnelSteps?: FunnelStepState[];
+    /** Index of currently active funnel step */
+    activeFunnelStepIndex?: number;
+    /** Time dimension for funnel temporal ordering */
+    funnelTimeDimension?: string | null;
+    /** Callback when funnel cube changes */
+    onFunnelCubeChange?: (cube: string | null) => void;
+    /** Add a new funnel step */
+    onAddFunnelStep?: () => void;
+    /** Remove a funnel step by index */
+    onRemoveFunnelStep?: (index: number) => void;
+    /** Update a funnel step by index */
+    onUpdateFunnelStep?: (index: number, updates: Partial<FunnelStepState>) => void;
+    /** Set the active funnel step index */
+    onSelectFunnelStep?: (index: number) => void;
+    /** Reorder funnel steps */
+    onReorderFunnelSteps?: (fromIndex: number, toIndex: number) => void;
+    /** Set the time dimension for funnel */
+    onFunnelTimeDimensionChange?: (dimension: string | null) => void;
+    /** Funnel display config (for Display tab in funnel mode) */
+    funnelDisplayConfig?: ChartDisplayConfig;
+    /** Callback when funnel display config changes */
+    onFunnelDisplayConfigChange?: (config: ChartDisplayConfig) => void;
 }
 /**
  * Props for the AnalysisResultsPanel component
@@ -295,6 +340,32 @@ export interface AnalysisResultsPanelProps {
     activeTableIndex?: number;
     /** Callback when active table changes */
     onActiveTableChange?: (index: number) => void;
+    /** Current analysis type (query or funnel) - primary way to detect mode */
+    analysisType?: AnalysisType;
+    /**
+     * Whether in funnel mode (always show unified results, no per-query tables)
+     * @deprecated Use analysisType === 'funnel' instead
+     */
+    isFunnelMode?: boolean;
+    /**
+     * The actual server funnel query { funnel: {...} } sent to the server.
+     * Use this for debug display instead of per-query debug data.
+     */
+    funnelServerQuery?: unknown;
+    /**
+     * Unified debug data for funnel queries (SQL, analysis, loading/error state).
+     * Contains the CTE-based SQL for the entire funnel.
+     */
+    funnelDebugData?: {
+        sql: {
+            sql: string;
+            params: unknown[];
+        } | null;
+        analysis: unknown;
+        loading: boolean;
+        error: Error | null;
+        funnelMetadata?: unknown;
+    } | null;
 }
 /**
  * Props for the MetricsSection component
@@ -418,6 +489,18 @@ export interface BreakdownItemCardProps {
     /** Drag end handler */
     onDragEnd?: () => void;
 }
+/**
+ * Initial funnel state for AnalysisBuilder (matches InitialFunnelState in store)
+ */
+export interface AnalysisBuilderInitialFunnelState {
+    funnelCube?: string | null;
+    funnelSteps?: FunnelStepState[];
+    funnelTimeDimension?: string | null;
+    funnelBindingKey?: FunnelBindingKey | null;
+    funnelChartType?: ChartType;
+    funnelChartConfig?: ChartAxisConfig;
+    funnelDisplayConfig?: ChartDisplayConfig;
+}
 /**
  * Props for the main AnalysisBuilder component
  */
@@ -438,6 +521,10 @@ export interface AnalysisBuilderProps {
         chartConfig?: ChartAxisConfig;
         displayConfig?: ChartDisplayConfig;
     };
+    /** Initial analysis type (query or funnel) - defaults to 'query' */
+    initialAnalysisType?: AnalysisType;
+    /** Initial funnel state (when initialAnalysisType === 'funnel') */
+    initialFunnelState?: AnalysisBuilderInitialFunnelState;
     /** Initial data to display (avoids re-fetching when editing existing portlets) */
     initialData?: any[];
     /** Color palette for chart visualization */
@@ -455,22 +542,46 @@ export interface AnalysisBuilderProps {
         displayConfig: ChartDisplayConfig;
     }) => void;
 }
+/**
+ * Funnel state returned by getFunnelState
+ */
+export interface FunnelStateSnapshot {
+    funnelCube: string | null;
+    funnelSteps: FunnelStepState[];
+    funnelTimeDimension: string | null;
+    funnelBindingKey: FunnelBindingKey | null;
+    funnelChartType: ChartType;
+    funnelChartConfig: ChartAxisConfig;
+    funnelDisplayConfig: ChartDisplayConfig;
+    activeFunnelStepIndex: number;
+}
 /**
  * Ref interface for AnalysisBuilder (for external access)
  */
 export interface AnalysisBuilderRef {
     /**
      * Get the current query configuration.
-     * Returns either a CubeQuery (single query) or MultiQueryConfig (multiple queries).
+     * Returns CubeQuery (single query), MultiQueryConfig (multiple queries), or ServerFunnelQuery (funnel mode).
      * Consumers should just JSON.stringify the result - no need to check the type.
+     * @deprecated Use getAnalysisConfig() for Phase 3+ integrations
      */
-    getQueryConfig: () => CubeQuery | MultiQueryConfig;
+    getQueryConfig: () => CubeQuery | MultiQueryConfig | import('../../types/funnel').ServerFunnelQuery;
     /** Get current chart configuration */
     getChartConfig: () => {
         chartType: ChartType;
         chartConfig: ChartAxisConfig;
         displayConfig: ChartDisplayConfig;
     };
+    /** Get the current analysis type (query or funnel) */
+    getAnalysisType: () => AnalysisType;
+    /** Get the current funnel state (for persisting funnel mode configuration) */
+    getFunnelState: () => FunnelStateSnapshot;
+    /**
+     * Phase 3: Get the complete AnalysisConfig.
+     * This is the canonical format for persisting analysis state.
+     * Replaces getQueryConfig + getChartConfig + getAnalysisType.
+     */
+    getAnalysisConfig: () => import('../../types/analysisConfig').AnalysisConfig;
     /** Execute the current query */
     executeQuery: () => void;
     /** Clear the current query */
@@ -493,6 +604,10 @@ export interface AnalysisBuilderStorageState {
     mergeStrategy?: QueryMergeStrategy;
     /** Dimension keys used for merging in 'merge' strategy */
     mergeKeys?: string[];
+    /** Binding key for funnel strategy (links steps together) */
+    funnelBindingKey?: FunnelBindingKey | null;
+    /** Time window per step for funnel strategy (ISO 8601 duration) */
+    stepTimeToConvert?: (string | null)[];
 }
 /**
  * Recent fields storage shape

package/dist/client/components/AnalysisBuilder/utils/fieldUtils.d.ts

@@ -27,7 +27,7 @@ export declare function getFieldType(field: MetaField): FieldType;
 /**
  * Convert schema to flat list of field options
  */
-export declare function schemaToFieldOptions(schema: MetaResponse | null, mode: 'metrics' | 'breakdown' | 'filter'): FieldOption[];
+export declare function schemaToFieldOptions(schema: MetaResponse | null, mode: 'metrics' | 'breakdown' | 'filter' | 'dimensionFilter'): FieldOption[];
 /**
  * Filter field options by search term
  */
@@ -44,3 +44,21 @@ export declare function getCubeNames(schema: MetaResponse | null): string[];
  * Get cube title by name
  */
 export declare function getCubeTitle(cubeName: string, schema: MetaResponse | null): string;
+/**
+ * Get all cubes reachable from a source cube via join relationships
+ * Includes the source cube itself plus all cubes it has joins to
+ *
+ * @param sourceCube - Name of the cube to find related cubes for
+ * @param schema - Full schema with all cubes
+ * @returns Set of cube names that are reachable from the source
+ */
+export declare function getRelatedCubeNames(sourceCube: string, schema: MetaResponse | null): Set<string>;
+/**
+ * Filter schema to include only cubes reachable from a source cube
+ * This is used for funnel step filters where cross-cube filtering is supported
+ *
+ * @param sourceCube - Name of the cube to find related cubes for
+ * @param schema - Full schema with all cubes
+ * @returns Filtered schema containing only reachable cubes
+ */
+export declare function getRelatedCubesSchema(sourceCube: string, schema: MetaResponse | null): MetaResponse | null;

package/dist/client/components/AnalysisBuilder/utils/recentFieldsUtils.d.ts

@@ -11,4 +11,4 @@ export declare function addRecentField(fieldName: string, mode: 'metrics' | 'bre
 /**
  * Get recent field options from schema
  */
-export declare function getRecentFieldOptions(schema: MetaResponse | null, mode: 'metrics' | 'breakdown' | 'filter', recentFieldNames: string[]): FieldOption[];
+export declare function getRecentFieldOptions(schema: MetaResponse | null, mode: 'metrics' | 'breakdown' | 'filter' | 'dimensionFilter', recentFieldNames: string[]): FieldOption[];

package/dist/client/components/AnalysisBuilder/utils/storageUtils.d.ts

@@ -1,6 +1,8 @@
 import { Filter } from '../../../types';
 import { MetricItem, BreakdownItem, AnalysisBuilderState, AnalysisBuilderStorageState } from '../types';
-export declare const STORAGE_KEY = "drizzle-cube-analysis-builder-state";
+export declare const STORAGE_KEY = "drizzle-cube-analysis-builder-v3";
+/** @deprecated Use STORAGE_KEY instead */
+export declare const STORAGE_KEY_V2 = "drizzle-cube-analysis-builder-v2";
 /**
  * Create initial empty state for AnalysisBuilder
  *

package/dist/client/components/ChartTypeSelector.d.ts

@@ -8,6 +8,8 @@ interface ChartTypeSelectorProps {
     compact?: boolean;
     /** Map of chart type availability - when provided, unavailable charts are disabled */
     availability?: ChartAvailabilityMap;
+    /** Chart types to exclude from the list (e.g., ['funnel'] to hide funnel in query mode) */
+    excludeTypes?: ChartType[];
 }
-export default function ChartTypeSelector({ selectedType, onTypeChange, className, compact, availability }: ChartTypeSelectorProps): import("react/jsx-runtime").JSX.Element;
+export default function ChartTypeSelector({ selectedType, onTypeChange, className, compact, availability, excludeTypes }: ChartTypeSelectorProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/client/components.js

@@ -1,5 +1,5 @@
-import { a as s, A as t, c as r, D as o, M as d, P as i, Q as l } from "./chunks/components-CCRoi0sB.js";
-import { c, j as u, h as y, e as P, d as b, v as h } from "./chunks/charts-Cr9ec7VQ.js";
+import { a as s, A as t, c as r, D as o, M as d, P as i, Q as l } from "./chunks/components-Bq8GLyiY.js";
+import { c, j as u, h as y, e as P, d as b, v as h } from "./chunks/charts-CdOqkTEj.js";
 export {
   s as AnalyticsDashboard,
   t as AnalyticsPortlet,

package/dist/client/hooks/queries/index.d.ts

@@ -12,5 +12,5 @@
 export { useCubeMetaQuery, prefetchCubeMeta, CUBE_META_QUERY_KEY, type UseCubeMetaQueryOptions, type UseCubeMetaQueryResult, } from './useCubeMetaQuery';
 export { useCubeLoadQuery, useCubeLoadQuery as useCubeQuery, createQueryKey, type UseCubeLoadQueryOptions, type UseCubeLoadQueryResult, } from './useCubeLoadQuery';
 export { useMultiCubeLoadQuery, createMultiQueryKey, type UseMultiCubeLoadQueryOptions, type UseMultiCubeLoadQueryResult, } from './useMultiCubeLoadQuery';
-export { useDryRunQuery, useMultiDryRunQueries, useDryRunQueries, createDryRunQueryKey, type DebugDataEntry, type UseDryRunQueryOptions, type UseDryRunQueryResult, type UseMultiDryRunQueriesOptions, type UseMultiDryRunQueriesResult, } from './useDryRunQuery';
+export { useDryRunQuery, useMultiDryRunQueries, useDryRunQueries, useFunnelDryRunQuery, createDryRunQueryKey, type DebugDataEntry, type FunnelDebugDataEntry, type UseDryRunQueryOptions, type UseDryRunQueryResult, type UseMultiDryRunQueriesOptions, type UseMultiDryRunQueriesResult, } from './useDryRunQuery';
 export { useFunnelQuery, createFunnelQueryKey, } from './useFunnelQuery';

package/dist/client/hooks/queries/useDryRunQuery.d.ts

@@ -101,3 +101,32 @@ export declare function useDryRunQueries(options: {
     skip?: boolean;
     staleTime?: number;
 }): UseMultiDryRunQueriesResult;
+/**
+ * Debug data entry for funnel queries
+ */
+export interface FunnelDebugDataEntry extends DebugDataEntry {
+    /** Funnel-specific metadata from server */
+    funnelMetadata?: {
+        stepCount: number;
+        steps: Array<{
+            index: number;
+            name: string;
+            timeToConvert?: string;
+            cube?: string;
+        }>;
+        bindingKey: unknown;
+        timeDimension: unknown;
+    };
+}
+/**
+ * TanStack Query hook for funnel query dry-run (debug) data
+ *
+ * Usage:
+ * ```tsx
+ * const { debugData } = useFunnelDryRunQuery(serverQuery, { skip: !isFunnelMode })
+ * ```
+ */
+export declare function useFunnelDryRunQuery(serverQuery: unknown | null, options?: UseDryRunQueryOptions): {
+    debugData: FunnelDebugDataEntry;
+    refetch: () => void;
+};

package/dist/client/hooks/queries/useFunnelQuery.d.ts

@@ -1,25 +1,20 @@
 import { FunnelConfig, UseFunnelQueryOptions, UseFunnelQueryResult } from '../../types/funnel';
 /**
- * Hook for sequential funnel query execution
+ * Hook for server-side funnel query execution
  *
  * Usage:
  * ```tsx
- * const { result, isExecuting, execute, stepResults, chartData } = useFunnelQuery(config, {
+ * const { chartData, isExecuting, error } = useFunnelQuery(config, {
  *   debounceMs: 300,
  *   skip: !hasBindingKey
  * })
  *
- * // Results show progressively as each step completes
- * {stepResults.map((step, i) => (
- *   <div key={i}>
- *     {step.stepName}: {step.count} ({step.conversionRate}% from previous)
- *   </div>
- * ))}
+ * // Results available after single server request
+ * <FunnelChart data={chartData} />
  * ```
  */
 export declare function useFunnelQuery(config: FunnelConfig | null, options?: UseFunnelQueryOptions): UseFunnelQueryResult;
 /**
  * Create a stable query key for funnel queries
- * (useful if we want to integrate with TanStack Query in the future)
  */
 export declare function createFunnelQueryKey(config: FunnelConfig | null): readonly unknown[];

package/dist/client/hooks/useAnalysisAI.d.ts

@@ -1,5 +1,7 @@
 import { AnalysisBuilderState, AIState } from '../components/AnalysisBuilder/types';
 import { ChartType, ChartAxisConfig, ChartDisplayConfig } from '../types';
+import { ServerFunnelQuery } from '../types/funnel';
+import { AnalysisType, AnalysisConfig } from '../types/analysisConfig';
 interface UseAnalysisAIOptions {
     /** Current state for snapshotting */
     state: AnalysisBuilderState;
@@ -23,6 +25,16 @@ interface UseAnalysisAIOptions {
     setActiveView: (view: 'table' | 'chart') => void;
     /** AI endpoint URL */
     aiEndpoint?: string;
+    /** Current analysis type */
+    analysisType?: AnalysisType;
+    /** Set analysis type (for switching to funnel mode) */
+    setAnalysisType?: (type: AnalysisType) => void;
+    /** Load funnel config from ServerFunnelQuery */
+    loadFunnelFromServerQuery?: (query: ServerFunnelQuery) => void;
+    /** Get full AnalysisConfig for snapshotting (for complete undo) */
+    getFullConfig?: () => AnalysisConfig;
+    /** Load full AnalysisConfig (for restoring on cancel) */
+    loadFullConfig?: (config: AnalysisConfig) => void;
 }
 interface UseAnalysisAIResult {
     /** Current AI state */
@@ -40,5 +52,5 @@ interface UseAnalysisAIResult {
     /** Cancel and restore previous state */
     handleCancelAI: () => void;
 }
-export declare function useAnalysisAI({ state, setState, chartType, setChartType, chartConfig, setChartConfig, displayConfig, setDisplayConfig, setUserManuallySelectedChart, setActiveView, aiEndpoint }: UseAnalysisAIOptions): UseAnalysisAIResult;
+export declare function useAnalysisAI({ state, setState, chartType, setChartType, chartConfig, setChartConfig, displayConfig, setDisplayConfig, setUserManuallySelectedChart, setActiveView, aiEndpoint, analysisType, setAnalysisType, loadFunnelFromServerQuery, getFullConfig, loadFullConfig }: UseAnalysisAIOptions): UseAnalysisAIResult;
 export {};

package/dist/client/hooks/useAnalysisBuilderHook.d.ts

@@ -1,10 +1,11 @@
 import { ColorPalette } from '../utils/colorPalettes';
-import { CubeQuery, MultiQueryConfig, ChartType, ChartAxisConfig, ChartDisplayConfig, Filter, QueryMergeStrategy, FunnelBindingKey } from '../types';
+import { CubeQuery, MultiQueryConfig, ChartType, ChartAxisConfig, ChartDisplayConfig, Filter, QueryMergeStrategy, FunnelBindingKey, AnalysisType, FunnelStepState } from '../types';
 import { AnalysisBuilderState, MetricItem, BreakdownItem, ExecutionStatus, QueryPanelTab } from '../components/AnalysisBuilder/types';
 import { ChartAvailabilityMap } from '../shared/chartDefaults';
 import { DebugDataEntry } from './queries';
 import { MultiQueryValidationResult } from '../utils/multiQueryValidation';
 import { MetaField } from '../shared/types';
+import { ValidationResult } from '../adapters/modeAdapter';
 export interface UseAnalysisBuilderOptions {
     /** External color palette (overrides local) */
     externalColorPalette?: string[] | ColorPalette;
@@ -31,6 +32,24 @@ export interface UseAnalysisBuilderResult {
     multiQueryConfig: MultiQueryConfig | null;
     multiQueryValidation: MultiQueryValidationResult | null;
     funnelBindingKey: FunnelBindingKey | null;
+    /** Whether funnel mode is properly configured and ready for execution */
+    isFunnelModeEnabled: boolean;
+    /** Current analysis type (query, multi, funnel) */
+    analysisType: AnalysisType;
+    /** Selected cube for funnel mode (all steps use this cube) */
+    funnelCube: string | null;
+    /** Dedicated funnel steps (when analysisType === 'funnel') */
+    funnelSteps: FunnelStepState[];
+    /** Index of currently active funnel step */
+    activeFunnelStepIndex: number;
+    /** Time dimension for funnel temporal ordering */
+    funnelTimeDimension: string | null;
+    /** Chart type for funnel mode (separate from query mode) */
+    funnelChartType: ChartType;
+    /** Chart config for funnel mode (separate from query mode) */
+    funnelChartConfig: ChartAxisConfig;
+    /** Display config for funnel mode (separate from query mode) */
+    funnelDisplayConfig: ChartDisplayConfig;
     executionStatus: ExecutionStatus;
     executionResults: unknown[] | null;
     perQueryResults: (unknown[] | null)[] | null;
@@ -41,6 +60,19 @@ export interface UseAnalysisBuilderResult {
     debugDataPerQuery: DebugDataEntry[];
     /** In funnel mode, the actually executed queries with binding key dimension and IN filters */
     funnelExecutedQueries: CubeQuery[] | null;
+    /** In funnel mode, the actual server query { funnel: {...} } sent to the API */
+    funnelServerQuery: unknown | null;
+    /** In funnel mode, unified debug data (SQL, analysis, funnel metadata) */
+    funnelDebugData: {
+        sql: {
+            sql: string;
+            params: unknown[];
+        } | null;
+        analysis: unknown | null;
+        loading: boolean;
+        error: Error | null;
+        funnelMetadata?: unknown;
+    } | null;
     chartType: ChartType;
     chartConfig: ChartAxisConfig;
     displayConfig: ChartDisplayConfig;
@@ -66,6 +98,8 @@ export interface UseAnalysisBuilderResult {
     };
     shareButtonState: 'idle' | 'copied' | 'copied-no-chart';
     canShare: boolean;
+    /** Validation result from the adapter for the current analysis type */
+    adapterValidation: ValidationResult;
     actions: {
         setActiveQueryIndex: (index: number) => void;
         setMergeStrategy: (strategy: QueryMergeStrategy) => void;
@@ -87,6 +121,15 @@ export interface UseAnalysisBuilderResult {
         addQuery: () => void;
         removeQuery: (index: number) => void;
         setFunnelBindingKey: (bindingKey: FunnelBindingKey | null) => void;
+        setAnalysisType: (type: AnalysisType) => void;
+        setFunnelCube: (cube: string | null) => void;
+        addFunnelStep: () => void;
+        removeFunnelStep: (index: number) => void;
+        updateFunnelStep: (index: number, updates: Partial<FunnelStepState>) => void;
+        setActiveFunnelStepIndex: (index: number) => void;
+        reorderFunnelSteps: (fromIndex: number, toIndex: number) => void;
+        setFunnelTimeDimension: (dimension: string | null) => void;
+        setFunnelDisplayConfig: (config: ChartDisplayConfig) => void;
         setChartType: (type: ChartType) => void;
         setChartConfig: (config: ChartAxisConfig) => void;
         setDisplayConfig: (config: ChartDisplayConfig) => void;
@@ -104,14 +147,16 @@ export interface UseAnalysisBuilderResult {
         cancelAI: () => void;
         share: () => Promise<void>;
         clearQuery: () => void;
+        clearCurrentMode: () => void;
         refetch: () => void;
         handleFieldSelected: (field: MetaField, fieldType: 'measure' | 'dimension' | 'timeDimension', cubeName: string, keepOpen?: boolean) => void;
     };
-    getQueryConfig: () => CubeQuery | MultiQueryConfig;
+    getQueryConfig: () => CubeQuery | MultiQueryConfig | import('../types/funnel').ServerFunnelQuery;
     getChartConfig: () => {
         chartType: ChartType;
         chartConfig: ChartAxisConfig;
         displayConfig: ChartDisplayConfig;
     };
+    getAnalysisType: () => AnalysisType;
 }
 export declare function useAnalysisBuilder(options?: UseAnalysisBuilderOptions): UseAnalysisBuilderResult;

package/dist/client/hooks/useAnalysisQueryExecution.d.ts

@@ -1,6 +1,7 @@
-import { DebugDataEntry } from './queries';
-import { CubeQuery, MultiQueryConfig, FunnelBindingKey, QueryMergeStrategy } from '../types';
+import { DebugDataEntry, FunnelDebugDataEntry } from './queries';
+import { CubeQuery, MultiQueryConfig, FunnelBindingKey, QueryMergeStrategy, AnalysisType } from '../types';
 import { ExecutionStatus } from '../components/AnalysisBuilder/types';
+import { ServerFunnelQuery } from '../types/funnel';
 export interface UseAnalysisQueryExecutionOptions {
     /** Current query (for single-query mode) */
     currentQuery: CubeQuery;
@@ -14,10 +15,26 @@ export interface UseAnalysisQueryExecutionOptions {
     isValidQuery: boolean;
     /** Initial data (skip first fetch) */
     initialData?: unknown[];
-    /** Merge strategy (for detecting funnel mode) */
+    /** Merge strategy (for detecting funnel mode - legacy) */
     mergeStrategy?: QueryMergeStrategy;
     /** Funnel binding key (required for funnel mode) */
     funnelBindingKey?: FunnelBindingKey | null;
+    /**
+     * Whether funnel mode is properly configured (from store).
+     * This includes filter-only step validation that isMultiQueryMode doesn't provide.
+     * @deprecated Use analysisType === 'funnel' instead
+     */
+    isFunnelModeEnabled?: boolean;
+    /**
+     * Analysis type for explicit mode routing.
+     * When provided, takes precedence over legacy mode detection.
+     */
+    analysisType?: AnalysisType;
+    /**
+     * Pre-built server funnel query from store's buildFunnelQueryFromSteps().
+     * Used when analysisType === 'funnel' with the new dedicated funnel state.
+     */
+    serverFunnelQuery?: ServerFunnelQuery | null;
 }
 export interface UseAnalysisQueryExecutionResult {
     /** Query execution status */
@@ -32,7 +49,7 @@ export interface UseAnalysisQueryExecutionResult {
     isFetching: boolean;
     /** Query error */
     error: Error | null;
-    /** Debug data per query */
+    /** Debug data per query (for non-funnel modes) */
     debugDataPerQuery: DebugDataEntry[];
     /** Whether query has been debounced (for smart defaults trigger) */
     hasDebounced: boolean;
@@ -43,7 +60,18 @@ export interface UseAnalysisQueryExecutionResult {
      * - Binding key dimension auto-added
      * - IN filter applied for steps 2+
      * Use these for debug display instead of the original queries.
+     * @deprecated Server-side funnel uses a unified query. Use funnelServerQuery instead.
      */
     funnelExecutedQueries: CubeQuery[] | null;
+    /**
+     * The actual server funnel query { funnel: {...} }
+     * This is the unified query sent to the server (not per-step queries).
+     */
+    funnelServerQuery: ServerFunnelQuery | null;
+    /**
+     * Debug data specifically for funnel mode
+     * Contains the funnel SQL and funnel-specific metadata
+     */
+    funnelDebugData: FunnelDebugDataEntry | null;
 }
 export declare function useAnalysisQueryExecution(options: UseAnalysisQueryExecutionOptions): UseAnalysisQueryExecutionResult;

package/dist/client/hooks/useAnalysisShare.d.ts

@@ -1,17 +1,12 @@
-import { CubeQuery, ChartType, ChartAxisConfig, ChartDisplayConfig, MultiQueryConfig } from '../types';
+import { AnalysisConfig } from '../types/analysisConfig';
 interface UseAnalysisShareOptions {
     /** Whether the current query is valid */
     isValidQuery: boolean;
-    /** Getter for the query config (matches AnalysisBuilder save format) */
-    getQueryConfig: () => CubeQuery | MultiQueryConfig;
-    /** Current chart type */
-    chartType: ChartType;
-    /** Current chart config */
-    chartConfig: ChartAxisConfig;
-    /** Current display config */
-    displayConfig: ChartDisplayConfig;
-    /** Current active view */
-    activeView: 'table' | 'chart';
+    /**
+     * Getter for the AnalysisConfig (from store.save())
+     * This is the new Phase 3 API - returns complete AnalysisConfig
+     */
+    getAnalysisConfig: () => AnalysisConfig;
 }
 interface UseAnalysisShareResult {
     /** Current share button state */
@@ -19,5 +14,5 @@ interface UseAnalysisShareResult {
     /** Handle share button click */
     handleShare: () => Promise<void>;
 }
-export declare function useAnalysisShare({ isValidQuery, getQueryConfig, chartType, chartConfig, displayConfig, activeView }: UseAnalysisShareOptions): UseAnalysisShareResult;
+export declare function useAnalysisShare({ isValidQuery, getAnalysisConfig, }: UseAnalysisShareOptions): UseAnalysisShareResult;
 export {};

package/dist/client/hooks.js

@@ -1,13 +1,13 @@
-import { u as s, u as a, r, z as t, d as y, b as o, t as i, a as b, c as Q, y as n } from "./chunks/hooks-CM78mXuP.js";
-import { f as d } from "./chunks/charts-nP6WCxHG.js";
+import { u as s, u as a, s as r, A as o, d as t, b as y, w as i, a as b, c as Q, z as n } from "./chunks/hooks-BVB4L4sl.js";
+import { f as d } from "./chunks/charts-BudebcSn.js";
 export {
   s as useCubeLoadQuery,
   d as useCubeMetaQuery,
   a as useCubeQuery,
   r as useDebounce,
-  t as useDirtyStateTracking,
-  y as useDryRunQueries,
-  o as useDryRunQuery,
+  o as useDirtyStateTracking,
+  t as useDryRunQueries,
+  y as useDryRunQuery,
   i as useFilterValues,
   b as useMultiCubeLoadQuery,
   Q as useMultiDryRunQueries,

package/dist/client/icons.js

@@ -1,12 +1,12 @@
-import { D as a, y as t, z as o, m as n, n as I, t as c, v as g, x as r, p as y, q as p, o as T } from "./chunks/charts-nP6WCxHG.js";
+import { I as a, G as t, H as o, x as I, y as c, D as g, E as n, F as r, A as y, B as p, z as T } from "./chunks/charts-BudebcSn.js";
 export {
   a as DEFAULT_ICONS,
   t as getChartTypeIcon,
   o as getFieldTypeIcon,
-  n as getIcon,
-  I as getIconData,
-  c as getIconRegistry,
-  g as getIconsByCategory,
+  I as getIcon,
+  c as getIconData,
+  g as getIconRegistry,
+  n as getIconsByCategory,
   r as getMeasureTypeIcon,
   y as registerIcons,
   p as resetIcons,

package/dist/client/index.d.ts

@@ -25,7 +25,7 @@ export type { UseAnalysisBuilderOptions, UseAnalysisBuilderResult, } from './hoo
 export { useDashboard } from './hooks/useDashboardHook';
 export type { UseDashboardOptions, UseDashboardResult, UseDashboardActions, } from './hooks/useDashboardHook';
 export { useAnalysisBuilderStore, selectCurrentState, selectMetrics, selectBreakdowns, selectFilters, selectChartConfig, selectUIState, selectMultiQueryState, selectFunnelState, } from './stores/analysisBuilderStore';
-export type { AnalysisBuilderStore, AnalysisBuilderStoreState, AnalysisBuilderStoreActions, FieldModalMode, SharedState, } from './stores/analysisBuilderStore';
+export type { AnalysisBuilderStore, AnalysisBuilderStoreState, AnalysisBuilderStoreActions, FieldModalMode, } from './stores/analysisBuilderStore';
 export { DashboardStoreProvider, useDashboardStore, useDashboardStoreApi, useDashboardStoreOptional, createDashboardStore, selectEditModeState, selectModalState, selectLayoutState, selectDebugData, selectPortletDebugData, selectEditModeActions, selectModalActions, selectLayoutActions, selectDebugDataActions, selectAllActions, } from './stores/dashboardStore';
 export type { DashboardStore, DashboardStoreState, DashboardStoreActions, PortletDebugDataEntry, DragState, CreateDashboardStoreOptions, DashboardStoreProviderProps, } from './stores/dashboardStore';
 export { validateMultiQueryConfig, validateTimeDimensionAlignment, validateMergeKeys, detectMeasureCollisions, detectAsymmetricDateRanges, isMultiQueryValid, getValidationSummary } from './utils/multiQueryValidation';
@@ -39,7 +39,7 @@ export type { ChartTypeConfig, DisplayOptionConfig, AxisDropZoneConfig } from '.
 export { createDashboardLayout, formatChartData, highlightCodeBlocks } from './utils/index';
 export { isMultiQueryData, mergeQueryResults, mergeResultsConcat, mergeResultsByKey, getCombinedFields, getQueryLabels, getQueryIndices, generateQueryLabel, validateMergeKey } from './utils/multiQueryUtils';
 export { validateFunnelConfig, validateBindingKeyExists, validateStepQueries, validateBindingKeyForSteps, isMinimumFunnelConfigValid, getAvailableBindingKeyDimensions, getBindingKeyLabel, } from './utils/funnelValidation';
-export { getBindingKeyField, extractBindingKeyValues, buildStepQuery, buildFunnelConfigFromQueries, buildFunnelChartData, isFunnelData, } from './utils/funnelExecution';
+export { getBindingKeyField, getCubeNameFromQuery, formatDuration, transformServerFunnelResult, buildServerFunnelQuery, isFunnelData, buildFunnelConfigFromQueries, } from './utils/funnelExecution';
 export { getThemeVariable, setThemeVariable, applyTheme, resetTheme, getTheme, setTheme, isDarkMode, watchThemeChanges, THEME_PRESETS } from './theme';
 export type { ThemeColorTokens, ThemeConfig, Theme } from './theme';
 export { getIcon, getIconData, setIcon, registerIcons, resetIcons, getIconRegistry, getIconsByCategory, getMeasureTypeIcon, getChartTypeIcon, getFieldTypeIcon, DEFAULT_ICONS } from './icons';