drizzle-cube 0.3.13 → 0.3.15

package/dist/client/chunks/analysis-builder-shared-gS0TDC6Y.js

@@ -0,0 +1,2779 @@
+import { useContext as it, createContext as vn, useRef as me, useMemo as F, useCallback as E, useEffect as fe, useState as bn } from "react";
+import { u as Dn, f as Tn } from "./providers-BW8D7Wso.js";
+import { jsx as Fn } from "react/jsx-runtime";
+import { c as Qn, d as Ge, e as Oe, s as He, p as An, f as Rn, l as rt } from "./vendor-BSkQZgtm.js";
+import { d as Mn, R as xn, a as qn, g as kn, D as Bn } from "./retention-CzCo8262.js";
+import { H as K, I as ye, J as O, K as H, L as j, N as In, O as st, u as Vn, f as En, R as Un, S as Pn } from "./components-DQuPThfA.js";
+import { F as je, b as We } from "./flow-utils-CjQZG5qq.js";
+import { h as _n, u as Kn, a as Ln } from "./useDirtyStateTracking-Yu_qQXb-.js";
+import { c as $n, a as at } from "./funnel-utils-CyonoNeC.js";
+import { b as Nn, c as Gn, d as On, e as Hn } from "./hooks-DPRv1Xhb.js";
+function jn(n) {
+  const r = /* @__PURE__ */ new Date(), e = n.toLowerCase().trim(), t = r.getUTCFullYear(), i = r.getUTCMonth(), s = r.getUTCDate(), o = r.getUTCDay();
+  if (e === "today") {
+    const g = new Date(r);
+    g.setUTCHours(0, 0, 0, 0);
+    const c = new Date(r);
+    return c.setUTCHours(23, 59, 59, 999), { start: g, end: c };
+  }
+  if (e === "yesterday") {
+    const g = new Date(r);
+    g.setUTCDate(s - 1), g.setUTCHours(0, 0, 0, 0);
+    const c = new Date(r);
+    return c.setUTCDate(s - 1), c.setUTCHours(23, 59, 59, 999), { start: g, end: c };
+  }
+  if (e === "this week") {
+    const g = o === 0 ? -6 : 1 - o, c = new Date(r);
+    c.setUTCDate(s + g), c.setUTCHours(0, 0, 0, 0);
+    const p = new Date(c);
+    return p.setUTCDate(c.getUTCDate() + 6), p.setUTCHours(23, 59, 59, 999), { start: c, end: p };
+  }
+  if (e === "this month") {
+    const g = new Date(Date.UTC(t, i, 1, 0, 0, 0, 0)), c = new Date(Date.UTC(t, i + 1, 0, 23, 59, 59, 999));
+    return { start: g, end: c };
+  }
+  if (e === "this quarter") {
+    const g = Math.floor(i / 3), c = new Date(Date.UTC(t, g * 3, 1, 0, 0, 0, 0)), p = new Date(Date.UTC(t, g * 3 + 3, 0, 23, 59, 59, 999));
+    return { start: c, end: p };
+  }
+  if (e === "this year") {
+    const g = new Date(Date.UTC(t, 0, 1, 0, 0, 0, 0)), c = new Date(Date.UTC(t, 11, 31, 23, 59, 59, 999));
+    return { start: g, end: c };
+  }
+  const l = e.match(/^last\s+(\d+)\s+days?$/);
+  if (l) {
+    const g = parseInt(l[1], 10), c = new Date(r);
+    c.setUTCDate(s - g + 1), c.setUTCHours(0, 0, 0, 0);
+    const p = new Date(r);
+    return p.setUTCHours(23, 59, 59, 999), { start: c, end: p };
+  }
+  const d = e.match(/^last\s+(\d+)\s+weeks?$/);
+  if (d) {
+    const c = parseInt(d[1], 10) * 7, p = new Date(r);
+    p.setUTCDate(s - c + 1), p.setUTCHours(0, 0, 0, 0);
+    const S = new Date(r);
+    return S.setUTCHours(23, 59, 59, 999), { start: p, end: S };
+  }
+  if (e === "last week") {
+    const g = o === 0 ? -13 : -6 - o, c = new Date(r);
+    c.setUTCDate(s + g), c.setUTCHours(0, 0, 0, 0);
+    const p = new Date(c);
+    return p.setUTCDate(c.getUTCDate() + 6), p.setUTCHours(23, 59, 59, 999), { start: c, end: p };
+  }
+  if (e === "last month") {
+    const g = new Date(Date.UTC(t, i - 1, 1, 0, 0, 0, 0)), c = new Date(Date.UTC(t, i, 0, 23, 59, 59, 999));
+    return { start: g, end: c };
+  }
+  if (e === "last quarter") {
+    const g = Math.floor(i / 3), c = g === 0 ? 3 : g - 1, p = g === 0 ? t - 1 : t, S = new Date(Date.UTC(p, c * 3, 1, 0, 0, 0, 0)), C = new Date(Date.UTC(p, c * 3 + 3, 0, 23, 59, 59, 999));
+    return { start: S, end: C };
+  }
+  if (e === "last year") {
+    const g = new Date(Date.UTC(t - 1, 0, 1, 0, 0, 0, 0)), c = new Date(Date.UTC(t - 1, 11, 31, 23, 59, 59, 999));
+    return { start: g, end: c };
+  }
+  if (e === "last 12 months") {
+    const g = new Date(Date.UTC(t, i - 11, 1, 0, 0, 0, 0)), c = new Date(r);
+    return c.setUTCHours(23, 59, 59, 999), { start: g, end: c };
+  }
+  const f = e.match(/^last\s+(\d+)\s+months?$/);
+  if (f) {
+    const g = parseInt(f[1], 10), c = new Date(Date.UTC(t, i - g + 1, 1, 0, 0, 0, 0)), p = new Date(r);
+    return p.setUTCHours(23, 59, 59, 999), { start: c, end: p };
+  }
+  const y = e.match(/^last\s+(\d+)\s+years?$/);
+  if (y) {
+    const g = parseInt(y[1], 10), c = new Date(Date.UTC(t - g, 0, 1, 0, 0, 0, 0)), p = new Date(r);
+    return p.setUTCHours(23, 59, 59, 999), { start: c, end: p };
+  }
+  return null;
+}
+function Wn(n) {
+  if (Array.isArray(n)) {
+    if (n.length < 2) return null;
+    const r = new Date(n[0]), e = new Date(n[1]);
+    return isNaN(r.getTime()) || isNaN(e.getTime()) ? null : (e.setUTCHours(23, 59, 59, 999), { start: r, end: e });
+  }
+  return jn(n);
+}
+function de(n) {
+  return n.toISOString().split("T")[0];
+}
+function zn(n, r) {
+  const e = r.getTime() - n.getTime(), t = Math.ceil(e / (1e3 * 60 * 60 * 24)), i = new Date(n);
+  i.setUTCDate(i.getUTCDate() - 1), i.setUTCHours(23, 59, 59, 999);
+  const s = new Date(i);
+  return s.setUTCDate(s.getUTCDate() - t + 1), s.setUTCHours(0, 0, 0, 0), { start: s, end: i };
+}
+function ot(n, r) {
+  for (const e of n)
+    if ("type" in e && "filters" in e) {
+      const i = ot(e.filters, r);
+      if (i) return i;
+    } else if ("member" in e) {
+      const t = e;
+      if (t.member === r && t.operator === "inDateRange" && t.dateRange)
+        return { dateRange: t.dateRange };
+    }
+}
+function lt(n, r) {
+  const e = ot(r, n);
+  if (!e?.dateRange) return;
+  const t = Wn(e.dateRange);
+  if (!t) return;
+  const i = zn(t.start, t.end);
+  return [
+    [de(t.start), de(t.end)],
+    [de(i.start), de(i.end)]
+  ];
+}
+function ut(n, r) {
+  return n.reduce((e, t) => {
+    if ("type" in t && "filters" in t) {
+      const i = t, s = ut(i.filters, r);
+      s.length > 0 && e.push({ type: i.type, filters: s });
+    } else if ("member" in t) {
+      const i = t;
+      i.member === r && i.operator === "inDateRange" || e.push(t);
+    } else
+      e.push(t);
+    return e;
+  }, []);
+}
+function ge(n, r, e, t, i = !1) {
+  const s = r.filter((d) => d.isTimeDimension && d.enableComparison).map((d) => d.field);
+  let o = e;
+  if (!i)
+    for (const d of s)
+      o = ut(o, d);
+  const l = {
+    measures: n.map((d) => d.field),
+    dimensions: r.filter((d) => !d.isTimeDimension).map((d) => d.field),
+    timeDimensions: r.filter((d) => d.isTimeDimension).map((d) => {
+      const f = {
+        dimension: d.field,
+        granularity: d.granularity || "day"
+      };
+      if (d.enableComparison) {
+        const y = lt(d.field, e);
+        y && (f.compareDateRange = y);
+      }
+      return f;
+    }),
+    filters: o.length > 0 ? o : void 0,
+    order: t && Object.keys(t).length > 0 ? t : void 0
+  };
+  return l.measures?.length === 0 && delete l.measures, l.dimensions?.length === 0 && delete l.dimensions, l.timeDimensions?.length === 0 && delete l.timeDimensions, l;
+}
+const Jn = "drizzle-cube-analysis-builder-v3";
+function Q() {
+  return {
+    metrics: [],
+    breakdowns: [],
+    filters: [],
+    order: void 0,
+    validationStatus: "idle",
+    validationError: null
+  };
+}
+function ze() {
+  return {
+    metrics: [],
+    breakdowns: [],
+    filters: [],
+    order: void 0,
+    validationStatus: "idle",
+    validationError: null
+  };
+}
+function Yn(n) {
+  return n.map((r) => r.field);
+}
+function Xn(n, r) {
+  const e = [], t = [];
+  for (const i of n)
+    if (i.isTimeDimension) {
+      const s = {
+        dimension: i.field,
+        granularity: i.granularity || "day"
+      };
+      if (i.enableComparison) {
+        const o = lt(i.field, r);
+        o && (s.compareDateRange = o);
+      }
+      t.push(s);
+    } else
+      e.push(i.field);
+  return { dimensions: e, timeDimensions: t };
+}
+function Zn(n) {
+  const { dimensions: r, timeDimensions: e } = Xn(
+    n.breakdowns,
+    n.filters
+  ), t = {
+    measures: Yn(n.metrics),
+    dimensions: r
+  };
+  return e.length > 0 && (t.timeDimensions = e), n.filters.length > 0 && (t.filters = n.filters), n.order && Object.keys(n.order).length > 0 && (t.order = n.order), t;
+}
+function ei(n) {
+  return n.map((r, e) => ({
+    id: K(),
+    field: r,
+    label: ye(e)
+  }));
+}
+function ti(n) {
+  const r = [];
+  if (n.dimensions)
+    for (const e of n.dimensions)
+      r.push({
+        id: K(),
+        field: e,
+        isTimeDimension: !1
+      });
+  if (n.timeDimensions)
+    for (const e of n.timeDimensions) {
+      const t = !!(e.compareDateRange && e.compareDateRange.length > 0);
+      r.push({
+        id: K(),
+        field: e.dimension,
+        granularity: e.granularity,
+        isTimeDimension: !0,
+        enableComparison: t
+      });
+    }
+  return r;
+}
+function Je(n) {
+  return {
+    metrics: ei(n.measures || []),
+    breakdowns: ti(n),
+    filters: n.filters || [],
+    order: n.order,
+    validationStatus: "idle",
+    validationError: null
+  };
+}
+function ni(n) {
+  return typeof n == "object" && n !== null && "queries" in n && Array.isArray(n.queries);
+}
+const _ = {
+  type: "query",
+  createInitial() {
+    return {
+      queryStates: [ze()],
+      activeQueryIndex: 0,
+      mergeStrategy: "concat"
+    };
+  },
+  extractState(n) {
+    return {
+      queryStates: n.queryStates,
+      activeQueryIndex: n.activeQueryIndex,
+      mergeStrategy: n.mergeStrategy
+    };
+  },
+  canLoad(n) {
+    if (!n || typeof n != "object") return !1;
+    const r = n;
+    return !(r.version !== 1 || r.analysisType !== "query" || !r.query || typeof r.query != "object");
+  },
+  load(n) {
+    if (n.analysisType !== "query")
+      throw new Error(
+        `Cannot load ${n.analysisType} config with query adapter`
+      );
+    const r = n;
+    if (ni(r.query)) {
+      const e = r.query, t = e.queries.map(Je);
+      return t.length === 0 && t.push(ze()), {
+        queryStates: t,
+        activeQueryIndex: 0,
+        mergeStrategy: e.mergeStrategy || "concat"
+      };
+    }
+    return {
+      queryStates: [Je(r.query)],
+      activeQueryIndex: 0,
+      mergeStrategy: "concat"
+    };
+  },
+  save(n, r, e) {
+    const t = n.queryStates.map(Zn), s = t.length === 1 && n.mergeStrategy === "concat" ? t[0] : {
+      queries: t,
+      mergeStrategy: n.mergeStrategy
+    };
+    return {
+      version: 1,
+      analysisType: "query",
+      activeView: e,
+      charts: {
+        query: r.query || this.getDefaultChartConfig()
+      },
+      query: s
+    };
+  },
+  validate(n) {
+    const r = [], e = [];
+    if (n.queryStates.some((i) => i.metrics.length > 0) || r.push("At least one metric is required"), n.queryStates.forEach((i, s) => {
+      const o = n.queryStates.length > 1 ? `Query ${s + 1}: ` : "";
+      i.metrics.length === 0 && i.breakdowns.length === 0 && e.push(`${o}Query is empty`);
+    }), n.queryStates.length > 1 && n.mergeStrategy === "merge") {
+      const i = n.queryStates[0].breakdowns.map(
+        (o) => o.field
+      );
+      n.queryStates.every((o) => {
+        const l = o.breakdowns.map((d) => d.field);
+        return l.length === i.length && l.every((d) => i.includes(d));
+      }) || e.push(
+        "Queries have different breakdowns - merge results may be unexpected"
+      );
+    }
+    return {
+      isValid: r.length === 0,
+      errors: r,
+      warnings: e
+    };
+  },
+  clear(n) {
+    return this.createInitial();
+  },
+  getDefaultChartConfig() {
+    return {
+      chartType: "bar",
+      chartConfig: {},
+      displayConfig: { showLegend: !0, showGrid: !0, showTooltip: !0 }
+    };
+  }
+}, V = /* @__PURE__ */ new Map();
+let xe = !1;
+function Re() {
+  xe || (V.has("query") || V.set("query", _), V.has("funnel") || V.set("funnel", O), V.has("flow") || V.set("flow", H), V.has("retention") || V.set("retention", j), xe = !0);
+}
+const P = {
+  /**
+   * Register an adapter for a specific analysis type.
+   * Should be called once at app initialization.
+   *
+   * @param adapter - The adapter to register
+   */
+  register(n) {
+    V.has(n.type) && console.warn(
+      `[adapterRegistry] Overwriting existing adapter for type: ${n.type}`
+    ), V.set(n.type, n);
+  },
+  /**
+   * Get the adapter for a specific analysis type.
+   * Built-in adapters (query, funnel) are initialized automatically.
+   *
+   * @param type - The analysis type to get adapter for
+   * @returns The registered adapter
+   * @throws Error if no adapter is registered for the type
+   */
+  get(n) {
+    Re();
+    const r = V.get(n);
+    if (!r)
+      throw new Error(
+        `[adapterRegistry] No adapter registered for type: ${n}. Available types: ${Array.from(V.keys()).join(", ") || "none"}`
+      );
+    return r;
+  },
+  /**
+   * Check if an adapter is registered for a specific type.
+   * Built-in adapters (query, funnel) are initialized automatically.
+   *
+   * @param type - The analysis type to check
+   * @returns True if an adapter is registered
+   */
+  has(n) {
+    return Re(), V.has(n);
+  },
+  /**
+   * Get all registered analysis types.
+   * Built-in adapters (query, funnel) are initialized automatically.
+   *
+   * @returns Array of registered types
+   */
+  getRegisteredTypes() {
+    return Re(), Array.from(V.keys());
+  },
+  /**
+   * Clear all registered adapters.
+   * Primarily useful for testing.
+   * Note: Built-in adapters will be re-initialized on next access.
+   */
+  clear() {
+    V.clear(), xe = !1;
+  }
+}, ct = () => ({
+  analysisType: "query",
+  // Use adapter defaults as single source of truth for chart configuration
+  charts: {
+    query: _.getDefaultChartConfig(),
+    funnel: O.getDefaultChartConfig(),
+    flow: H.getDefaultChartConfig(),
+    retention: j.getDefaultChartConfig()
+  },
+  // Per-mode active view preference
+  activeViews: {
+    query: "chart",
+    funnel: "chart",
+    flow: "chart",
+    retention: "chart"
+  },
+  userManuallySelectedChart: !1,
+  localPaletteName: "default"
+}), ii = (n, r) => ({
+  ...ct(),
+  setAnalysisType: (e) => {
+    n((t) => {
+      const i = { ...t.charts };
+      if (!i[e]) {
+        const o = P.get(e);
+        i[e] = o.getDefaultChartConfig();
+      }
+      const s = { ...t.activeViews };
+      return s[e] || (s[e] = "chart"), {
+        analysisType: e,
+        charts: i,
+        activeViews: s,
+        activeView: s[e] ?? "chart"
+      };
+    });
+  },
+  setChartType: (e) => {
+    n((t) => {
+      const i = t.analysisType, s = t.charts[i] || {
+        chartType: e,
+        chartConfig: {},
+        displayConfig: {}
+      };
+      return {
+        charts: {
+          ...t.charts,
+          [i]: { ...s, chartType: e }
+        }
+      };
+    });
+  },
+  setChartTypeManual: (e) => {
+    n((t) => {
+      const i = t.analysisType, s = t.charts[i] || {
+        chartType: e,
+        chartConfig: {},
+        displayConfig: {}
+      };
+      return {
+        charts: {
+          ...t.charts,
+          [i]: { ...s, chartType: e }
+        },
+        userManuallySelectedChart: !0,
+        activeView: "chart",
+        activeViews: {
+          ...t.activeViews,
+          [i]: "chart"
+        }
+      };
+    });
+  },
+  setChartConfig: (e) => {
+    n((t) => {
+      const i = t.analysisType, s = t.charts[i] || {
+        chartType: "bar",
+        chartConfig: e,
+        displayConfig: {}
+      };
+      return {
+        charts: {
+          ...t.charts,
+          [i]: { ...s, chartConfig: e }
+        },
+        activeView: "chart",
+        activeViews: {
+          ...t.activeViews,
+          [i]: "chart"
+        }
+      };
+    });
+  },
+  setDisplayConfig: (e) => {
+    n((t) => {
+      const i = t.analysisType, s = t.charts[i] || {
+        chartType: "bar",
+        chartConfig: {},
+        displayConfig: e
+      };
+      return {
+        charts: {
+          ...t.charts,
+          [i]: { ...s, displayConfig: e }
+        },
+        activeView: "chart",
+        activeViews: {
+          ...t.activeViews,
+          [i]: "chart"
+        }
+      };
+    });
+  },
+  setLocalPaletteName: (e) => n({ localPaletteName: e }),
+  setUserManuallySelectedChart: (e) => n({ userManuallySelectedChart: e }),
+  // @deprecated - Use setChartType() instead
+  // Kept for backward compatibility
+  setFunnelChartType: (e) => {
+    n((t) => {
+      const i = t.charts.funnel || {
+        chartType: e,
+        chartConfig: {},
+        displayConfig: {}
+      };
+      return {
+        charts: {
+          ...t.charts,
+          funnel: { ...i, chartType: e }
+        }
+      };
+    });
+  },
+  // @deprecated - Use setChartConfig() instead
+  // Kept for backward compatibility
+  setFunnelChartConfig: (e) => {
+    n((t) => {
+      const i = t.charts.funnel || {
+        chartType: "funnel",
+        chartConfig: e,
+        displayConfig: {}
+      };
+      return {
+        charts: {
+          ...t.charts,
+          funnel: { ...i, chartConfig: e }
+        }
+      };
+    });
+  },
+  // @deprecated - Use setDisplayConfig() instead
+  // Kept for backward compatibility
+  setFunnelDisplayConfig: (e) => {
+    n((t) => {
+      const i = t.charts.funnel || {
+        chartType: "funnel",
+        chartConfig: {},
+        displayConfig: e
+      };
+      return {
+        charts: {
+          ...t.charts,
+          funnel: { ...i, displayConfig: e }
+        }
+      };
+    });
+  },
+  save: () => {
+    const e = r(), t = P.get(e.analysisType), i = t.extractState(e), s = e.activeViews[e.analysisType] ?? e.activeView ?? "chart";
+    return t.save(i, e.charts, s);
+  },
+  load: (e) => {
+    const t = P.get(e.analysisType);
+    if (!t.canLoad(e)) {
+      console.warn("[coreSlice] Invalid config, cannot load");
+      return;
+    }
+    const i = t.load(e), s = r(), o = {
+      ...s.charts,
+      ...e.charts
+    };
+    o[e.analysisType] || (o[e.analysisType] = t.getDefaultChartConfig());
+    const l = {
+      ...s.activeViews,
+      [e.analysisType]: e.activeView
+    };
+    n({
+      analysisType: e.analysisType,
+      charts: o,
+      activeView: e.activeView,
+      activeViews: l,
+      // Mode-specific state from adapter
+      ...i
+    });
+  },
+  saveWorkspace: () => {
+    const e = r(), t = e, i = P.get("query"), s = i.extractState(t), o = e.activeViews.query ?? e.activeView ?? "chart", l = i.save(
+      s,
+      e.charts,
+      o
+    ), d = P.get("funnel"), f = d.extractState(t), y = e.activeViews.funnel ?? e.activeView ?? "chart", g = d.save(
+      f,
+      e.charts,
+      y
+    ), c = P.get("flow"), p = c.extractState(t), S = e.activeViews.flow ?? e.activeView ?? "chart", C = c.save(
+      p,
+      e.charts,
+      S
+    ), b = P.get("retention"), w = b.extractState(t), m = e.activeViews.retention ?? e.activeView ?? "chart", D = b.save(
+      w,
+      e.charts,
+      m
+    );
+    return {
+      version: 1,
+      activeType: e.analysisType,
+      modes: {
+        query: l,
+        funnel: g,
+        flow: C,
+        retention: D
+      }
+    };
+  },
+  loadWorkspace: (e) => {
+    const t = P.get("query"), i = P.get("funnel"), s = P.get("flow"), o = P.get("retention");
+    let l = {}, d = {}, f = {}, y = {}, g = { ...r().charts }, c = { ...r().activeViews };
+    e.modes.query && t.canLoad(e.modes.query) && (l = t.load(e.modes.query), g = { ...g, ...e.modes.query.charts }, c.query = e.modes.query.activeView ?? "chart"), e.modes.funnel && i.canLoad(e.modes.funnel) && (d = i.load(e.modes.funnel), g = { ...g, ...e.modes.funnel.charts }, c.funnel = e.modes.funnel.activeView ?? "chart"), e.modes.flow && s.canLoad(e.modes.flow) && (f = s.load(e.modes.flow), g = { ...g, ...e.modes.flow.charts }, c.flow = e.modes.flow.activeView ?? "chart"), e.modes.retention && o.canLoad(e.modes.retention) && (y = o.load(e.modes.retention), g = { ...g, ...e.modes.retention.charts }, c.retention = e.modes.retention.activeView ?? "chart");
+    const S = e.modes[e.activeType]?.activeView ?? "chart";
+    n({
+      analysisType: e.activeType,
+      charts: g,
+      activeViews: c,
+      activeView: S,
+      ...l,
+      ...d,
+      ...f,
+      ...y
+    });
+  }
+}), qe = () => ({
+  queryStates: [Q()],
+  activeQueryIndex: 0,
+  mergeStrategy: "concat"
+}), ri = (n, r) => ({
+  ...qe(),
+  // ==========================================================================
+  // Query State Management
+  // ==========================================================================
+  setQueryStates: (e) => n({ queryStates: e }),
+  updateQueryState: (e, t) => n((i) => {
+    const s = [...i.queryStates];
+    return s[e] = t(s[e] || Q()), { queryStates: s };
+  }),
+  setActiveQueryIndex: (e) => n({ activeQueryIndex: e }),
+  setMergeStrategy: (e) => n({ mergeStrategy: e }),
+  // ==========================================================================
+  // Multi-Query Actions
+  // ==========================================================================
+  addQuery: () => n((e) => {
+    const t = e.queryStates[e.activeQueryIndex] || Q(), i = {
+      ...Q(),
+      metrics: [...t.metrics],
+      breakdowns: [...t.breakdowns],
+      filters: [...t.filters]
+    };
+    return {
+      queryStates: [...e.queryStates, i],
+      activeQueryIndex: e.queryStates.length
+    };
+  }),
+  removeQuery: (e) => n((t) => {
+    if (t.queryStates.length <= 1) return t;
+    const i = t.queryStates.filter((o, l) => l !== e);
+    let s = t.activeQueryIndex;
+    return e === t.activeQueryIndex ? s = Math.max(0, t.activeQueryIndex - 1) : e < t.activeQueryIndex && (s = t.activeQueryIndex - 1), { queryStates: i, activeQueryIndex: s };
+  }),
+  // ==========================================================================
+  // Metrics Actions
+  // ==========================================================================
+  addMetric: (e, t) => n((i) => {
+    const s = i.activeQueryIndex, o = [...i.queryStates], l = o[s] || Q(), d = {
+      id: K(),
+      field: e,
+      label: t || ye(l.metrics.length)
+    };
+    return o[s] = {
+      ...l,
+      metrics: [...l.metrics, d]
+    }, { queryStates: o };
+  }),
+  removeMetric: (e) => n((t) => {
+    const i = t.activeQueryIndex, s = [...t.queryStates], o = s[i] || Q(), l = o.metrics.find((y) => y.id === e)?.field, d = o.metrics.filter((y) => y.id !== e);
+    let f = o.order;
+    return l && f && f[l] && (f = { ...f }, delete f[l], Object.keys(f).length === 0 && (f = void 0)), s[i] = {
+      ...o,
+      metrics: d,
+      order: f
+    }, { queryStates: s };
+  }),
+  toggleMetric: (e) => n((t) => {
+    const i = t.activeQueryIndex, s = [...t.queryStates], o = s[i] || Q(), l = o.metrics.findIndex((d) => d.field === e);
+    if (l >= 0)
+      s[i] = {
+        ...o,
+        metrics: o.metrics.filter((d, f) => f !== l)
+      };
+    else {
+      const d = {
+        id: K(),
+        field: e,
+        label: ye(o.metrics.length)
+      };
+      s[i] = {
+        ...o,
+        metrics: [...o.metrics, d]
+      };
+    }
+    return { queryStates: s };
+  }),
+  reorderMetrics: (e, t) => n((i) => {
+    const s = i.activeQueryIndex, o = [...i.queryStates], l = o[s] || Q(), d = [...l.metrics], [f] = d.splice(e, 1);
+    return d.splice(t, 0, f), o[s] = {
+      ...l,
+      metrics: d
+    }, { queryStates: o };
+  }),
+  // ==========================================================================
+  // Breakdowns Actions
+  // ==========================================================================
+  addBreakdown: (e, t, i) => n((s) => {
+    const o = s.activeQueryIndex, l = [...s.queryStates], d = l[o] || Q();
+    if (t && d.breakdowns.some((g) => g.isTimeDimension))
+      return s;
+    const f = {
+      id: K(),
+      field: e,
+      isTimeDimension: t,
+      granularity: t ? i || "month" : void 0
+    };
+    return l[o] = {
+      ...d,
+      breakdowns: [...d.breakdowns, f]
+    }, { queryStates: l };
+  }),
+  removeBreakdown: (e) => n((t) => {
+    const i = t.activeQueryIndex, s = [...t.queryStates], o = s[i] || Q(), l = o.breakdowns.find((y) => y.id === e)?.field, d = o.breakdowns.filter((y) => y.id !== e);
+    let f = o.order;
+    return l && f && f[l] && (f = { ...f }, delete f[l], Object.keys(f).length === 0 && (f = void 0)), s[i] = {
+      ...o,
+      breakdowns: d,
+      order: f
+    }, { queryStates: s };
+  }),
+  toggleBreakdown: (e, t, i) => n((s) => {
+    const o = s.activeQueryIndex, l = [...s.queryStates], d = l[o] || Q(), f = d.breakdowns.findIndex((y) => y.field === e);
+    if (f >= 0)
+      l[o] = {
+        ...d,
+        breakdowns: d.breakdowns.filter((y, g) => g !== f)
+      };
+    else {
+      if (t && d.breakdowns.some((c) => c.isTimeDimension))
+        return s;
+      const y = {
+        id: K(),
+        field: e,
+        isTimeDimension: t,
+        granularity: t ? i || "month" : void 0
+      };
+      l[o] = {
+        ...d,
+        breakdowns: [...d.breakdowns, y]
+      };
+    }
+    return { queryStates: l };
+  }),
+  setBreakdownGranularity: (e, t) => n((i) => {
+    const { mergeStrategy: s, activeQueryIndex: o, queryStates: l } = i, d = [...l], f = s === "merge" && o > 0 ? 0 : o;
+    return d[f] = {
+      ...d[f],
+      breakdowns: d[f].breakdowns.map(
+        (y) => y.id === e ? { ...y, granularity: t } : y
+      )
+    }, { queryStates: d };
+  }),
+  toggleBreakdownComparison: (e) => n((t) => {
+    const { mergeStrategy: i, activeQueryIndex: s, queryStates: o, charts: l, analysisType: d } = t, f = [...o], y = i === "merge" && s > 0 ? 0 : s, g = f[y].breakdowns.find((C) => C.id === e), c = g && !g.enableComparison, p = f[y].breakdowns.map((C) => C.id === e ? { ...C, enableComparison: !C.enableComparison } : C.isTimeDimension && C.enableComparison ? { ...C, enableComparison: !1 } : C);
+    f[y] = {
+      ...f[y],
+      breakdowns: p
+    };
+    const S = { queryStates: f };
+    if (c && g?.isTimeDimension && g.field) {
+      const C = f[y].filters || [];
+      if (!C.some((m) => {
+        if ("member" in m) {
+          const D = m;
+          return D.member === g.field && D.operator === "inDateRange";
+        }
+        return !1;
+      })) {
+        const m = {
+          member: g.field,
+          operator: "inDateRange",
+          values: [],
+          dateRange: _n("last_n_months", 3)
+        };
+        f[y] = {
+          ...f[y],
+          filters: [...C, m]
+        }, S.queryStates = f;
+      }
+      const w = l[d];
+      w && w.chartType !== "line" && (S.charts = {
+        ...l,
+        [d]: {
+          ...w,
+          chartType: "line"
+        }
+      }, S.userManuallySelectedChart = !1, S.activeView = "chart", S.activeViews = {
+        ...t.activeViews,
+        [d]: "chart"
+      });
+    }
+    return S;
+  }),
+  reorderBreakdowns: (e, t) => n((i) => {
+    const s = i.activeQueryIndex, o = [...i.queryStates], l = o[s] || Q(), d = [...l.breakdowns], [f] = d.splice(e, 1);
+    return d.splice(t, 0, f), o[s] = {
+      ...l,
+      breakdowns: d
+    }, { queryStates: o };
+  }),
+  // ==========================================================================
+  // Filters Actions
+  // ==========================================================================
+  setFilters: (e) => n((t) => {
+    const i = t.activeQueryIndex, s = [...t.queryStates];
+    return s[i] = {
+      ...s[i],
+      filters: e
+    }, { queryStates: s };
+  }),
+  dropFieldToFilter: (e) => n((t) => {
+    const i = t.activeQueryIndex, s = [...t.queryStates], o = s[i] || Q(), l = o.filters || [];
+    if (l.some((g) => "member" in g && g.member === e)) return t;
+    const f = {
+      member: e,
+      operator: "set",
+      values: []
+    };
+    let y;
+    if (l.length === 0)
+      y = [f];
+    else if (l.length === 1 && "type" in l[0]) {
+      const g = l[0];
+      y = [{ ...g, filters: [...g.filters, f] }];
+    } else
+      y = [{ type: "and", filters: [...l, f] }];
+    return s[i] = {
+      ...o,
+      filters: y
+    }, { queryStates: s };
+  }),
+  setOrder: (e, t) => n((i) => {
+    const s = i.activeQueryIndex, o = [...i.queryStates], l = o[s] || Q(), d = { ...l.order || {} };
+    return t === null ? delete d[e] : d[e] = t, o[s] = {
+      ...l,
+      order: Object.keys(d).length > 0 ? d : void 0
+    }, { queryStates: o };
+  }),
+  // ==========================================================================
+  // Utility Actions
+  // ==========================================================================
+  getCurrentState: () => {
+    const e = r();
+    return e.queryStates[e.activeQueryIndex] || Q();
+  },
+  getMergeKeys: () => {
+    const e = r();
+    if (e.mergeStrategy !== "merge" || e.queryStates.length === 0)
+      return;
+    const t = e.queryStates[0].breakdowns;
+    if (t.length !== 0)
+      return t.map((i) => i.field);
+  },
+  isMultiQueryMode: () => {
+    const e = r();
+    return e.queryStates.length <= 1 ? !1 : e.queryStates.filter(
+      (i) => i.metrics.length > 0 || i.breakdowns.length > 0
+    ).length > 1;
+  },
+  buildCurrentQuery: () => {
+    const e = r(), t = e.queryStates[e.activeQueryIndex] || Q();
+    return ge(t.metrics, t.breakdowns, t.filters, t.order);
+  },
+  buildAllQueries: () => {
+    const e = r(), t = e.queryStates[0]?.breakdowns || [];
+    return e.queryStates.map((i, s) => {
+      const o = e.mergeStrategy === "merge" && s > 0 ? t : i.breakdowns;
+      return ge(i.metrics, o, i.filters, i.order);
+    });
+  },
+  buildMultiQueryConfig: () => {
+    const e = r();
+    if (!r().isMultiQueryMode()) return null;
+    const i = r().buildAllQueries().filter((s) => s.measures && s.measures.length > 0 || s.dimensions && s.dimensions.length > 0 || s.timeDimensions && s.timeDimensions.length > 0);
+    return i.length < 2 ? null : {
+      queries: i,
+      mergeStrategy: e.mergeStrategy,
+      mergeKeys: r().getMergeKeys(),
+      queryLabels: i.map((s, o) => `Q${o + 1}`)
+    };
+  }
+}), ke = () => ({
+  funnelCube: null,
+  funnelSteps: [],
+  activeFunnelStepIndex: 0,
+  funnelTimeDimension: null,
+  funnelBindingKey: null,
+  stepTimeToConvert: []
+  // Deprecated - kept for backward compat
+}), si = (n, r) => ({
+  ...ke(),
+  addFunnelStep: () => n((e) => {
+    const t = e.funnelSteps[e.funnelSteps.length - 1], i = {
+      id: K(),
+      name: `Step ${e.funnelSteps.length + 1}`,
+      cube: e.funnelCube || "",
+      // Deep copy filters from previous step, or empty array if first step
+      filters: t?.filters ? JSON.parse(JSON.stringify(t.filters)) : [],
+      // Copy timeToConvert from previous step
+      timeToConvert: t?.timeToConvert
+    };
+    return {
+      funnelSteps: [...e.funnelSteps, i],
+      activeFunnelStepIndex: e.funnelSteps.length
+    };
+  }),
+  removeFunnelStep: (e) => n((t) => {
+    if (t.funnelSteps.length <= 1) return t;
+    const i = t.funnelSteps.filter((o, l) => l !== e), s = Math.min(t.activeFunnelStepIndex, i.length - 1);
+    return {
+      funnelSteps: i,
+      activeFunnelStepIndex: s
+    };
+  }),
+  updateFunnelStep: (e, t) => n((i) => {
+    const s = [...i.funnelSteps];
+    return s[e] && (s[e] = { ...s[e], ...t }), { funnelSteps: s };
+  }),
+  setActiveFunnelStepIndex: (e) => n({ activeFunnelStepIndex: e }),
+  reorderFunnelSteps: (e, t) => n((i) => {
+    const s = [...i.funnelSteps], [o] = s.splice(e, 1);
+    return s.splice(t, 0, o), { funnelSteps: s };
+  }),
+  setFunnelTimeDimension: (e) => n({ funnelTimeDimension: e }),
+  setFunnelBindingKey: (e) => n({ funnelBindingKey: e }),
+  setFunnelCube: (e) => n((t) => {
+    const i = t.funnelSteps.map((s) => ({
+      ...s,
+      cube: e || ""
+    }));
+    return {
+      funnelCube: e,
+      // Clear binding key and time dimension since they may not exist in new cube
+      funnelBindingKey: null,
+      funnelTimeDimension: null,
+      funnelSteps: i
+    };
+  }),
+  // Deprecated: no-op - legacy queryStates-based funnels are no longer supported
+  // Use updateFunnelStep with timeToConvert instead
+  setStepTimeToConvert: () => {
+  },
+  // Deprecated: always returns null - legacy queryStates-based funnels are no longer supported
+  // Use buildFunnelQueryFromSteps instead
+  buildFunnelConfig: () => null,
+  // New: Build ServerFunnelQuery from dedicated funnelSteps
+  buildFunnelQueryFromSteps: () => {
+    const e = r();
+    if (e.analysisType !== "funnel" || !e.funnelBindingKey || !e.funnelTimeDimension || e.funnelSteps.length < 2) return null;
+    const t = e.funnelSteps.filter((i) => i.cube && i.name);
+    return t.length < 2 ? null : {
+      funnel: {
+        bindingKey: e.funnelBindingKey.dimension,
+        timeDimension: e.funnelTimeDimension,
+        steps: t.map((i) => ({
+          name: i.name,
+          cube: i.cube,
+          filter: i.filters.length > 0 ? i.filters : void 0,
+          timeToConvert: i.timeToConvert
+        })),
+        includeTimeMetrics: !0
+      }
+    };
+  },
+  isFunnelMode: () => r().analysisType === "funnel",
+  isFunnelModeEnabled: () => {
+    const e = r();
+    return e.analysisType !== "funnel" || !e.funnelBindingKey || !e.funnelTimeDimension || e.funnelSteps.length < 2 ? !1 : e.funnelSteps.filter((i) => i.cube && i.name).length >= 2;
+  }
+}), Be = () => ({
+  flowCube: null,
+  flowBindingKey: null,
+  flowTimeDimension: null,
+  startingStep: {
+    name: "",
+    filters: []
+  },
+  stepsBefore: 3,
+  stepsAfter: 3,
+  eventDimension: null,
+  joinStrategy: "auto"
+}), ai = (n, r) => ({
+  ...Be(),
+  setFlowCube: (e) => n(() => ({
+    flowCube: e,
+    // Clear binding key and time dimension since they may not exist in new cube
+    flowBindingKey: null,
+    flowTimeDimension: null,
+    eventDimension: null,
+    // Reset starting step filters when cube changes
+    startingStep: {
+      name: "",
+      filters: []
+    }
+  })),
+  setFlowBindingKey: (e) => n({ flowBindingKey: e }),
+  setFlowTimeDimension: (e) => n({ flowTimeDimension: e }),
+  setEventDimension: (e) => n({ eventDimension: e }),
+  setStartingStepName: (e) => n((t) => ({
+    startingStep: {
+      ...t.startingStep,
+      name: e
+    }
+  })),
+  setStartingStepFilters: (e) => n((t) => ({
+    startingStep: {
+      ...t.startingStep,
+      filters: e
+    }
+  })),
+  addStartingStepFilter: (e) => n((t) => ({
+    startingStep: {
+      ...t.startingStep,
+      filters: [...t.startingStep.filters, e]
+    }
+  })),
+  removeStartingStepFilter: (e) => n((t) => ({
+    startingStep: {
+      ...t.startingStep,
+      filters: t.startingStep.filters.filter((i, s) => s !== e)
+    }
+  })),
+  updateStartingStepFilter: (e, t) => n((i) => {
+    const s = [...i.startingStep.filters];
+    return s[e] && (s[e] = t), {
+      startingStep: {
+        ...i.startingStep,
+        filters: s
+      }
+    };
+  }),
+  setStepsBefore: (e) => n({
+    stepsBefore: Math.max(je, Math.min(We, e))
+  }),
+  setStepsAfter: (e) => n({
+    stepsAfter: Math.max(je, Math.min(We, e))
+  }),
+  setJoinStrategy: (e) => n(() => ({
+    joinStrategy: e
+  })),
+  isFlowMode: () => r().analysisType === "flow",
+  isFlowModeEnabled: () => {
+    const e = r();
+    return !(e.analysisType !== "flow" || !e.flowCube || !e.flowBindingKey?.dimension || !e.flowTimeDimension || !e.eventDimension || e.startingStep.filters.length === 0);
+  },
+  buildFlowQuery: () => {
+    const e = r();
+    if (e.analysisType !== "flow" || !e.flowBindingKey?.dimension || !e.flowTimeDimension || !e.eventDimension || e.startingStep.filters.length === 0) return null;
+    let t;
+    if (typeof e.flowBindingKey.dimension == "string")
+      t = e.flowBindingKey.dimension;
+    else if (Array.isArray(e.flowBindingKey.dimension))
+      t = e.flowBindingKey.dimension.map((d) => ({
+        cube: d.cube,
+        dimension: d.dimension
+      }));
+    else
+      return null;
+    const i = e.startingStep.filters.length === 1 ? e.startingStep.filters[0] : e.startingStep.filters, o = e.charts?.flow?.chartType === "sunburst" ? "sunburst" : "sankey", l = o === "sunburst" ? 0 : e.stepsBefore;
+    return {
+      flow: {
+        bindingKey: t,
+        timeDimension: e.flowTimeDimension,
+        startingStep: {
+          name: e.startingStep.name || "Starting Step",
+          filter: i
+        },
+        stepsBefore: l,
+        stepsAfter: e.stepsAfter,
+        eventDimension: e.eventDimension,
+        outputMode: o,
+        joinStrategy: e.joinStrategy
+      }
+    };
+  }
+}), Ie = () => ({
+  ...Mn
+}), oi = (n, r) => ({
+  ...Ie(),
+  setRetentionCube: (e) => n(() => ({
+    retentionCube: e,
+    // Clear related fields when cube changes
+    retentionTimeDimension: null,
+    retentionBindingKey: null,
+    retentionCohortFilters: [],
+    retentionActivityFilters: [],
+    retentionBreakdowns: []
+  })),
+  setRetentionBindingKey: (e) => n({ retentionBindingKey: e }),
+  setRetentionTimeDimension: (e) => n({ retentionTimeDimension: e }),
+  setRetentionDateRange: (e) => n({ retentionDateRange: e }),
+  setRetentionCohortFilters: (e) => n({ retentionCohortFilters: e }),
+  addRetentionCohortFilter: (e) => n((t) => ({
+    retentionCohortFilters: [...t.retentionCohortFilters, e]
+  })),
+  removeRetentionCohortFilter: (e) => n((t) => ({
+    retentionCohortFilters: t.retentionCohortFilters.filter(
+      (i, s) => s !== e
+    )
+  })),
+  updateRetentionCohortFilter: (e, t) => n((i) => {
+    const s = [...i.retentionCohortFilters];
+    return s[e] && (s[e] = t), { retentionCohortFilters: s };
+  }),
+  setRetentionActivityFilters: (e) => n({ retentionActivityFilters: e }),
+  addRetentionActivityFilter: (e) => n((t) => ({
+    retentionActivityFilters: [...t.retentionActivityFilters, e]
+  })),
+  removeRetentionActivityFilter: (e) => n((t) => ({
+    retentionActivityFilters: t.retentionActivityFilters.filter(
+      (i, s) => s !== e
+    )
+  })),
+  updateRetentionActivityFilter: (e, t) => n((i) => {
+    const s = [...i.retentionActivityFilters];
+    return s[e] && (s[e] = t), { retentionActivityFilters: s };
+  }),
+  setRetentionBreakdowns: (e) => n({ retentionBreakdowns: e }),
+  addRetentionBreakdown: (e) => n((t) => ({
+    retentionBreakdowns: [...t.retentionBreakdowns, e]
+  })),
+  removeRetentionBreakdown: (e) => n((t) => ({
+    retentionBreakdowns: t.retentionBreakdowns.filter((i) => i.field !== e)
+  })),
+  setRetentionViewGranularity: (e) => n({ retentionViewGranularity: e }),
+  setRetentionPeriods: (e) => n({
+    retentionPeriods: Math.max(
+      xn,
+      Math.min(qn, e)
+    )
+  }),
+  setRetentionType: (e) => n({ retentionType: e }),
+  isRetentionMode: () => r().analysisType === "retention",
+  isRetentionModeEnabled: () => {
+    const e = r();
+    return !(e.analysisType !== "retention" || !e.retentionBindingKey?.dimension || !e.retentionTimeDimension);
+  },
+  buildRetentionQuery: () => {
+    const e = r();
+    if (e.analysisType !== "retention" || !e.retentionBindingKey?.dimension || !e.retentionTimeDimension) return null;
+    let t;
+    if (typeof e.retentionBindingKey.dimension == "string")
+      t = e.retentionBindingKey.dimension;
+    else if (Array.isArray(e.retentionBindingKey.dimension))
+      t = e.retentionBindingKey.dimension.map((s) => ({
+        cube: s.cube,
+        dimension: s.dimension
+      }));
+    else
+      return null;
+    const i = {
+      retention: {
+        timeDimension: e.retentionTimeDimension,
+        bindingKey: t,
+        dateRange: e.retentionDateRange,
+        granularity: e.retentionViewGranularity,
+        periods: e.retentionPeriods,
+        retentionType: e.retentionType
+      }
+    };
+    return e.retentionCohortFilters.length > 0 && (i.retention.cohortFilters = e.retentionCohortFilters.length === 1 ? e.retentionCohortFilters[0] : e.retentionCohortFilters), e.retentionActivityFilters.length > 0 && (i.retention.activityFilters = e.retentionActivityFilters.length === 1 ? e.retentionActivityFilters[0] : e.retentionActivityFilters), e.retentionBreakdowns.length > 0 && (i.retention.breakdownDimensions = e.retentionBreakdowns.map((s) => s.field)), i;
+  },
+  getRetentionValidation: () => {
+    const e = r(), t = [], i = [];
+    if (e.analysisType !== "retention")
+      return { isValid: !0, errors: [], warnings: [] };
+    if (e.retentionCube || t.push("Select a cube for retention analysis"), e.retentionBindingKey?.dimension || t.push("Select a user identifier (binding key) to track retention"), e.retentionTimeDimension || t.push("Select a timestamp dimension for the analysis"), !e.retentionDateRange?.start || !e.retentionDateRange?.end)
+      t.push("Date range is required for retention analysis");
+    else {
+      const s = new Date(e.retentionDateRange.start), o = new Date(e.retentionDateRange.end);
+      isNaN(s.getTime()) && t.push("Invalid start date format"), isNaN(o.getTime()) && t.push("Invalid end date format"), s > o && t.push("Start date must be before or equal to end date");
+    }
+    return e.retentionPeriods < 1 && t.push("At least 1 retention period is required"), e.retentionPeriods > 52 && i.push("More than 52 periods may impact performance"), {
+      isValid: t.length === 0,
+      errors: t,
+      warnings: i
+    };
+  }
+}), dt = {
+  isOpen: !1,
+  userPrompt: "",
+  isGenerating: !1,
+  error: null,
+  hasGeneratedQuery: !1,
+  previousState: null
+}, li = () => ({
+  activeTab: "query",
+  activeView: "chart",
+  displayLimit: 100,
+  showFieldModal: !1,
+  fieldModalMode: "metrics",
+  aiState: dt
+}), ui = (n, r) => ({
+  ...li(),
+  // ==========================================================================
+  // Tab/View Actions
+  // ==========================================================================
+  setActiveTab: (e) => n({ activeTab: e }),
+  setActiveView: (e) => n((t) => ({
+    activeView: e,
+    activeViews: {
+      ...t.activeViews,
+      [t.analysisType]: e
+    }
+  })),
+  setDisplayLimit: (e) => n({ displayLimit: e }),
+  // ==========================================================================
+  // Field Modal Actions
+  // ==========================================================================
+  openMetricsModal: () => n({ showFieldModal: !0, fieldModalMode: "metrics" }),
+  openBreakdownsModal: () => n({ showFieldModal: !0, fieldModalMode: "breakdown" }),
+  closeFieldModal: () => n({ showFieldModal: !1 }),
+  // ==========================================================================
+  // AI Actions
+  // ==========================================================================
+  openAI: () => n((e) => ({
+    aiState: { ...e.aiState, isOpen: !0 }
+  })),
+  closeAI: () => n((e) => ({
+    aiState: { ...e.aiState, isOpen: !1 }
+  })),
+  setAIPrompt: (e) => n((t) => ({
+    aiState: { ...t.aiState, userPrompt: e }
+  })),
+  setAIGenerating: (e) => n((t) => ({
+    aiState: { ...t.aiState, isGenerating: e }
+  })),
+  setAIError: (e) => n((t) => ({
+    aiState: { ...t.aiState, error: e }
+  })),
+  setAIHasGeneratedQuery: (e) => n((t) => ({
+    aiState: { ...t.aiState, hasGeneratedQuery: e }
+  })),
+  saveAIPreviousState: () => n((e) => {
+    const t = e.queryStates[e.activeQueryIndex], i = e.charts[e.analysisType] || {
+      chartType: "bar",
+      chartConfig: {},
+      displayConfig: { showLegend: !0, showGrid: !0, showTooltip: !0 }
+    };
+    return {
+      aiState: {
+        ...e.aiState,
+        previousState: t ? {
+          metrics: [...t.metrics],
+          breakdowns: [...t.breakdowns],
+          filters: [...t.filters],
+          chartType: i.chartType,
+          chartConfig: { ...i.chartConfig },
+          displayConfig: { ...i.displayConfig }
+        } : null
+      }
+    };
+  }),
+  restoreAIPreviousState: () => n((e) => {
+    const t = e.aiState.previousState;
+    if (!t) return e;
+    const i = e.activeQueryIndex, s = [...e.queryStates];
+    return s[i] = {
+      ...s[i] || Q(),
+      metrics: t.metrics,
+      breakdowns: t.breakdowns,
+      filters: t.filters
+    }, {
+      queryStates: s,
+      charts: {
+        ...e.charts,
+        [e.analysisType]: {
+          chartType: t.chartType,
+          chartConfig: t.chartConfig,
+          displayConfig: t.displayConfig
+        }
+      },
+      aiState: { ...dt }
+    };
+  })
+});
+function Ye(n) {
+  const r = n.filters ? [...n.filters] : [], e = n.timeDimensions || [], t = [
+    ...(n.dimensions || []).map((s) => ({
+      id: K(),
+      field: s,
+      isTimeDimension: !1
+    })),
+    ...e.map((s) => ({
+      id: K(),
+      field: s.dimension,
+      granularity: s.granularity,
+      isTimeDimension: !0,
+      enableComparison: !!(s.compareDateRange && s.compareDateRange.length > 0)
+    }))
+  ];
+  let i = r;
+  for (const s of e) {
+    if (!s.compareDateRange || s.compareDateRange.length === 0) continue;
+    const o = i.some(
+      (f) => "member" in f && f.member === s.dimension && f.operator === "inDateRange"
+    ), l = s.compareDateRange[0], d = Array.isArray(l) || typeof l == "string" ? l : void 0;
+    if (d) {
+      if (!o) {
+        i = [
+          ...i,
+          {
+            member: s.dimension,
+            operator: "inDateRange",
+            values: [],
+            dateRange: d
+          }
+        ];
+        continue;
+      }
+      i = i.map((f) => "member" in f && f.member === s.dimension && f.operator === "inDateRange" && !f.dateRange ? { ...f, dateRange: d } : f);
+    }
+  }
+  return {
+    ...Q(),
+    metrics: (n.measures || []).map((s, o) => ({
+      id: K(),
+      field: s,
+      label: ye(o)
+    })),
+    breakdowns: t,
+    filters: i,
+    order: n.order
+  };
+}
+function ci(n) {
+  return "queries" in n && Array.isArray(n.queries);
+}
+function di(n) {
+  if (n.initialAnalysisType === "funnel" && n.initialFunnelState) {
+    const r = O.getDefaultChartConfig(), e = {
+      chartType: n.initialChartConfig?.chartType || r.chartType,
+      chartConfig: n.initialChartConfig?.chartConfig || r.chartConfig,
+      displayConfig: n.initialChartConfig?.displayConfig || r.displayConfig
+    }, t = {
+      funnelCube: n.initialFunnelState.funnelCube ?? null,
+      funnelSteps: n.initialFunnelState.funnelSteps || [],
+      activeFunnelStepIndex: 0,
+      funnelTimeDimension: n.initialFunnelState.funnelTimeDimension ?? null,
+      funnelBindingKey: n.initialFunnelState.funnelBindingKey ?? null
+    };
+    return O.save(
+      t,
+      { funnel: e },
+      n.initialActiveView || "chart"
+    );
+  }
+  if (n.initialAnalysisType === "flow" && n.initialFlowState) {
+    const r = H.getDefaultChartConfig(), e = {
+      chartType: n.initialChartConfig?.chartType || r.chartType,
+      chartConfig: n.initialChartConfig?.chartConfig || r.chartConfig,
+      displayConfig: n.initialChartConfig?.displayConfig || r.displayConfig
+    }, t = {
+      flowCube: n.initialFlowState.flowCube ?? null,
+      flowBindingKey: n.initialFlowState.flowBindingKey ?? null,
+      flowTimeDimension: n.initialFlowState.flowTimeDimension ?? null,
+      startingStep: n.initialFlowState.startingStep || { name: "", filters: [] },
+      stepsBefore: n.initialFlowState.stepsBefore ?? 3,
+      stepsAfter: n.initialFlowState.stepsAfter ?? 3,
+      eventDimension: n.initialFlowState.eventDimension ?? null,
+      joinStrategy: n.initialFlowState.joinStrategy ?? "auto"
+    };
+    return H.save(
+      t,
+      { flow: e },
+      n.initialActiveView || "chart"
+    );
+  }
+  if (n.initialAnalysisType === "retention" && n.initialRetentionState) {
+    const r = j.getDefaultChartConfig(), e = {
+      chartType: n.initialChartConfig?.chartType || r.chartType,
+      chartConfig: n.initialChartConfig?.chartConfig || r.chartConfig,
+      displayConfig: n.initialChartConfig?.displayConfig || r.displayConfig
+    }, t = kn(Bn), i = {
+      retentionCube: n.initialRetentionState.retentionCube ?? null,
+      retentionBindingKey: n.initialRetentionState.retentionBindingKey ?? null,
+      retentionTimeDimension: n.initialRetentionState.retentionTimeDimension ?? null,
+      retentionDateRange: n.initialRetentionState.retentionDateRange ?? t,
+      retentionCohortFilters: n.initialRetentionState.retentionCohortFilters || [],
+      retentionActivityFilters: n.initialRetentionState.retentionActivityFilters || [],
+      retentionBreakdowns: n.initialRetentionState.retentionBreakdowns || [],
+      retentionViewGranularity: n.initialRetentionState.retentionViewGranularity ?? "week",
+      retentionPeriods: n.initialRetentionState.retentionPeriods ?? 12,
+      retentionType: n.initialRetentionState.retentionType ?? "classic"
+    };
+    return j.save(
+      i,
+      { retention: e },
+      n.initialActiveView || "chart"
+    );
+  }
+  if (n.initialQuery) {
+    const r = n.initialQuery;
+    let e, t = "concat";
+    ci(r) ? (e = r.queries.map(Ye), r.mergeStrategy && (t = r.mergeStrategy)) : e = [Ye(r)];
+    const i = _.getDefaultChartConfig(), s = {
+      chartType: n.initialChartConfig?.chartType || i.chartType,
+      chartConfig: n.initialChartConfig?.chartConfig || i.chartConfig,
+      displayConfig: n.initialChartConfig?.displayConfig || i.displayConfig
+    };
+    return _.save(
+      { queryStates: e, activeQueryIndex: 0, mergeStrategy: t },
+      { query: s },
+      n.initialActiveView || "chart"
+    );
+  }
+  if (n.initialChartConfig) {
+    const r = _.getDefaultChartConfig(), e = {
+      chartType: n.initialChartConfig.chartType || r.chartType,
+      chartConfig: n.initialChartConfig.chartConfig || r.chartConfig,
+      displayConfig: n.initialChartConfig.displayConfig || r.displayConfig
+    };
+    return _.save(
+      { queryStates: [Q()], activeQueryIndex: 0, mergeStrategy: "concat" },
+      { query: e },
+      n.initialActiveView || "chart"
+    );
+  }
+  return n.initialActiveView ? _.save(
+    { queryStates: [Q()], activeQueryIndex: 0, mergeStrategy: "concat" },
+    { query: _.getDefaultChartConfig() },
+    n.initialActiveView
+  ) : null;
+}
+function fi(n, r) {
+  return {
+    reset: () => {
+      n({
+        ...ct(),
+        ...qe(),
+        ...ke(),
+        ...Be(),
+        ...Ie(),
+        // Apply adapter defaults for charts (may differ from slice defaults)
+        charts: {
+          query: _.getDefaultChartConfig(),
+          funnel: O.getDefaultChartConfig(),
+          flow: H.getDefaultChartConfig(),
+          retention: j.getDefaultChartConfig()
+        },
+        activeViews: {
+          query: "chart",
+          funnel: "chart",
+          flow: "chart",
+          retention: "chart"
+        }
+      });
+    },
+    clearCurrentMode: () => n((e) => {
+      switch (e.analysisType) {
+        case "funnel":
+          return {
+            ...ke(),
+            charts: {
+              ...e.charts,
+              funnel: O.getDefaultChartConfig()
+            }
+          };
+        case "flow":
+          return {
+            ...Be(),
+            charts: {
+              ...e.charts,
+              flow: H.getDefaultChartConfig()
+            }
+          };
+        case "retention":
+          return {
+            ...Ie(),
+            charts: {
+              ...e.charts,
+              retention: j.getDefaultChartConfig()
+            }
+          };
+        default:
+          return {
+            ...qe(),
+            userManuallySelectedChart: !1,
+            charts: {
+              ...e.charts,
+              query: _.getDefaultChartConfig()
+            }
+          };
+      }
+    }),
+    clearQuery: () => n((e) => {
+      const t = [...e.queryStates];
+      return t[e.activeQueryIndex] = Q(), {
+        queryStates: t,
+        userManuallySelectedChart: !1,
+        charts: {
+          ...e.charts,
+          query: _.getDefaultChartConfig()
+        }
+      };
+    }),
+    getValidation: () => {
+      const e = r(), t = P.get(e.analysisType), i = t.extractState(e);
+      return t.validate(i);
+    }
+  };
+}
+function yi(n = {}) {
+  const r = di(n), e = (t, i, s) => ({
+    // Compose slices - they provide default state and actions
+    ...ii(t, i),
+    ...ri(t, i),
+    ...si(t, i),
+    ...ai(t, i),
+    ...oi(t, i),
+    ...ui(t),
+    // Cross-slice actions
+    ...fi(t, i)
+  });
+  if (n.disableLocalStorage) {
+    const t = Ge()(
+      Oe(He(e), {
+        name: "AnalysisBuilderStore (no-persist)"
+      })
+    );
+    return r && t.getState().load(r), t;
+  }
+  return Ge()(
+    Oe(
+      He(
+        An(e, {
+          name: Jn,
+          // Use workspace format to preserve ALL modes' state
+          partialize: (t) => t.saveWorkspace(),
+          merge: (t, i) => t && In(t) ? {
+            ...i,
+            _persistedWorkspace: t
+          } : t && st(t) ? {
+            ...i,
+            _persistedConfig: t
+          } : r ? {
+            ...i,
+            _initialConfig: r
+          } : i,
+          onRehydrateStorage: () => (t) => {
+            if (t) {
+              if (t._persistedWorkspace) {
+                const i = t._persistedWorkspace;
+                delete t._persistedWorkspace, delete t._persistedConfig, delete t._initialConfig, t.loadWorkspace(i);
+              } else if (t._persistedConfig) {
+                const i = t._persistedConfig;
+                delete t._persistedConfig, delete t._initialConfig, t.load(i);
+              } else if (t._initialConfig) {
+                const i = t._initialConfig;
+                delete t._initialConfig, t.load(i);
+              }
+            }
+          }
+        })
+      ),
+      { name: "AnalysisBuilderStore" }
+    )
+  );
+}
+const Ve = vn(null);
+function Ji({
+  children: n,
+  initialQuery: r,
+  initialChartConfig: e,
+  disableLocalStorage: t,
+  initialAnalysisType: i,
+  initialFunnelState: s,
+  initialFlowState: o,
+  initialRetentionState: l,
+  initialActiveView: d
+}) {
+  const f = me(null);
+  return f.current || (f.current = yi({
+    initialQuery: r,
+    initialChartConfig: e,
+    disableLocalStorage: t,
+    initialAnalysisType: i,
+    initialFunnelState: s,
+    initialFlowState: o,
+    initialRetentionState: l,
+    initialActiveView: d
+  })), /* @__PURE__ */ Fn(Ve.Provider, { value: f.current, children: n });
+}
+function u(n) {
+  const r = it(Ve);
+  if (!r)
+    throw new Error("useAnalysisBuilderStore must be used within AnalysisBuilderStoreProvider");
+  return Qn(r, n);
+}
+function gi() {
+  const n = it(Ve);
+  if (!n)
+    throw new Error("useAnalysisBuilderStoreApi must be used within AnalysisBuilderStoreProvider");
+  return n;
+}
+const Ee = (n) => n.queryStates[n.activeQueryIndex] || Q(), Yi = (n) => Ee(n).metrics, Xi = (n) => Ee(n).breakdowns, Zi = (n) => Ee(n).filters, mi = (n) => {
+  const r = n.charts[n.analysisType];
+  return r ? {
+    chartType: r.chartType,
+    chartConfig: r.chartConfig,
+    displayConfig: r.displayConfig
+  } : {
+    chartType: "bar",
+    chartConfig: {},
+    displayConfig: { showLegend: !0, showGrid: !0, showTooltip: !0 }
+  };
+}, er = (n) => ({
+  activeTab: n.activeTab,
+  activeView: n.activeView,
+  displayLimit: n.displayLimit,
+  showFieldModal: n.showFieldModal,
+  fieldModalMode: n.fieldModalMode
+}), tr = (n) => ({
+  queryStates: n.queryStates,
+  activeQueryIndex: n.activeQueryIndex,
+  mergeStrategy: n.mergeStrategy,
+  // Multi-query mode is when we have more than one query in 'query' analysis type
+  isMultiQueryMode: n.analysisType === "query" && n.queryStates.length > 1
+}), nr = (n) => ({
+  funnelCube: n.funnelCube,
+  funnelSteps: n.funnelSteps,
+  activeFunnelStepIndex: n.activeFunnelStepIndex,
+  funnelTimeDimension: n.funnelTimeDimension,
+  funnelBindingKey: n.funnelBindingKey,
+  isFunnelMode: n.analysisType === "funnel",
+  // Deprecated field kept for backward compat
+  stepTimeToConvert: n.stepTimeToConvert
+});
+function Xe(n) {
+  return n.timeDimensions || [];
+}
+function hi(n) {
+  const r = [];
+  if (n.length < 2) return r;
+  const e = Xe(n[0]);
+  if (e.length === 0) return r;
+  for (let t = 1; t < n.length; t++) {
+    const i = Xe(n[t]);
+    if (i.length === 0 && e.length > 0) {
+      r.push({
+        type: "missing_time_dimension",
+        queryIndex: t,
+        message: `Query ${t + 1} is missing time dimension "${e[0].dimension}"`,
+        details: { field: e[0].dimension }
+      });
+      continue;
+    }
+    for (const s of e) {
+      const o = i.find((l) => l.dimension === s.dimension);
+      o && o.granularity !== s.granularity && r.push({
+        type: "granularity_mismatch",
+        queryIndex: t,
+        message: `Query ${t + 1} uses "${o.granularity}" granularity but Query 1 uses "${s.granularity}"`,
+        details: {
+          field: s.dimension,
+          expectedGranularity: s.granularity,
+          actualGranularity: o.granularity
+        }
+      });
+    }
+  }
+  return r;
+}
+function pi(n, r) {
+  const e = [];
+  if (n.length < 2 || r.length === 0) return e;
+  for (let t = 0; t < n.length; t++) {
+    const i = n[t], s = /* @__PURE__ */ new Set([
+      ...i.dimensions || [],
+      ...i.timeDimensions?.map((o) => o.dimension) || []
+    ]);
+    for (const o of r)
+      s.has(o) || e.push({
+        type: "missing_merge_key",
+        queryIndex: t,
+        message: `Query ${t + 1} is missing merge dimension "${o}"`,
+        details: { field: o }
+      });
+  }
+  return e;
+}
+function Ci(n) {
+  const r = [];
+  if (n.length < 2) return r;
+  const e = /* @__PURE__ */ new Map();
+  n.forEach((s, o) => {
+    s.measures?.forEach((l) => {
+      e.has(l) || e.set(l, []), e.get(l).push(o);
+    });
+  });
+  const t = [], i = /* @__PURE__ */ new Set();
+  return e.forEach((s, o) => {
+    s.length > 1 && (t.push(o), s.forEach((l) => i.add(l)));
+  }), t.length > 0 && r.push({
+    type: "measure_collision",
+    queryIndices: Array.from(i).sort(),
+    message: `Measure${t.length > 1 ? "s" : ""} "${t.join('", "')}" appear${t.length === 1 ? "s" : ""} in multiple queries - first value will be used`,
+    affectedMeasures: t
+  }), r;
+}
+function Si(n) {
+  const r = [];
+  if (n.length < 2) return r;
+  const e = n.map((i) => i.timeDimensions?.[0]?.dateRange);
+  return new Set(e.map((i) => JSON.stringify(i))).size > 1 && r.push({
+    type: "asymmetric_date_range",
+    queryIndices: n.map((i, s) => s),
+    message: "Queries have different date ranges - some data points may be missing in merged results"
+  }), r;
+}
+function wi(n, r, e = []) {
+  const t = [], i = [];
+  return n.length < 2 ? { isValid: !0, errors: t, warnings: i } : (i.push(...Ci(n)), i.push(...Si(n)), r === "merge" && (t.push(...hi(n)), e.length > 0 && t.push(...pi(n, e))), {
+    isValid: t.length === 0,
+    errors: t,
+    warnings: i
+  });
+}
+function ir(n) {
+  return n.filter(
+    (r) => (r.measures?.length || 0) + (r.dimensions?.length || 0) + (r.timeDimensions?.length || 0) > 0
+  ).length >= 2;
+}
+function rr(n) {
+  if (n.isValid && n.warnings.length === 0)
+    return "Configuration is valid";
+  const r = [];
+  return n.errors.length > 0 && r.push(`${n.errors.length} error${n.errors.length > 1 ? "s" : ""}`), n.warnings.length > 0 && r.push(`${n.warnings.length} warning${n.warnings.length > 1 ? "s" : ""}`), r.join(", ");
+}
+function vi() {
+  const n = u((m) => m.queryStates), r = u((m) => m.activeQueryIndex), e = u((m) => m.mergeStrategy), t = u((m) => m.setActiveQueryIndex), i = u((m) => m.setMergeStrategy), s = u((m) => m.addQuery), o = u((m) => m.removeQuery), l = u((m) => m.getCurrentState), d = u((m) => m.getMergeKeys), f = u((m) => m.isMultiQueryMode), y = l(), g = f(), c = d(), p = F(() => {
+    const m = n[r] || y;
+    return ge(m.metrics, m.breakdowns, m.filters, m.order);
+  }, [n, r, y]), S = F(() => {
+    const m = n[0]?.breakdowns || [];
+    return n.map((D, B) => {
+      const L = e === "merge" && B > 0 ? m : D.breakdowns;
+      return ge(D.metrics, L, D.filters, D.order);
+    });
+  }, [n, e]), C = F(() => {
+    if (n.length <= 1) return null;
+    const m = S.filter((D) => D.measures && D.measures.length > 0 || D.dimensions && D.dimensions.length > 0 || D.timeDimensions && D.timeDimensions.length > 0);
+    return m.length < 2 ? null : {
+      queries: m,
+      mergeStrategy: e,
+      mergeKeys: c,
+      queryLabels: m.map((D, B) => `Q${B + 1}`)
+    };
+  }, [S, n.length, e, c]), b = F(() => g ? wi(S, e, c || []) : null, [g, S, e, c]), w = F(() => p.measures && p.measures.length > 0 || p.dimensions && p.dimensions.length > 0 || p.timeDimensions && p.timeDimensions.length > 0, [p]);
+  return {
+    queryState: y,
+    queryStates: n,
+    activeQueryIndex: r,
+    mergeStrategy: e,
+    isMultiQueryMode: g,
+    mergeKeys: c,
+    currentQuery: p,
+    allQueries: S,
+    multiQueryConfig: C,
+    multiQueryValidation: b,
+    isValidQuery: w,
+    // Actions
+    setActiveQueryIndex: t,
+    setMergeStrategy: i,
+    addQuery: s,
+    removeQuery: o
+  };
+}
+function bi(n) {
+  const { queryState: r, queryStates: e, isMultiQueryMode: t, mergeStrategy: i, activeQueryIndex: s } = n, o = F(() => {
+    if (!t) return r.metrics;
+    const f = /* @__PURE__ */ new Set(), y = [];
+    for (let g = 0; g < e.length; g++) {
+      const c = e[g];
+      for (const p of c.metrics) {
+        const S = `Q${g + 1}:${p.field}`;
+        f.has(S) || (f.add(S), y.push({
+          ...p,
+          label: `${p.label} (Q${g + 1})`
+        }));
+      }
+    }
+    return y;
+  }, [t, e, r.metrics]), l = F(() => {
+    if (!t) return r.breakdowns;
+    const f = /* @__PURE__ */ new Set(), y = [];
+    for (const g of e)
+      for (const c of g.breakdowns)
+        f.has(c.field) || (f.add(c.field), y.push(c));
+    return y;
+  }, [t, e, r.breakdowns]), d = F(() => i === "merge" && s > 0 ? e[0]?.breakdowns || [] : r.breakdowns, [i, s, e, r.breakdowns]);
+  return {
+    combinedMetrics: o,
+    combinedBreakdowns: l,
+    effectiveBreakdowns: d
+  };
+}
+function Di(n) {
+  const {
+    currentQuery: r,
+    allQueries: e,
+    multiQueryConfig: t,
+    isMultiQueryMode: i,
+    isValidQuery: s,
+    initialData: o,
+    // Unused - legacy mergeStrategy === 'funnel' is no longer supported
+    funnelBindingKey: l,
+    isFunnelModeEnabled: d,
+    analysisType: f,
+    serverFunnelQuery: y,
+    serverFlowQuery: g,
+    serverRetentionQuery: c,
+    retentionValidation: p
+  } = n, { getFieldLabel: S } = Dn(), C = f === "funnel" || d, b = f === "flow", w = f === "retention", m = f === "query" && i, D = f === "query" && !i, B = f === "funnel" && !!y, L = F(() => B || !C || !l || e.length < 2 ? null : $n(e, l), [B, C, l, e]), M = Kn(r, {
+    skip: !s || !D,
+    debounceMs: 300
+  }), A = Ln(t, {
+    skip: !t || !m,
+    debounceMs: 300
+  }), v = Vn(L, {
+    skip: !C || !L && !y,
+    debounceMs: 300,
+    prebuiltServerQuery: B ? y : void 0
+  }), h = En(g ?? null, {
+    skip: !b || !g,
+    debounceMs: 300
+  }), T = Un(c ?? null, {
+    skip: !w || !c,
+    debounceMs: 300,
+    getFieldLabel: S
+    // Pass label resolver for human-readable binding key display
+  }), U = Nn({
+    queries: i ? e : [r],
+    isMultiQueryMode: i,
+    skip: !s || C || b || w
+  }), W = Gn(
+    v.serverQuery,
+    { skip: !C || !v.serverQuery }
+  ), he = On(
+    h.serverQuery,
+    { skip: !b || !h.serverQuery }
+  ), te = Hn(
+    c,
+    { skip: !w || !c }
+  ), $ = w ? T.isLoading || T.isDebouncing : b ? h.isLoading || h.isDebouncing : C ? v.isExecuting || v.isDebouncing : m ? A.isLoading : M.isLoading, G = w ? T.isFetching : b ? h.isFetching : C ? v.isExecuting : m ? A.isFetching : M.isFetching, N = w ? T.error : b ? h.error : C ? v.error : m ? A.error : M.error, z = !!(M.debouncedQuery || A.debouncedConfig || !v.isDebouncing || // Funnel has debounced when not debouncing
+  !h.isDebouncing || // Flow has debounced when not debouncing
+  !T.isDebouncing), J = E((R) => {
+    w ? T.execute(R) : b ? h.refetch(R) : C ? v.execute(R) : m ? A.refetch(R) : M.refetch(R);
+  }, [w, b, C, m, T, h, v, A, M]), Y = F(() => {
+    const R = w ? T.chartData : b ? h.data : C ? v.chartData : m ? A.data : M.rawData;
+    return o && o.length > 0 && !R ? "success" : s ? $ && !R ? "loading" : G && R ? "refreshing" : N ? "error" : R ? "success" : "idle" : "idle";
+  }, [s, $, G, N, M.rawData, A.data, v.chartData, h.data, T.chartData, o, m, C, b, w]), X = F(() => w && T.chartData ? T.chartData.rows.map((R) => ({
+    "Retention.period": `P${R.period}`,
+    "Retention.rate": R.retentionRate,
+    "Retention.retained": R.retainedUsers,
+    "Retention.cohortSize": R.cohortSize,
+    "Retention.segment": R.breakdownValue || "All Users"
+  })) : b && h.data ? [h.data] : C && v.chartData ? v.chartData : m && A.data ? A.data : M.rawData ? M.rawData : o && o.length > 0 ? o : null, [M.rawData, A.data, v.chartData, h.data, T.chartData, o, m, C, b, w]), ne = F(() => C && v.stepResults ? v.stepResults.map((R) => R.data) : !m || !A.perQueryData ? null : A.perQueryData, [m, C, A.perQueryData, v.stepResults]), ie = C && v.executedQueries?.length > 0 ? v.executedQueries : null, re = C ? v.serverQuery : null, se = C ? W.debugData : null, ae = b ? h.serverQuery : null, oe = b ? h.data : null, le = b ? he.debugData : null, ue = w ? c ?? null : null, pe = w ? T.chartData : null, Ce = w ? te.debugData : null, Se = F(() => w ? T.needsRefresh : b ? h.needsRefresh : C ? v.needsRefresh : m ? !1 : M.needsRefresh, [w, b, C, m, T.needsRefresh, h.needsRefresh, v.needsRefresh, M.needsRefresh]);
+  return {
+    executionStatus: Y,
+    executionResults: X,
+    perQueryResults: ne,
+    isLoading: $,
+    isFetching: G,
+    error: N,
+    debugDataPerQuery: U.debugDataPerQuery,
+    hasDebounced: z,
+    refetch: J,
+    funnelExecutedQueries: ie,
+    funnelServerQuery: re,
+    funnelDebugData: se,
+    flowServerQuery: ae,
+    flowChartData: oe,
+    flowDebugData: le,
+    retentionServerQuery: ue,
+    retentionChartData: pe,
+    retentionDebugData: Ce,
+    retentionValidation: p ?? null,
+    needsRefresh: Se
+  };
+}
+function ft(n) {
+  return n.isTimeDimension;
+}
+function Ti(n) {
+  return n.find(ft);
+}
+function Fi(n) {
+  return n.find((r) => !r.isTimeDimension);
+}
+function Ue(n) {
+  return n.filter((r) => !r.isTimeDimension);
+}
+function yt(n) {
+  return n.filter(ft);
+}
+function Pe(n, r, e) {
+  const t = r.length, i = Ue(e).length, s = yt(e).length, o = e.length;
+  switch (n) {
+    // Always available charts
+    case "table":
+    case "markdown":
+      return { available: !0 };
+    // Measure-only charts (KPI Number, KPI Text)
+    case "kpiNumber":
+    case "kpiText":
+      return t < 1 ? { available: !1, reason: "Requires at least 1 measure" } : { available: !0 };
+    // Bar chart - needs dimension for categories + measure for values
+    case "bar":
+      return t < 1 ? { available: !1, reason: "Requires at least 1 measure" } : o < 1 ? { available: !1, reason: "Requires at least 1 breakdown for categories" } : { available: !0 };
+    // KPI Delta - needs dimension for ordering + measure for values
+    case "kpiDelta":
+      return t < 1 ? { available: !1, reason: "Requires at least 1 measure" } : o < 1 ? { available: !1, reason: "Requires at least 1 breakdown for ordering" } : { available: !0 };
+    // Line and area charts - need dimension/time + measure
+    case "line":
+    case "area":
+      return t < 1 ? { available: !1, reason: "Requires at least 1 measure" } : o < 1 ? { available: !1, reason: "Requires a breakdown (dimension or time)" } : { available: !0 };
+    // Pie chart - needs dimension (not time) + measure
+    case "pie":
+      return t < 1 ? { available: !1, reason: "Requires 1 measure" } : i < 1 ? { available: !1, reason: "Requires 1 dimension (not time dimension)" } : { available: !0 };
+    // Scatter - needs measure + any breakdown
+    case "scatter":
+      return t < 1 ? { available: !1, reason: "Requires at least 1 measure" } : t < 2 && o < 1 ? { available: !1, reason: "Requires 2 measures or 1 measure + 1 breakdown" } : { available: !0 };
+    // Bubble - needs 2+ measures and 1+ breakdown (dimension or time dimension for series)
+    case "bubble":
+      return t < 2 ? { available: !1, reason: "Requires at least 2 measures" } : o < 1 ? { available: !1, reason: "Requires at least 1 breakdown for series grouping" } : { available: !0 };
+    // Radar - needs dimension + measure
+    case "radar":
+      return t < 1 ? { available: !1, reason: "Requires at least 1 measure" } : i < 1 ? { available: !1, reason: "Requires at least 1 dimension" } : { available: !0 };
+    // Radial Bar - needs dimension + measure
+    case "radialBar":
+      return t < 1 ? { available: !1, reason: "Requires at least 1 measure" } : i < 1 ? { available: !1, reason: "Requires at least 1 dimension" } : { available: !0 };
+    // Treemap - needs dimension + measure
+    case "treemap":
+      return t < 1 ? { available: !1, reason: "Requires at least 1 measure" } : i < 1 ? { available: !1, reason: "Requires at least 1 dimension" } : { available: !0 };
+    // Activity Grid - needs time dimension + measure
+    case "activityGrid":
+      return t < 1 ? { available: !1, reason: "Requires at least 1 measure" } : s < 1 ? { available: !1, reason: "Requires a time dimension" } : { available: !0 };
+    default:
+      return { available: !0 };
+  }
+}
+function Qi(n, r) {
+  const e = [
+    "activityGrid",
+    "area",
+    "bar",
+    "bubble",
+    "kpiDelta",
+    "kpiNumber",
+    "kpiText",
+    "line",
+    "markdown",
+    "pie",
+    "radar",
+    "radialBar",
+    "scatter",
+    "table",
+    "treemap"
+  ], t = {};
+  for (const i of e)
+    t[i] = Pe(i, n, r);
+  return t;
+}
+function gt(n, r, e) {
+  if (Pe(e, n, r).available || n.length === 0 && r.length === 0)
+    return e;
+  const i = yt(r).length > 0, s = Ue(r).length > 0, o = n.length > 0;
+  return i && o ? "line" : s && o ? "bar" : o && !s && !i ? "kpiNumber" : "table";
+}
+function Me(n, r, e) {
+  const t = gt(n, r, e), i = Ai(t, n, r);
+  return { chartType: t, chartConfig: i };
+}
+function Ai(n, r, e) {
+  const t = Ti(e), i = Fi(e), s = Ue(e), o = e;
+  switch (n) {
+    case "line":
+    case "area":
+      return {
+        xAxis: t ? [t.field] : i ? [i.field] : [],
+        yAxis: r.map((l) => l.field),
+        series: s.length > 1 ? [s[1].field] : i && t ? [i.field] : []
+      };
+    case "bar":
+      return {
+        xAxis: i ? [i.field] : t ? [t.field] : [],
+        yAxis: r.map((l) => l.field),
+        series: s.length > 1 ? [s[1].field] : t && i ? [t.field] : []
+      };
+    case "pie":
+      return {
+        xAxis: i ? [i.field] : [],
+        yAxis: r.length > 0 ? [r[0].field] : []
+      };
+    case "scatter":
+      return r.length >= 2 ? {
+        xAxis: [r[0].field],
+        yAxis: [r[1].field],
+        series: i ? [i.field] : []
+      } : {
+        xAxis: o.length > 0 ? [o[0].field] : [],
+        yAxis: r.length > 0 ? [r[0].field] : [],
+        series: s.length > 1 ? [s[1].field] : []
+      };
+    case "bubble":
+      return {
+        xAxis: r.length > 0 ? [r[0].field] : [],
+        yAxis: r.length > 1 ? [r[1].field] : [],
+        sizeField: r.length > 2 ? r[2].field : r.length > 1 ? r[1].field : void 0,
+        series: i ? [i.field] : t ? [t.field] : []
+      };
+    case "radar":
+    case "radialBar":
+    case "treemap":
+      return {
+        xAxis: i ? [i.field] : [],
+        yAxis: r.length > 0 ? [r[0].field] : []
+      };
+    case "activityGrid":
+      return {
+        dateField: t ? [t.field] : [],
+        valueField: r.length > 0 ? [r[0].field] : []
+      };
+    case "kpiNumber":
+    case "kpiDelta":
+    case "kpiText":
+      return {
+        yAxis: r.length > 0 ? [r[0].field] : []
+      };
+    case "table":
+      return {
+        xAxis: [
+          ...e.map((l) => l.field),
+          ...r.map((l) => l.field)
+        ]
+      };
+    case "markdown":
+      return {};
+    default:
+      return {
+        xAxis: o.length > 0 ? [o[0].field] : [],
+        yAxis: r.map((l) => l.field)
+      };
+  }
+}
+function Ri(n, r, e, t) {
+  if (t && Pe(e, n, r).available)
+    return null;
+  const i = gt(n, r, e);
+  return i !== e ? i : null;
+}
+function Mi(n) {
+  const { externalColorPalette: r, combinedMetrics: e, combinedBreakdowns: t, hasDebounced: i } = n, s = u((h) => h.analysisType), { chartType: o, chartConfig: l, displayConfig: d } = u(Rn(mi)), f = u((h) => h.userManuallySelectedChart), y = u((h) => h.localPaletteName), g = u((h) => h.setChartTypeManual), c = u((h) => h.setChartConfig), p = u((h) => h.setDisplayConfig), S = u((h) => h.setFunnelChartType), C = u((h) => h.setFunnelChartConfig), b = u((h) => h.setFunnelDisplayConfig), w = u((h) => h.setLocalPaletteName), m = u((h) => h.setUserManuallySelectedChart), D = E(
+    (h) => {
+      if (s === "funnel")
+        S(h);
+      else {
+        g(h);
+        const { chartConfig: T } = Me(
+          e,
+          t,
+          h
+        );
+        c(T);
+      }
+    },
+    [
+      s,
+      e,
+      t,
+      S,
+      g,
+      c
+    ]
+  ), B = E(
+    (h) => {
+      s === "funnel" ? C(h) : c(h);
+    },
+    [s, C, c]
+  ), L = E(
+    (h) => {
+      s === "funnel" ? b(h) : p(h);
+    },
+    [s, b, p]
+  ), M = F(
+    () => Qi(e, t),
+    [e, t]
+  ), A = F(() => r ? Array.isArray(r) && typeof r[0] == "string" ? {
+    name: "custom",
+    label: "Custom",
+    colors: r,
+    gradient: r
+  } : r : Pn(y), [r, y]), v = me("");
+  return fe(() => {
+    if (!i || e.length === 0 && t.length === 0) return;
+    const h = JSON.stringify({
+      metrics: e.map((U) => U.field),
+      breakdowns: t.map((U) => ({ field: U.field, isTime: U.isTimeDimension }))
+    });
+    if (h === v.current) return;
+    v.current = h;
+    const T = Ri(
+      e,
+      t,
+      o,
+      f
+    );
+    if (T) {
+      const { chartConfig: U } = Me(
+        e,
+        t,
+        T
+      );
+      D(T), B(U), m(!1);
+    } else if ((e.length > 0 || t.length > 0) && !l.xAxis?.length && !l.yAxis?.length && !l.series?.length) {
+      const { chartConfig: W } = Me(
+        e,
+        t,
+        o
+      );
+      B(W);
+    }
+  }, [
+    i,
+    e,
+    t,
+    o,
+    f,
+    l,
+    D,
+    B,
+    m
+  ]), {
+    chartType: o,
+    chartConfig: l,
+    displayConfig: d,
+    colorPalette: A,
+    localPaletteName: y,
+    chartAvailability: M,
+    userManuallySelectedChart: f,
+    // Actions - mode-aware setters route to appropriate store fields
+    setChartType: D,
+    setChartConfig: B,
+    setDisplayConfig: L,
+    setLocalPaletteName: w
+  };
+}
+function xi() {
+  const n = u((c) => c.activeTab), r = u((c) => c.activeView), e = u((c) => c.displayLimit), t = u((c) => c.showFieldModal), i = u((c) => c.fieldModalMode), s = u((c) => c.userManuallySelectedChart), o = u((c) => c.setActiveTab), l = u((c) => c.setActiveView), d = u((c) => c.setDisplayLimit), f = u((c) => c.closeFieldModal), [y, g] = bn(0);
+  return {
+    // State
+    activeTab: n,
+    activeView: r,
+    displayLimit: e,
+    showFieldModal: t,
+    fieldModalMode: i,
+    activeTableIndex: y,
+    userManuallySelectedChart: s,
+    // Actions
+    setActiveTab: o,
+    setActiveView: l,
+    setDisplayLimit: d,
+    closeFieldModal: f,
+    setActiveTableIndex: g
+  };
+}
+const Ze = 1800, et = "share=";
+function tt(n) {
+  const r = JSON.stringify(n);
+  return rt.compressToEncodedURIComponent(r);
+}
+function qi(n) {
+  try {
+    const r = rt.decompressFromEncodedURIComponent(n);
+    if (!r) return null;
+    const e = JSON.parse(r);
+    return st(e) ? e : (console.warn("[shareUtils] Invalid AnalysisConfig in share URL"), null);
+  } catch {
+    return null;
+  }
+}
+function sr(n) {
+  const r = tt(n);
+  if (r.length <= Ze)
+    return { encoded: r, queryOnly: !1 };
+  const e = {
+    version: n.version,
+    analysisType: n.analysisType,
+    activeView: n.activeView,
+    charts: {},
+    // Drop chart config to save space
+    query: n.query
+  }, t = tt(e);
+  return t.length <= Ze ? { encoded: t, queryOnly: !0 } : { encoded: null, queryOnly: !0 };
+}
+function ki() {
+  if (typeof window > "u") return null;
+  const n = window.location.hash;
+  return !n || !n.startsWith(`#${et}`) ? null : n.slice(et.length + 1);
+}
+function Bi() {
+  if (typeof window > "u") return;
+  const n = new URL(window.location.href);
+  n.hash = "", window.history.replaceState(null, "", n.toString());
+}
+function Ii() {
+  const n = ki();
+  return n ? qi(n) : null;
+}
+function Vi(n) {
+  const {
+    currentQuery: r,
+    isValidQuery: e,
+    chartType: t,
+    chartConfig: i,
+    displayConfig: s,
+    onQueryChange: o,
+    onChartConfigChange: l
+  } = n, d = u((y) => y.load), f = me(!1);
+  fe(() => {
+    if (f.current) return;
+    f.current = !0;
+    const y = Ii();
+    y && (d(y), Bi());
+  }, [d]), fe(() => {
+    o && e && o(r);
+  }, [r, e, o]), fe(() => {
+    l && l({
+      chartType: t,
+      chartConfig: i,
+      displayConfig: s
+    });
+  }, [t, i, s, l]);
+}
+function ar(n = {}) {
+  const { initialData: r, externalColorPalette: e, onQueryChange: t, onChartConfigChange: i } = n, { features: s } = Tn(), o = gi(), l = vi(), d = bi({
+    queryState: l.queryState,
+    queryStates: l.queryStates,
+    isMultiQueryMode: l.isMultiQueryMode,
+    mergeStrategy: l.mergeStrategy,
+    activeQueryIndex: l.activeQueryIndex
+  }), f = u((a) => a.funnelBindingKey), y = u((a) => a.analysisType), g = u((a) => a.funnelCube), c = u((a) => a.funnelSteps), p = u((a) => a.activeFunnelStepIndex), S = u((a) => a.funnelTimeDimension), C = F(() => y !== "funnel" || !f?.dimension || !S || !c || c.length < 2 ? !1 : c.every((a) => a.filters.length > 0), [y, f, S, c]), b = u((a) => a.charts.funnel?.chartType) || "funnel", w = u((a) => a.charts.funnel?.chartConfig), m = F(() => w || {}, [w]), D = u((a) => a.flowCube), B = u((a) => a.flowBindingKey), L = u((a) => a.flowTimeDimension), M = u((a) => a.eventDimension), A = u((a) => a.startingStep), v = u((a) => a.stepsBefore), h = u((a) => a.stepsAfter), T = u((a) => a.joinStrategy), U = u((a) => a.charts.flow?.displayConfig), W = F(
+    () => U || { showLegend: !0, showGrid: !0, showTooltip: !0 },
+    [U]
+  ), he = u((a) => a.charts.flow?.chartType) || "sankey", te = u((a) => a.buildFunnelQueryFromSteps), $ = F(() => y !== "funnel" ? null : te(), [y, te, c]), G = u((a) => a.buildFlowQuery), N = F(() => y !== "flow" ? null : G(), [y, G, D, B, L, M, A, v, h, he, T]), z = u((a) => a.retentionCube), J = u((a) => a.retentionBindingKey), Y = u((a) => a.retentionTimeDimension), X = u((a) => a.retentionDateRange), ne = u((a) => a.retentionCohortFilters), ie = u((a) => a.retentionActivityFilters), re = u((a) => a.retentionBreakdowns), se = u((a) => a.retentionViewGranularity), ae = u((a) => a.retentionPeriods), oe = u((a) => a.retentionType), le = u((a) => a.buildRetentionQuery), ue = u((a) => a.getRetentionValidation), pe = u((a) => a.charts.retention?.displayConfig), Ce = u((a) => a.setRetentionCube), Se = u((a) => a.setRetentionBindingKey), R = u((a) => a.setRetentionTimeDimension), mt = u((a) => a.setRetentionDateRange), ht = u((a) => a.setRetentionCohortFilters), pt = u((a) => a.setRetentionActivityFilters), Ct = u((a) => a.setRetentionBreakdowns), we = u((a) => a.addRetentionBreakdown), St = u((a) => a.removeRetentionBreakdown), wt = u((a) => a.setRetentionViewGranularity), vt = u((a) => a.setRetentionPeriods), bt = u((a) => a.setRetentionType), ve = F(() => y !== "retention" ? null : le(), [
+    y,
+    le,
+    z,
+    J,
+    Y,
+    X,
+    re,
+    se,
+    ae,
+    oe,
+    ne,
+    ie
+  ]), Dt = F(() => y !== "retention" ? null : ue(), [
+    y,
+    ue,
+    z,
+    J,
+    Y,
+    X
+  ]), be = F(() => y === "retention" ? ve !== null : y === "flow" ? N !== null : y === "funnel" ? $ !== null : l.isValidQuery ?? !1, [y, ve, N, $, l.isValidQuery]), x = Di({
+    currentQuery: l.currentQuery,
+    allQueries: l.allQueries,
+    multiQueryConfig: l.multiQueryConfig,
+    isMultiQueryMode: l.isMultiQueryMode,
+    isValidQuery: be,
+    initialData: r,
+    funnelBindingKey: f,
+    isFunnelModeEnabled: C,
+    // New: pass analysisType and serverFunnelQuery for explicit mode routing
+    analysisType: y,
+    serverFunnelQuery: $,
+    // Flow mode: pass serverFlowQuery
+    serverFlowQuery: N,
+    // Retention mode: pass serverRetentionQuery
+    serverRetentionQuery: ve,
+    // Retention mode: pass validation for debug panel
+    retentionValidation: Dt
+  }), q = Mi({
+    externalColorPalette: e,
+    combinedMetrics: d.combinedMetrics,
+    combinedBreakdowns: d.combinedBreakdowns,
+    hasDebounced: x.hasDebounced
+  }), I = xi();
+  Vi({
+    currentQuery: l.currentQuery,
+    isValidQuery: l.isValidQuery ?? !1,
+    chartType: q.chartType,
+    chartConfig: q.chartConfig,
+    displayConfig: q.displayConfig,
+    onQueryChange: t,
+    onChartConfigChange: i
+  });
+  const Tt = u((a) => a.openMetricsModal), Ft = u((a) => a.addMetric), Qt = u((a) => a.removeMetric), De = u((a) => a.toggleMetric), At = u((a) => a.reorderMetrics), Rt = u((a) => a.openBreakdownsModal), Mt = u((a) => a.addBreakdown), xt = u((a) => a.removeBreakdown), Te = u((a) => a.toggleBreakdown), qt = u((a) => a.setBreakdownGranularity), kt = u((a) => a.toggleBreakdownComparison), Bt = u((a) => a.reorderBreakdowns), It = u((a) => a.setFilters), Vt = u((a) => a.dropFieldToFilter), Et = u((a) => a.setOrder), Ut = u((a) => a.clearQuery), Pt = u((a) => a.clearCurrentMode), _t = u((a) => a.setFunnelBindingKey), Kt = u((a) => a.setAnalysisType), Lt = u((a) => a.setFunnelCube), $t = u((a) => a.addFunnelStep), Nt = u((a) => a.removeFunnelStep), Gt = u((a) => a.updateFunnelStep), Ot = u((a) => a.setActiveFunnelStepIndex), Ht = u((a) => a.reorderFunnelSteps), jt = u((a) => a.setFunnelTimeDimension), _e = u((a) => a.charts.funnel?.displayConfig), Wt = F(
+    () => _e || { showLegend: !0, showGrid: !0, showTooltip: !0 },
+    [_e]
+  ), zt = u((a) => a.setFunnelDisplayConfig), Jt = u((a) => a.setFlowCube), Yt = u((a) => a.setFlowBindingKey), Xt = u((a) => a.setFlowTimeDimension), Zt = u((a) => a.setEventDimension), en = u((a) => a.setStartingStepName), tn = u((a) => a.setStartingStepFilters), nn = u((a) => a.setStepsBefore), rn = u((a) => a.setStepsAfter), sn = u((a) => a.setJoinStrategy), an = E(
+    (a) => {
+      o.setState((k) => ({
+        charts: {
+          ...k.charts,
+          flow: {
+            ...k.charts.flow || { chartType: "sankey", chartConfig: {}, displayConfig: {} },
+            displayConfig: a
+          }
+        }
+      }));
+    },
+    [o]
+  ), on = E(
+    (a) => {
+      o.setState((k) => ({
+        charts: {
+          ...k.charts,
+          retention: {
+            ...k.charts.retention || { chartType: "retentionCombined", chartConfig: {}, displayConfig: {} },
+            displayConfig: a
+          }
+        }
+      }));
+    },
+    [o]
+  ), Z = u((a) => a.aiState), ln = u((a) => a.openAI), ee = u((a) => a.closeAI), un = u((a) => a.setAIPrompt), Fe = u((a) => a.setAIGenerating), Qe = u((a) => a.setAIError), ce = u((a) => a.setAIHasGeneratedQuery), Ke = u((a) => a.saveAIPreviousState), Le = u((a) => a.restoreAIPreviousState), Ae = me("idle"), cn = be, $e = u((a) => a.getValidation), dn = F(
+    () => $e(),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      $e,
+      l.queryStates,
+      y,
+      // Funnel deps
+      c,
+      f,
+      S,
+      // Flow deps
+      D,
+      B,
+      L,
+      M,
+      A,
+      v,
+      h,
+      T
+    ]
+  ), fn = E(
+    (a, k, Ne, wn) => {
+      I.fieldModalMode === "metrics" && k === "measure" ? De(a.name) : I.fieldModalMode === "breakdown" && (y === "retention" && k === "dimension" ? we({ field: a.name }) : Te(a.name, k === "timeDimension")), wn || I.closeFieldModal();
+    },
+    [I, De, Te, we, y]
+  ), yn = E(async () => {
+    if (s?.aiEndpoint) {
+      Ke(), Fe(!0), Qe(null);
+      try {
+        await new Promise((a) => setTimeout(a, 1e3)), ce(!0);
+      } catch (a) {
+        Qe(a instanceof Error ? a.message : "Failed to generate query");
+      } finally {
+        Fe(!1);
+      }
+    }
+  }, [s?.aiEndpoint, Ke, Fe, Qe, ce]), gn = E(() => {
+    ee(), ce(!1);
+  }, [ee, ce]), mn = E(() => {
+    Le(), ee();
+  }, [Le, ee]), hn = E(async () => {
+    Ae.current = "copied", setTimeout(() => {
+      Ae.current = "idle";
+    }, 2e3);
+  }, []), pn = E(() => {
+    const a = o.getState();
+    if (a.analysisType === "funnel") {
+      const k = a.buildFunnelQueryFromSteps();
+      return k || a.buildCurrentQuery();
+    }
+    return a.queryStates.length > 1 ? {
+      queries: a.buildAllQueries(),
+      mergeStrategy: a.mergeStrategy,
+      mergeKeys: a.getMergeKeys(),
+      queryLabels: a.queryStates.map((k, Ne) => `Q${Ne + 1}`),
+      // Include funnel-specific config when in funnel mode
+      funnelBindingKey: a.funnelBindingKey,
+      stepTimeToConvert: a.stepTimeToConvert
+    } : a.buildCurrentQuery();
+  }, [o]), Cn = E(() => {
+    const a = o.getState(), k = a.charts[a.analysisType];
+    return k ? {
+      chartType: k.chartType,
+      chartConfig: k.chartConfig,
+      displayConfig: k.displayConfig
+    } : {
+      chartType: q.chartType,
+      chartConfig: q.chartConfig,
+      displayConfig: q.displayConfig
+    };
+  }, [o, q.chartType, q.chartConfig, q.displayConfig]), Sn = E(() => o.getState().analysisType, [o]);
+  return {
+    // Query state (from queryBuilder)
+    queryState: l.queryState,
+    queryStates: l.queryStates,
+    activeQueryIndex: l.activeQueryIndex,
+    mergeStrategy: l.mergeStrategy,
+    isMultiQueryMode: l.isMultiQueryMode,
+    mergeKeys: l.mergeKeys,
+    currentQuery: l.currentQuery,
+    allQueries: l.allQueries,
+    multiQueryConfig: l.multiQueryConfig,
+    multiQueryValidation: l.multiQueryValidation,
+    // Funnel state (legacy)
+    funnelBindingKey: f,
+    isFunnelModeEnabled: C,
+    // Analysis Type state (new)
+    analysisType: y,
+    funnelCube: g,
+    funnelSteps: c,
+    activeFunnelStepIndex: p,
+    funnelTimeDimension: S,
+    funnelChartType: b,
+    funnelChartConfig: m,
+    funnelDisplayConfig: Wt,
+    // Flow state (new)
+    flowCube: D,
+    flowBindingKey: B,
+    flowTimeDimension: L,
+    eventDimension: M,
+    startingStep: A,
+    stepsBefore: v,
+    stepsAfter: h,
+    joinStrategy: T,
+    flowDisplayConfig: W,
+    // Retention state (simplified Mixpanel-style)
+    retentionCube: z,
+    retentionBindingKey: J,
+    retentionTimeDimension: Y,
+    retentionDateRange: X,
+    retentionCohortFilters: ne,
+    retentionActivityFilters: ie,
+    retentionBreakdowns: re,
+    retentionViewGranularity: se,
+    retentionPeriods: ae,
+    retentionType: oe,
+    retentionDisplayConfig: pe,
+    // Data fetching (from queryExecution)
+    executionStatus: x.executionStatus,
+    executionResults: x.executionResults,
+    perQueryResults: x.perQueryResults,
+    isLoading: x.isLoading,
+    isFetching: x.isFetching,
+    error: x.error,
+    isValidQuery: be,
+    debugDataPerQuery: x.debugDataPerQuery,
+    needsRefresh: x.needsRefresh,
+    funnelExecutedQueries: x.funnelExecutedQueries,
+    funnelServerQuery: x.funnelServerQuery,
+    funnelDebugData: x.funnelDebugData,
+    flowServerQuery: x.flowServerQuery,
+    flowDebugData: x.flowDebugData,
+    retentionServerQuery: x.retentionServerQuery,
+    retentionDebugData: x.retentionDebugData,
+    retentionChartData: x.retentionChartData,
+    retentionValidation: x.retentionValidation,
+    // Chart configuration (from chartDefaults)
+    // Note: Funnel chart type is determined by analysisType === 'funnel', not mergeStrategy
+    chartType: q.chartType,
+    chartConfig: q.chartConfig,
+    displayConfig: q.displayConfig,
+    colorPalette: q.colorPalette,
+    localPaletteName: q.localPaletteName,
+    chartAvailability: q.chartAvailability,
+    combinedMetrics: d.combinedMetrics,
+    combinedBreakdowns: d.combinedBreakdowns,
+    effectiveBreakdowns: d.effectiveBreakdowns,
+    // UI state (from uiState)
+    activeTab: I.activeTab,
+    activeView: I.activeView,
+    displayLimit: I.displayLimit,
+    showFieldModal: I.showFieldModal,
+    fieldModalMode: I.fieldModalMode,
+    activeTableIndex: I.activeTableIndex,
+    userManuallySelectedChart: I.userManuallySelectedChart,
+    // AI state
+    aiState: {
+      isOpen: Z.isOpen,
+      userPrompt: Z.userPrompt,
+      isGenerating: Z.isGenerating,
+      error: Z.error,
+      hasGeneratedQuery: Z.hasGeneratedQuery
+    },
+    // Share state
+    shareButtonState: Ae.current,
+    canShare: cn,
+    // Adapter validation (NEW - Phase 5)
+    adapterValidation: dn,
+    // Actions
+    actions: {
+      // Query state (from queryBuilder)
+      setActiveQueryIndex: l.setActiveQueryIndex,
+      setMergeStrategy: l.setMergeStrategy,
+      // Metrics
+      openMetricsModal: Tt,
+      addMetric: Ft,
+      removeMetric: Qt,
+      toggleMetric: De,
+      reorderMetrics: At,
+      // Breakdowns
+      openBreakdownsModal: Rt,
+      addBreakdown: Mt,
+      removeBreakdown: xt,
+      toggleBreakdown: Te,
+      setBreakdownGranularity: qt,
+      toggleBreakdownComparison: kt,
+      reorderBreakdowns: Bt,
+      // Filters
+      setFilters: It,
+      dropFieldToFilter: Vt,
+      setOrder: Et,
+      // Multi-query (from queryBuilder)
+      addQuery: l.addQuery,
+      removeQuery: l.removeQuery,
+      // Funnel (legacy)
+      setFunnelBindingKey: _t,
+      // Analysis Type (new)
+      setAnalysisType: Kt,
+      // Funnel Mode (new dedicated state)
+      setFunnelCube: Lt,
+      addFunnelStep: $t,
+      removeFunnelStep: Nt,
+      updateFunnelStep: Gt,
+      setActiveFunnelStepIndex: Ot,
+      reorderFunnelSteps: Ht,
+      setFunnelTimeDimension: jt,
+      setFunnelDisplayConfig: zt,
+      // Flow Mode actions
+      setFlowCube: Jt,
+      setFlowBindingKey: Yt,
+      setFlowTimeDimension: Xt,
+      setEventDimension: Zt,
+      setStartingStepName: en,
+      setStartingStepFilters: tn,
+      setStepsBefore: nn,
+      setStepsAfter: rn,
+      setJoinStrategy: sn,
+      setFlowDisplayConfig: an,
+      // Retention Mode actions (simplified Mixpanel-style)
+      setRetentionCube: Ce,
+      setRetentionBindingKey: Se,
+      setRetentionTimeDimension: R,
+      setRetentionDateRange: mt,
+      setRetentionCohortFilters: ht,
+      setRetentionActivityFilters: pt,
+      setRetentionBreakdowns: Ct,
+      addRetentionBreakdown: we,
+      removeRetentionBreakdown: St,
+      setRetentionViewGranularity: wt,
+      setRetentionPeriods: vt,
+      setRetentionType: bt,
+      setRetentionDisplayConfig: on,
+      // Chart (from chartDefaults)
+      setChartType: q.setChartType,
+      setChartConfig: q.setChartConfig,
+      setDisplayConfig: q.setDisplayConfig,
+      setLocalPaletteName: q.setLocalPaletteName,
+      // UI (from uiState)
+      setActiveTab: I.setActiveTab,
+      setActiveView: I.setActiveView,
+      setDisplayLimit: I.setDisplayLimit,
+      closeFieldModal: I.closeFieldModal,
+      setActiveTableIndex: I.setActiveTableIndex,
+      // AI
+      openAI: ln,
+      closeAI: ee,
+      setAIPrompt: un,
+      generateAI: yn,
+      acceptAI: gn,
+      cancelAI: mn,
+      // Share
+      share: hn,
+      // Utility
+      clearQuery: Ut,
+      clearCurrentMode: Pt,
+      refetch: x.refetch,
+      handleFieldSelected: fn
+    },
+    // Refs
+    getQueryConfig: pn,
+    getChartConfig: Cn,
+    getAnalysisType: Sn
+  };
+}
+function Ei(n, r) {
+  const e = [];
+  if (!r?.cubes)
+    return e;
+  if (typeof n.dimension == "string") {
+    const [t, i] = n.dimension.split("."), s = r.cubes.find((o) => o.name === t);
+    s ? s.dimensions?.find((l) => l.name === n.dimension) || e.push({
+      type: "binding_key",
+      message: `Dimension "${i}" not found in cube "${t}"`
+    }) : e.push({
+      type: "binding_key",
+      message: `Cube "${t}" not found for binding key`
+    });
+  } else
+    for (const t of n.dimension) {
+      const i = r.cubes.find((s) => s.name === t.cube);
+      i ? i.dimensions?.find((o) => o.name === t.dimension) || e.push({
+        type: "cross_cube",
+        message: `Dimension "${t.dimension}" not found in cube "${t.cube}"`
+      }) : e.push({
+        type: "cross_cube",
+        message: `Cube "${t.cube}" not found for binding key mapping`
+      });
+    }
+  return e;
+}
+function Ui(n) {
+  const r = [];
+  for (let e = 0; e < n.length; e++) {
+    const t = n[e], i = t.query;
+    i.measures && i.measures.length > 0 || i.dimensions && i.dimensions.length > 0 || i.timeDimensions && i.timeDimensions.length > 0 || r.push({
+      type: "step_query",
+      message: `Step ${e + 1} "${t.name}" has no measures, dimensions, or time dimensions`,
+      stepIndex: e
+    });
+  }
+  return r;
+}
+function Pi(n, r) {
+  if (typeof n.dimension == "string")
+    return !0;
+  const e = at(r);
+  return e ? n.dimension.some((t) => t.cube === e) : !1;
+}
+function _i(n, r) {
+  const e = [];
+  for (let t = 0; t < r.length; t++) {
+    const i = r[t];
+    if (!Pi(n, i.query)) {
+      const s = at(i.query) || "unknown";
+      e.push({
+        type: "cross_cube",
+        message: `Step ${t + 1} uses cube "${s}" but no binding key mapping exists for it`,
+        stepIndex: t
+      });
+    }
+  }
+  return e;
+}
+function nt(n) {
+  return n ? /^P(?:\d+Y)?(?:\d+M)?(?:\d+W)?(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+S)?)?$/.test(n) ? null : {
+    type: "time_window",
+    message: `Invalid time window format "${n}". Expected ISO 8601 duration (e.g., P7D, PT1H)`
+  } : null;
+}
+function or(n, r) {
+  const e = [], t = [];
+  n.steps.length < 2 && e.push({
+    type: "general",
+    message: "Funnel requires at least 2 steps"
+  }), n.bindingKey?.dimension ? (e.push(...Ei(n.bindingKey, r)), e.push(..._i(n.bindingKey, n.steps))) : e.push({
+    type: "binding_key",
+    message: "Binding key dimension is required"
+  }), e.push(...Ui(n.steps));
+  for (let s = 0; s < n.steps.length; s++) {
+    const o = n.steps[s], l = nt(o.timeToConvert);
+    l && (l.stepIndex = s, e.push(l));
+  }
+  const i = nt(n.globalTimeWindow);
+  return i && e.push(i), n.steps.length > 5 && t.push({
+    type: "general",
+    message: "Funnels with more than 5 steps may have reduced performance"
+  }), {
+    isValid: e.length === 0,
+    errors: e,
+    warnings: t
+  };
+}
+function lr(n, r) {
+  return r < 2 ? { isValid: !1, message: "Add at least 2 steps for funnel" } : n?.dimension ? typeof n.dimension == "string" && !n.dimension ? { isValid: !1, message: "Select a binding key dimension" } : Array.isArray(n.dimension) && n.dimension.length === 0 ? { isValid: !1, message: "Select a binding key dimension" } : { isValid: !0 } : { isValid: !1, message: "Select a binding key dimension" };
+}
+function ur(n) {
+  if (!n?.cubes) return [];
+  const r = [];
+  for (const e of n.cubes)
+    if (e.dimensions)
+      for (const t of e.dimensions)
+        (t.type === "string" || t.type === "number") && r.push({
+          cube: e.name,
+          dimension: t.name,
+          label: t.title || t.shortTitle || t.name.split(".")[1] || t.name
+        });
+  return r;
+}
+function cr(n) {
+  if (!n?.dimension) return "Select binding key...";
+  if (typeof n.dimension == "string")
+    return n.dimension.split(".")[1] || n.dimension;
+  if (n.dimension.length > 0) {
+    const r = n.dimension[0];
+    return `${r.dimension.split(".")[1] || r.dimension} (${n.dimension.length} cubes)`;
+  }
+  return "Select binding key...";
+}
+export {
+  qi as A,
+  Ji as B,
+  gi as C,
+  u as a,
+  Yi as b,
+  Xi as c,
+  Zi as d,
+  mi as e,
+  er as f,
+  tr as g,
+  nr as h,
+  hi as i,
+  pi as j,
+  Ci as k,
+  Si as l,
+  ir as m,
+  rr as n,
+  or as o,
+  Ei as p,
+  Ui as q,
+  _i as r,
+  Ee as s,
+  lr as t,
+  ar as u,
+  wi as v,
+  ur as w,
+  cr as x,
+  sr as y,
+  ki as z
+};
+//# sourceMappingURL=analysis-builder-shared-gS0TDC6Y.js.map