@salesmind-ai/design-system 0.3.1 → 0.3.3

package/dist/report/index.cjs

@@ -1,2414 +1,182 @@
 'use strict';
 
-var React2 = require('react');
-var jsxRuntime = require('react/jsx-runtime');
-var clsx12 = require('clsx');
-var select = require('@base-ui/react/select');
-var menu = require('@base-ui/react/menu');
+var chunk4GM5BGBN_cjs = require('../chunk-4GM5BGBN.cjs');
+var chunkQ2MFGYTE_cjs = require('../chunk-Q2MFGYTE.cjs');
+var chunk3TGSIILM_cjs = require('../chunk-3TGSIILM.cjs');
 
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var React2__default = /*#__PURE__*/_interopDefault(React2);
-var clsx12__default = /*#__PURE__*/_interopDefault(clsx12);
 
-// src/report-engine/constants.ts
-var EXECUTIVE_MODE = {
-  mode: "executive",
-  features: {
-    showMethodology: false,
-    showConfidenceScores: false,
-    showRawData: false,
-    showStatisticalTests: false,
-    chartDetailLevel: "summary",
-    maxInsightsShown: 5,
-    allowDrilldown: false
-  }
-};
-var ANALYST_MODE = {
-  mode: "analyst",
-  features: {
-    showMethodology: true,
-    showConfidenceScores: true,
-    showRawData: true,
-    showStatisticalTests: true,
-    chartDetailLevel: "detailed",
-    maxInsightsShown: 20,
-    allowDrilldown: true
-  }
-};
-var CONFIDENCE_THRESHOLDS = [
-  { level: "high", min: 90, max: 100, label: "High Confidence", color: "var(--status-success)" },
-  {
-    level: "moderate",
-    min: 70,
-    max: 89,
-    label: "Moderate Confidence",
-    color: "var(--status-info)"
-  },
-  { level: "low", min: 50, max: 69, label: "Low Confidence", color: "var(--status-warning)" },
-  {
-    level: "insufficient",
-    min: 0,
-    max: 49,
-    label: "Insufficient Data",
-    color: "var(--status-error)"
-  }
-];
-var MINIMUM_SAMPLE_SIZES = {
-  overall: 30,
-  segment: 30,
-  mbtiType: 50,
-  correlation: 100,
-  timeSeries: 7
-};
-var INSIGHT_TYPE_CONTRACTS = {
-  "performance-delta": {
-    type: "performance-delta",
-    allowedCharts: ["BarChart", "LineChart", "KeyMetric"],
-    requiredFields: ["metric_name", "current_value", "previous_value", "time_period"],
-    minSampleSize: 30,
-    headlinePattern: "{metric} {direction} by {delta}% {timeframe}",
-    recommendationFormats: ["maintain-strategy", "investigate-decline", "scale-success"]
-  },
-  "behavioral-correlation": {
-    type: "behavioral-correlation",
-    allowedCharts: ["HeatmapChart", "BarChart"],
-    requiredFields: ["variable_a", "variable_b", "correlation_coefficient"],
-    minSampleSize: 100,
-    headlinePattern: "{variable_a} correlates with {variable_b}",
-    recommendationFormats: ["leverage-correlation", "investigate-causation"]
-  },
-  "funnel-leakage": {
-    type: "funnel-leakage",
-    allowedCharts: ["FunnelChart", "BarChart"],
-    requiredFields: ["stages", "stage_counts", "drop_rates"],
-    minSampleSize: 50,
-    headlinePattern: "{drop_rate}% drop-off at {stage}",
-    recommendationFormats: ["optimize-stage", "remove-friction"]
-  },
-  "audience-mismatch": {
-    type: "audience-mismatch",
-    allowedCharts: ["BarChart", "PieChart"],
-    requiredFields: ["target_audience", "actual_audience", "overlap_percentage"],
-    minSampleSize: 50,
-    headlinePattern: "Target audience differs by {mismatch}%",
-    recommendationFormats: ["refine-targeting", "expand-audience"]
-  },
-  "message-fatigue": {
-    type: "message-fatigue",
-    allowedCharts: ["LineChart", "BarChart"],
-    requiredFields: ["message_sequence", "engagement_rates", "fatigue_point"],
-    minSampleSize: 100,
-    headlinePattern: "Engagement drops {drop}% after message {n}",
-    recommendationFormats: ["reduce-frequency", "vary-content"]
-  },
-  "psychological-resonance": {
-    type: "psychological-resonance",
-    allowedCharts: ["MBTIRadar", "MBTITypeGrid", "BarChart"],
-    requiredFields: ["mbti_types", "response_rates", "message_type"],
-    minSampleSize: 50,
-    headlinePattern: "{mbti_type} responds {rate}% better to {message_type}",
-    recommendationFormats: ["personalize-messaging", "segment-by-type"]
-  },
-  "timing-pattern": {
-    type: "timing-pattern",
-    allowedCharts: ["HeatmapChart", "LineChart"],
-    requiredFields: ["time_slots", "engagement_rates"],
-    minSampleSize: 100,
-    headlinePattern: "Best engagement on {day} at {time}",
-    recommendationFormats: ["optimize-timing", "schedule-sends"]
-  },
-  "segment-outperformance": {
-    type: "segment-outperformance",
-    allowedCharts: ["BarChart", "KeyMetric"],
-    requiredFields: ["segments", "performance_metrics", "baseline"],
-    minSampleSize: 30,
-    headlinePattern: "{segment} outperforms by {delta}%",
-    recommendationFormats: ["double-down", "investigate-success"]
-  },
-  "anomaly-detection": {
-    type: "anomaly-detection",
-    allowedCharts: ["LineChart", "BarChart"],
-    requiredFields: ["metric", "expected_value", "actual_value", "deviation"],
-    minSampleSize: 30,
-    headlinePattern: "Unusual {direction} in {metric}",
-    recommendationFormats: ["investigate", "monitor"]
-  },
-  "competitive-benchmark": {
-    type: "competitive-benchmark",
-    allowedCharts: ["BarChart", "KeyMetric"],
-    requiredFields: ["metric", "our_value", "benchmark_value"],
-    minSampleSize: 30,
-    headlinePattern: "{position} industry benchmark by {delta}%",
-    recommendationFormats: ["maintain-lead", "close-gap"]
-  }
-};
-var ANALYTICAL_STATE_CONFIG = {
-  VALID: {
-    label: "Valid",
-    icon: "check",
-    color: "var(--status-success)",
-    action: null
-  },
-  INSUFFICIENT_SAMPLE: {
-    label: "Insufficient Sample",
-    icon: "alert-triangle",
-    color: "var(--status-warning)",
-    action: "Add more data"
-  },
-  LOW_CONFIDENCE: {
-    label: "Low Confidence",
-    icon: "alert-circle",
-    color: "var(--status-warning)",
-    action: "Interpret with caution"
-  },
-  PARTIAL_TIME_WINDOW: {
-    label: "Partial Data",
-    icon: "clock",
-    color: "var(--status-info)",
-    action: "Expand date range"
-  },
-  DATA_SKEW_DETECTED: {
-    label: "Data Skew",
-    icon: "bar-chart-2",
-    color: "var(--status-warning)",
-    action: "Review methodology"
-  },
-  CONFLICTING_SIGNALS: {
-    label: "Conflicting Signals",
-    icon: "git-merge",
-    color: "var(--status-error)",
-    action: "Manual review needed"
-  },
-  INFERRED_NOT_OBSERVED: {
-    label: "AI Generated",
-    icon: "cpu",
-    color: "var(--status-info)",
-    action: "Verify with data"
-  },
-  STALE_DATA: {
-    label: "Stale Data",
-    icon: "clock",
-    color: "var(--status-warning)",
-    action: "Refresh data"
-  },
-  FIELD_MISSING: {
-    label: "Missing Field",
-    icon: "file-x",
-    color: "var(--status-error)",
-    action: "Upload complete data"
-  },
-  CALCULATION_ERROR: {
-    label: "Calculation Error",
-    icon: "x-circle",
-    color: "var(--status-error)",
-    action: "Contact support"
-  }
-};
-
-// src/report-engine/confidence.ts
-function calculateConfidence(params) {
-  const { sampleSize, requiredSize, completeness, recency, variance, aiInference } = params;
-  const sampleScore = Math.min(40, sampleSize / requiredSize * 40);
-  const completenessScore = completeness * 20;
-  const recencyScore = recency * 20;
-  const variancePenalty = variance * 10;
-  const aiPenalty = aiInference ? 10 : 0;
-  const rawScore = sampleScore + completenessScore + recencyScore - variancePenalty - aiPenalty;
-  return Math.max(0, Math.min(100, Math.round(rawScore)));
-}
-function getConfidenceLevel(score) {
-  const threshold = CONFIDENCE_THRESHOLDS.find((t) => score >= t.min && score <= t.max);
-  return threshold?.level ?? "insufficient";
-}
-function getConfidenceThreshold(score) {
-  return CONFIDENCE_THRESHOLDS.find((t) => score >= t.min && score <= t.max) ?? CONFIDENCE_THRESHOLDS[CONFIDENCE_THRESHOLDS.length - 1];
-}
-function calculateRecency(dataDate, maxAgeDays = 30) {
-  const now = /* @__PURE__ */ new Date();
-  const ageInDays = (now.getTime() - dataDate.getTime()) / (1e3 * 60 * 60 * 24);
-  if (ageInDays <= 0) return 1;
-  if (ageInDays >= maxAgeDays) return 0;
-  return 1 - ageInDays / maxAgeDays;
-}
-function calculateCompleteness(data, requiredFields) {
-  if (data.length === 0 || requiredFields.length === 0) return 0;
-  let totalFields = 0;
-  let filledFields = 0;
-  for (const record of data) {
-    for (const field of requiredFields) {
-      totalFields++;
-      const value = record[field];
-      if (value !== null && value !== void 0 && value !== "") {
-        filledFields++;
-      }
-    }
-  }
-  return totalFields > 0 ? filledFields / totalFields : 0;
-}
-function calculateNormalizedVariance(values) {
-  if (values.length < 2) return 0;
-  const mean = values.reduce((a, b) => a + b, 0) / values.length;
-  const squaredDiffs = values.map((v) => Math.pow(v - mean, 2));
-  const variance = squaredDiffs.reduce((a, b) => a + b, 0) / values.length;
-  const stdDev = Math.sqrt(variance);
-  const cv = mean !== 0 ? stdDev / Math.abs(mean) : 0;
-  return Math.min(1, cv);
-}
-var ReportModeContext = React2.createContext(null);
-function ReportModeProvider({
-  mode = "executive",
-  children,
-  onModeChange
-}) {
-  const config = mode === "executive" ? EXECUTIVE_MODE : ANALYST_MODE;
-  const value = React2.useMemo(
-    () => ({
-      ...config,
-      setMode: onModeChange
-    }),
-    [config, onModeChange]
-  );
-  return /* @__PURE__ */ jsxRuntime.jsx(ReportModeContext.Provider, { value, children });
-}
-function useReportMode() {
-  const context = React2.useContext(ReportModeContext);
-  if (!context) {
-    return EXECUTIVE_MODE;
-  }
-  return context;
-}
-function useDataState(params) {
-  const {
-    sampleSize,
-    requiredSize = MINIMUM_SAMPLE_SIZES.overall,
-    completeness = 1,
-    recency = 1,
-    variance = 0,
-    aiInferred = false,
-    missingFields = [],
-    staleDays
-  } = params;
-  return React2.useMemo(() => {
-    const confidenceParams = {
-      sampleSize,
-      requiredSize,
-      completeness,
-      recency,
-      variance,
-      aiInference: aiInferred
-    };
-    const confidence = calculateConfidence(confidenceParams);
-    const confidenceLevel = getConfidenceLevel(confidence);
-    let state = "VALID";
-    if (missingFields.length > 0) {
-      state = "FIELD_MISSING";
-    } else if (sampleSize < requiredSize) {
-      state = "INSUFFICIENT_SAMPLE";
-    } else if (staleDays && staleDays > 30) {
-      state = "STALE_DATA";
-    } else if (aiInferred) {
-      state = "INFERRED_NOT_OBSERVED";
-    } else if (confidence < 50) {
-      state = "LOW_CONFIDENCE";
-    } else if (variance > 0.7) {
-      state = "DATA_SKEW_DETECTED";
-    } else if (recency < 0.3) {
-      state = "PARTIAL_TIME_WINDOW";
-    }
-    const details = {
-      sampleSize,
-      requiredSize,
-      confidence,
-      missingFields: missingFields.length > 0 ? missingFields : void 0,
-      staleDays
-    };
-    return {
-      state,
-      confidence,
-      confidenceLevel,
-      details,
-      isValid: state === "VALID"
-    };
-  }, [
-    sampleSize,
-    requiredSize,
-    completeness,
-    recency,
-    variance,
-    aiInferred,
-    missingFields,
-    staleDays
-  ]);
-}
-function useChartData({
-  data,
-  requiredFields,
-  minSampleSize = MINIMUM_SAMPLE_SIZES.overall
-}) {
-  return React2.useMemo(() => {
-    const missingFields = [];
-    if (data.length > 0) {
-      const firstRecord = data[0];
-      for (const field of requiredFields) {
-        if (!(field in firstRecord)) {
-          missingFields.push(field);
-        }
-      }
-    }
-    let completeness = 1;
-    if (data.length > 0 && requiredFields.length > 0) {
-      let filled = 0;
-      let total = 0;
-      for (const record of data) {
-        for (const field of requiredFields) {
-          total++;
-          const value = record[field];
-          if (value !== null && value !== void 0 && value !== "") {
-            filled++;
-          }
-        }
-      }
-      completeness = total > 0 ? filled / total : 0;
-    }
-    let state = "VALID";
-    let message;
-    if (missingFields.length > 0) {
-      state = "FIELD_MISSING";
-      message = `Missing fields: ${missingFields.join(", ")}`;
-    } else if (data.length === 0) {
-      state = "INSUFFICIENT_SAMPLE";
-      message = "No data available";
-    } else if (data.length < minSampleSize) {
-      state = "INSUFFICIENT_SAMPLE";
-      message = `Sample size ${data.length} is below minimum ${minSampleSize}`;
-    } else if (completeness < 0.7) {
-      state = "LOW_CONFIDENCE";
-      message = `Data completeness is ${Math.round(completeness * 100)}%`;
-    }
-    const confidence = calculateConfidence({
-      sampleSize: data.length,
-      requiredSize: minSampleSize,
-      completeness,
-      recency: 1,
-      // Assume fresh data if not specified
-      variance: 0,
-      aiInference: false
-    });
-    const isRenderable = state === "VALID" || state === "LOW_CONFIDENCE";
-    return {
-      data,
-      state,
-      confidence,
-      isRenderable,
-      message
-    };
-  }, [data, requiredFields, minSampleSize]);
-}
-
-// src/report-engine/chart-types.ts
-var CHART_REGISTRY = {
-  // ══════════════════════════════════════════════════════════════════════════
-  // TREND CHARTS (MVP)
-  // ══════════════════════════════════════════════════════════════════════════
-  line: {
-    id: "line",
-    name: "Line Chart",
-    description: "Shows trends over time with connected data points",
-    intent: "trend",
-    phase: "mvp",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 1,
-      minDataPoints: 3,
-      idealDataPoints: 7,
-      allowNegativeValues: true,
-      requireNonZeroTotal: false,
-      warningThresholds: { sparseData: 3 },
-      fallback: { type: "show_kpi", message: "Insufficient data for trend visualization" }
-    },
-    switchableTo: ["smooth_line", "area", "stacked_area"],
-    supportsStacking: false,
-    supportsMultipleSeries: true,
-    requiresTimeAxis: true
-  },
-  smooth_line: {
-    id: "smooth_line",
-    name: "Smooth Line Chart",
-    description: "Curved line chart for smoother trend visualization",
-    intent: "trend",
-    phase: "mvp",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 1,
-      minDataPoints: 3,
-      idealDataPoints: 7,
-      allowNegativeValues: true,
-      requireNonZeroTotal: false,
-      warningThresholds: { sparseData: 3 },
-      fallback: { type: "show_kpi", message: "Insufficient data for trend visualization" }
-    },
-    switchableTo: ["line", "area", "stacked_area"],
-    supportsStacking: false,
-    supportsMultipleSeries: true,
-    requiresTimeAxis: true
-  },
-  area: {
-    id: "area",
-    name: "Area Chart",
-    description: "Filled area under line, emphasizes volume over time",
-    intent: "trend",
-    phase: "mvp",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 1,
-      minDataPoints: 3,
-      idealDataPoints: 7,
-      allowNegativeValues: false,
-      requireNonZeroTotal: false,
-      warningThresholds: { sparseData: 3 },
-      fallback: { type: "show_kpi", message: "Insufficient data for area visualization" }
-    },
-    switchableTo: ["line", "smooth_line", "stacked_area", "area_100pct"],
-    supportsStacking: true,
-    supportsMultipleSeries: true,
-    requiresTimeAxis: true
-  },
-  stacked_area: {
-    id: "stacked_area",
-    name: "Stacked Area Chart",
-    description: "Multiple series stacked to show cumulative trends",
-    intent: "trend",
-    phase: "mvp",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 2,
-      minDataPoints: 3,
-      idealDataPoints: 7,
-      allowNegativeValues: false,
-      requireNonZeroTotal: true,
-      warningThresholds: { sparseData: 3 },
-      fallback: { type: "warn", message: "Stacked area requires non-negative values" }
-    },
-    switchableTo: ["line", "area", "area_100pct"],
-    supportsStacking: true,
-    supportsMultipleSeries: true,
-    requiresTimeAxis: true
-  },
-  area_100pct: {
-    id: "area_100pct",
-    name: "100% Stacked Area",
-    description: "Shows proportional contribution over time",
-    intent: "trend",
-    phase: "mvp",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 2,
-      minDataPoints: 3,
-      idealDataPoints: 7,
-      allowNegativeValues: false,
-      requireNonZeroTotal: true,
-      warningThresholds: { sparseData: 3 },
-      fallback: { type: "warn", message: "100% stacked requires positive totals" }
-    },
-    switchableTo: ["stacked_area", "area"],
-    supportsStacking: true,
-    supportsMultipleSeries: true,
-    requiresTimeAxis: true
-  },
-  // ══════════════════════════════════════════════════════════════════════════
-  // COMPARISON CHARTS (MVP)
-  // ══════════════════════════════════════════════════════════════════════════
-  bar: {
-    id: "bar",
-    name: "Horizontal Bar Chart",
-    description: "Horizontal bars for comparing categories",
-    intent: "comparison",
-    phase: "mvp",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 1,
-      minDataPoints: 2,
-      idealDataPoints: 5,
-      maxDataPoints: 15,
-      allowNegativeValues: true,
-      requireNonZeroTotal: false,
-      warningThresholds: { tooManyCategories: 12 },
-      fallback: { type: "aggregate", strategy: "top_n" }
-    },
-    switchableTo: ["column", "stacked_bar", "stacked_column"],
-    supportsStacking: true,
-    supportsMultipleSeries: true,
-    requiresTimeAxis: false
-  },
-  column: {
-    id: "column",
-    name: "Vertical Column Chart",
-    description: "Vertical bars for comparing categories",
-    intent: "comparison",
-    phase: "mvp",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 1,
-      minDataPoints: 2,
-      idealDataPoints: 5,
-      maxDataPoints: 12,
-      allowNegativeValues: true,
-      requireNonZeroTotal: false,
-      warningThresholds: { tooManyCategories: 10 },
-      fallback: { type: "aggregate", strategy: "top_n" }
-    },
-    switchableTo: ["bar", "stacked_column", "stacked_bar"],
-    supportsStacking: true,
-    supportsMultipleSeries: true,
-    requiresTimeAxis: false
-  },
-  stacked_bar: {
-    id: "stacked_bar",
-    name: "Stacked Horizontal Bar",
-    description: "Horizontal stacked bars showing composition per category",
-    intent: "comparison",
-    phase: "mvp",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 2,
-      minDataPoints: 2,
-      idealDataPoints: 5,
-      maxDataPoints: 10,
-      allowNegativeValues: false,
-      requireNonZeroTotal: true,
-      warningThresholds: { tooManyCategories: 8, imbalancedRatio: 0.9 },
-      fallback: { type: "aggregate", strategy: "other_bucket" }
-    },
-    switchableTo: ["bar", "stacked_column", "column_100pct"],
-    supportsStacking: true,
-    supportsMultipleSeries: true,
-    requiresTimeAxis: false
-  },
-  stacked_column: {
-    id: "stacked_column",
-    name: "Stacked Vertical Column",
-    description: "Vertical stacked columns showing composition per category",
-    intent: "comparison",
-    phase: "mvp",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 2,
-      minDataPoints: 2,
-      idealDataPoints: 5,
-      maxDataPoints: 10,
-      allowNegativeValues: false,
-      requireNonZeroTotal: true,
-      warningThresholds: { tooManyCategories: 8, imbalancedRatio: 0.9 },
-      fallback: { type: "aggregate", strategy: "other_bucket" }
-    },
-    switchableTo: ["column", "stacked_bar", "column_100pct"],
-    supportsStacking: true,
-    supportsMultipleSeries: true,
-    requiresTimeAxis: false
-  },
-  column_100pct: {
-    id: "column_100pct",
-    name: "100% Stacked Column",
-    description: "Shows proportional composition per category",
-    intent: "comparison",
-    phase: "mvp",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 2,
-      minDataPoints: 2,
-      idealDataPoints: 5,
-      maxDataPoints: 10,
-      allowNegativeValues: false,
-      requireNonZeroTotal: true,
-      warningThresholds: { tooManyCategories: 8 },
-      fallback: { type: "warn", message: "100% stacked requires positive totals" }
-    },
-    switchableTo: ["stacked_column", "stacked_bar"],
-    supportsStacking: true,
-    supportsMultipleSeries: true,
-    requiresTimeAxis: false
-  },
-  combo: {
-    id: "combo",
-    name: "Combo Chart",
-    description: "Combines bars with line overlay (Phase 2)",
-    intent: "comparison",
-    phase: "phase2",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 2,
-      minDataPoints: 3,
-      idealDataPoints: 6,
-      allowNegativeValues: true,
-      requireNonZeroTotal: false,
-      warningThresholds: { tooManyCategories: 10 },
-      fallback: { type: "warn", message: "Combo chart requires dual measures" }
-    },
-    switchableTo: ["column", "line"],
-    supportsStacking: false,
-    supportsMultipleSeries: true,
-    requiresTimeAxis: false
-  },
-  // ══════════════════════════════════════════════════════════════════════════
-  // COMPOSITION CHARTS (MVP)
-  // ══════════════════════════════════════════════════════════════════════════
-  pie: {
-    id: "pie",
-    name: "Pie Chart",
-    description: "Shows proportional composition of a whole",
-    intent: "composition",
-    phase: "mvp",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 1,
-      minDataPoints: 2,
-      idealDataPoints: 4,
-      maxDataPoints: 6,
-      allowNegativeValues: false,
-      requireNonZeroTotal: true,
-      warningThresholds: { tooManyCategories: 6, imbalancedRatio: 0.95 },
-      fallback: { type: "aggregate", strategy: "other_bucket" }
-    },
-    switchableTo: ["donut", "column_100pct"],
-    supportsStacking: false,
-    supportsMultipleSeries: false,
-    requiresTimeAxis: false,
-    maxSlices: 6
-  },
-  donut: {
-    id: "donut",
-    name: "Donut Chart",
-    description: "Pie chart with center cutout, can display total",
-    intent: "composition",
-    phase: "mvp",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 1,
-      minDataPoints: 2,
-      idealDataPoints: 4,
-      maxDataPoints: 6,
-      allowNegativeValues: false,
-      requireNonZeroTotal: true,
-      warningThresholds: { tooManyCategories: 6, imbalancedRatio: 0.95 },
-      fallback: { type: "aggregate", strategy: "other_bucket" }
-    },
-    switchableTo: ["pie", "column_100pct"],
-    supportsStacking: false,
-    supportsMultipleSeries: false,
-    requiresTimeAxis: false,
-    maxSlices: 6
-  },
-  treemap: {
-    id: "treemap",
-    name: "Treemap",
-    description: "Nested rectangles showing hierarchical composition (Phase 2)",
-    intent: "composition",
-    phase: "phase2",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 1,
-      minDataPoints: 3,
-      idealDataPoints: 10,
-      maxDataPoints: 50,
-      allowNegativeValues: false,
-      requireNonZeroTotal: true,
-      warningThresholds: { tooManyCategories: 30 },
-      fallback: { type: "aggregate", strategy: "top_n" }
-    },
-    switchableTo: ["pie", "donut"],
-    supportsStacking: false,
-    supportsMultipleSeries: false,
-    requiresTimeAxis: false
-  },
-  // ══════════════════════════════════════════════════════════════════════════
-  // DISTRIBUTION CHARTS (MVP)
-  // ══════════════════════════════════════════════════════════════════════════
-  histogram: {
-    id: "histogram",
-    name: "Histogram",
-    description: "Shows distribution of values across bins",
-    intent: "distribution",
-    phase: "mvp",
-    contract: {
-      requiredDimensions: 0,
-      requiredMeasures: 1,
-      minDataPoints: 10,
-      idealDataPoints: 50,
-      allowNegativeValues: true,
-      requireNonZeroTotal: false,
-      warningThresholds: { sparseData: 10 },
-      fallback: { type: "show_kpi", message: "Insufficient data for distribution" }
-    },
-    switchableTo: ["radar"],
-    supportsStacking: false,
-    supportsMultipleSeries: false,
-    requiresTimeAxis: false
-  },
-  radar: {
-    id: "radar",
-    name: "Radar Chart",
-    description: "Multi-dimensional comparison in radial layout (Phase 2)",
-    intent: "distribution",
-    phase: "phase2",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 3,
-      minDataPoints: 3,
-      idealDataPoints: 6,
-      maxDataPoints: 8,
-      allowNegativeValues: false,
-      requireNonZeroTotal: false,
-      warningThresholds: { tooManyCategories: 8 },
-      fallback: { type: "warn", message: "Radar works best with 3-8 dimensions" }
-    },
-    switchableTo: ["histogram"],
-    supportsStacking: false,
-    supportsMultipleSeries: true,
-    requiresTimeAxis: false
-  },
-  // ══════════════════════════════════════════════════════════════════════════
-  // RELATIONSHIP CHARTS
-  // ══════════════════════════════════════════════════════════════════════════
-  heatmap: {
-    id: "heatmap",
-    name: "Heatmap",
-    description: "Color-coded matrix showing intensity",
-    intent: "relationship",
-    phase: "mvp",
-    contract: {
-      requiredDimensions: 2,
-      requiredMeasures: 1,
-      minDataPoints: 9,
-      idealDataPoints: 25,
-      allowNegativeValues: true,
-      requireNonZeroTotal: false,
-      warningThresholds: { sparseData: 9 },
-      fallback: { type: "warn", message: "Heatmap requires grid data" }
-    },
-    switchableTo: ["scatter"],
-    supportsStacking: false,
-    supportsMultipleSeries: false,
-    requiresTimeAxis: false
-  },
-  scatter: {
-    id: "scatter",
-    name: "Scatter Plot",
-    description: "Shows correlation between two variables (Phase 2)",
-    intent: "relationship",
-    phase: "phase2",
-    contract: {
-      requiredDimensions: 0,
-      requiredMeasures: 2,
-      minDataPoints: 20,
-      idealDataPoints: 100,
-      allowNegativeValues: true,
-      requireNonZeroTotal: false,
-      warningThresholds: { sparseData: 20 },
-      fallback: { type: "show_kpi", message: "Scatter requires 20+ points" }
-    },
-    switchableTo: ["bubble", "heatmap"],
-    supportsStacking: false,
-    supportsMultipleSeries: true,
-    requiresTimeAxis: false
-  },
-  bubble: {
-    id: "bubble",
-    name: "Bubble Chart",
-    description: "Scatter with sized points for third dimension (Phase 2)",
-    intent: "relationship",
-    phase: "phase2",
-    contract: {
-      requiredDimensions: 0,
-      requiredMeasures: 3,
-      minDataPoints: 10,
-      idealDataPoints: 50,
-      allowNegativeValues: true,
-      requireNonZeroTotal: false,
-      warningThresholds: { sparseData: 10 },
-      fallback: { type: "show_kpi", message: "Bubble requires 3 measures" }
-    },
-    switchableTo: ["scatter"],
-    supportsStacking: false,
-    supportsMultipleSeries: true,
-    requiresTimeAxis: false
-  },
-  // ══════════════════════════════════════════════════════════════════════════
-  // GEOGRAPHIC CHARTS (Phase 2)
-  // ══════════════════════════════════════════════════════════════════════════
-  geo: {
-    id: "geo",
-    name: "Geographic Map",
-    description: "Map with regional data markers (Phase 2)",
-    intent: "geo",
-    phase: "phase2",
-    contract: {
-      requiredDimensions: 1,
-      // geo dimension (country/region)
-      requiredMeasures: 1,
-      minDataPoints: 1,
-      idealDataPoints: 10,
-      allowNegativeValues: true,
-      requireNonZeroTotal: false,
-      warningThresholds: {},
-      fallback: { type: "hide" }
-    },
-    switchableTo: ["choropleth"],
-    supportsStacking: false,
-    supportsMultipleSeries: false,
-    requiresTimeAxis: false
-  },
-  choropleth: {
-    id: "choropleth",
-    name: "Choropleth Map",
-    description: "Color-shaded regions by value (Phase 2)",
-    intent: "geo",
-    phase: "phase2",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 1,
-      minDataPoints: 3,
-      idealDataPoints: 20,
-      allowNegativeValues: false,
-      requireNonZeroTotal: false,
-      warningThresholds: {},
-      fallback: { type: "hide" }
-    },
-    switchableTo: ["geo"],
-    supportsStacking: false,
-    supportsMultipleSeries: false,
-    requiresTimeAxis: false
-  },
-  // ══════════════════════════════════════════════════════════════════════════
-  // SPECIAL CHARTS
-  // ══════════════════════════════════════════════════════════════════════════
-  funnel: {
-    id: "funnel",
-    name: "Funnel Chart",
-    description: "Shows conversion through sequential stages",
-    intent: "comparison",
-    phase: "mvp",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 1,
-      minDataPoints: 3,
-      idealDataPoints: 5,
-      maxDataPoints: 7,
-      allowNegativeValues: false,
-      requireNonZeroTotal: true,
-      warningThresholds: { tooManyCategories: 7 },
-      fallback: { type: "warn", message: "Funnel requires sequential stages" }
-    },
-    switchableTo: ["bar"],
-    supportsStacking: false,
-    supportsMultipleSeries: false,
-    requiresTimeAxis: false
-  },
-  waterfall: {
-    id: "waterfall",
-    name: "Waterfall Chart",
-    description: "Shows cumulative effect of sequential changes (Phase 2)",
-    intent: "comparison",
-    phase: "phase2",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 1,
-      minDataPoints: 3,
-      idealDataPoints: 6,
-      maxDataPoints: 12,
-      allowNegativeValues: true,
-      requireNonZeroTotal: false,
-      warningThresholds: { tooManyCategories: 10 },
-      fallback: { type: "warn", message: "Waterfall requires sequential data" }
-    },
-    switchableTo: ["bar", "column"],
-    supportsStacking: false,
-    supportsMultipleSeries: false,
-    requiresTimeAxis: false
-  },
-  timeline: {
-    id: "timeline",
-    name: "Timeline",
-    description: "Shows events along time axis (Phase 2)",
-    intent: "trend",
-    phase: "phase2",
-    contract: {
-      requiredDimensions: 1,
-      requiredMeasures: 0,
-      minDataPoints: 2,
-      idealDataPoints: 10,
-      allowNegativeValues: false,
-      requireNonZeroTotal: false,
-      warningThresholds: {},
-      fallback: { type: "hide" }
-    },
-    switchableTo: ["line"],
-    supportsStacking: false,
-    supportsMultipleSeries: false,
-    requiresTimeAxis: true
-  }
-};
-var INTENT_CHART_FAMILIES = {
-  trend: ["line", "smooth_line", "area", "stacked_area", "area_100pct"],
-  comparison: ["bar", "column", "stacked_bar", "stacked_column", "column_100pct", "funnel"],
-  composition: ["pie", "donut"],
-  distribution: ["histogram"],
-  relationship: ["heatmap"],
-  geo: []
-};
-function getAllowedSwitchTargets(currentType) {
-  const metadata = CHART_REGISTRY[currentType];
-  if (!metadata) return [];
-  return metadata.switchableTo.filter((type) => {
-    const targetMeta = CHART_REGISTRY[type];
-    return targetMeta && targetMeta.phase === "mvp";
-  });
-}
-function canSwitchChart(from, to) {
-  const fromMeta = CHART_REGISTRY[from];
-  const toMeta = CHART_REGISTRY[to];
-  if (!fromMeta || !toMeta) return false;
-  if (fromMeta.intent !== toMeta.intent) return false;
-  return fromMeta.switchableTo.includes(to);
-}
-function validateChartData(chartType, data, dimensions, measures) {
-  const metadata = CHART_REGISTRY[chartType];
-  if (!metadata) {
-    return {
-      isValid: false,
-      warnings: [],
-      errors: [`Unknown chart type: ${chartType}`]
-    };
-  }
-  const contract = metadata.contract;
-  const warnings = [];
-  const errors = [];
-  if (data.length < contract.minDataPoints) {
-    errors.push(`Requires at least ${contract.minDataPoints} data points, got ${data.length}`);
-  }
-  if (contract.maxDataPoints && data.length > contract.maxDataPoints) {
-    warnings.push(`Chart works best with \u2264${contract.maxDataPoints} items. Consider aggregating.`);
-  }
-  if (dimensions.length < contract.requiredDimensions) {
-    errors.push(`Requires ${contract.requiredDimensions} dimension(s), got ${dimensions.length}`);
-  }
-  if (measures.length < contract.requiredMeasures) {
-    errors.push(`Requires ${contract.requiredMeasures} measure(s), got ${measures.length}`);
-  }
-  if (!contract.allowNegativeValues && data.length > 0) {
-    const hasNegative = data.some((row) => {
-      if (typeof row !== "object" || row === null) return false;
-      return measures.some((m) => {
-        const val = row[m];
-        return typeof val === "number" && val < 0;
-      });
-    });
-    if (hasNegative) {
-      errors.push("This chart type does not support negative values");
-    }
-  }
-  if (contract.warningThresholds.tooManyCategories && data.length > contract.warningThresholds.tooManyCategories) {
-    warnings.push(`Too many categories (${data.length}). Consider grouping smaller values.`);
-  }
-  return {
-    isValid: errors.length === 0,
-    warnings,
-    errors,
-    fallbackAction: errors.length > 0 ? contract.fallback : void 0
-  };
-}
-function getMVPChartsForIntent(intent) {
-  return Object.values(CHART_REGISTRY).filter(
-    (meta) => meta.intent === intent && meta.phase === "mvp"
-  );
-}
-function getDefaultChartForIntent(intent) {
-  const defaults = {
-    trend: "line",
-    comparison: "column",
-    composition: "donut",
-    distribution: "histogram",
-    relationship: "heatmap",
-    geo: "geo"
-  };
-  return defaults[intent];
-}
-function suggestChartType(params) {
-  const {
-    hasTimeAxis,
-    dimensionCount,
-    measureCount,
-    dataPointCount,
-    hasNegativeValues,
-    isSequential
-  } = params;
-  if (hasTimeAxis && measureCount >= 1) {
-    if (measureCount > 1 && !hasNegativeValues) return "stacked_area";
-    return "line";
-  }
-  if (isSequential && !hasNegativeValues && dataPointCount <= 7) {
-    return "funnel";
-  }
-  if (measureCount === 1 && dataPointCount <= 6 && !hasNegativeValues) {
-    return "donut";
-  }
-  if (dimensionCount === 2 && measureCount === 1) {
-    return "heatmap";
-  }
-  return "column";
-}
-function validateReportStructure(children) {
-  const issues = [];
-  const childArray = React2__default.default.Children.toArray(children);
-  let hasThesis = false;
-  let thesisIndex = -1;
-  const getComponentName2 = (child) => {
-    if (!React2__default.default.isValidElement(child)) return void 0;
-    const type = child.type;
-    return type.displayName || type.name;
-  };
-  const isChart2 = (name) => {
-    return name && (name.endsWith("Chart") || name === "MBTIRadar" || name === "MBTITypeGrid" || name === "KeyMetric");
-  };
-  childArray.forEach((child, index) => {
-    const name = getComponentName2(child);
-    if (name === "ExecutiveThesis") {
-      if (hasThesis) {
-        issues.push({
-          ruleId: "R1",
-          severity: "error",
-          message: "Only one ExecutiveThesis is allowed per report.",
-          component: "ExecutiveThesis"
-        });
-      }
-      hasThesis = true;
-      thesisIndex = index;
-    }
-    if (isChart2(name)) {
-      issues.push({
-        ruleId: "R3",
-        severity: "error",
-        message: `Orphan chart detected: <${name} />. Charts must be placed inside an InsightBlock or EvidenceGroup.`,
-        component: name
-      });
-    }
-    if (name === "InsightBlock" && React2__default.default.isValidElement(child)) {
-      validateInsightBlock(child, issues);
-    }
-  });
-  if (!hasThesis) {
-    issues.push({
-      ruleId: "R1",
-      severity: "error",
-      message: "Report must contain an ExecutiveThesis."
-    });
-  } else if (thesisIndex > 2) {
-    issues.push({
-      ruleId: "R1",
-      severity: "warning",
-      message: "ExecutiveThesis should be the first major component in the report."
-    });
-  }
-  return {
-    isValid: issues.filter((i) => i.severity === "error").length === 0,
-    issues
-  };
-}
-function validateInsightBlock(node, issues) {
-  const children = node.props.children;
-  const childArray = React2__default.default.Children.toArray(children);
-  let chartsInBlock = 0;
-  const countCharts = (nodes) => {
-    nodes.forEach((n) => {
-      const name = getComponentName(n);
-      if (isChart(name)) {
-        chartsInBlock++;
-      }
-      if (name === "EvidenceGroup" && React2__default.default.isValidElement(n)) {
-        countCharts(React2__default.default.Children.toArray(n.props.children));
-      }
-    });
-  };
-  countCharts(childArray);
-  if (chartsInBlock > 3) {
-    issues.push({
-      ruleId: "R6",
-      severity: "warning",
-      message: `InsightBlock contains ${chartsInBlock} charts. Recommended maximum is 3 to prevent data dumping.`,
-      component: "InsightBlock"
-    });
-  }
-}
-var getComponentName = (child) => {
-  if (!React2__default.default.isValidElement(child)) return void 0;
-  const type = child.type;
-  return type.displayName || type.name;
-};
-var isChart = (name) => {
-  return name && (name.endsWith("Chart") || name === "MBTIRadar" || name === "MBTITypeGrid" || name === "KeyMetric");
-};
-var ReportShell = React2__default.default.forwardRef(
-  ({
-    title,
-    subtitle,
-    mode = "executive",
-    brand,
-    onModeChange,
-    children,
-    actions,
-    className,
-    ...props
-  }, ref) => {
-    return /* @__PURE__ */ jsxRuntime.jsx(ReportModeProvider, { mode, onModeChange, children: /* @__PURE__ */ jsxRuntime.jsxs(
-      "div",
-      {
-        ref,
-        className: clsx12__default.default("ds-report-shell", className),
-        "data-mode": mode,
-        "data-brand": brand,
-        ...props,
-        children: [
-          (title || subtitle || actions) && /* @__PURE__ */ jsxRuntime.jsxs("header", { className: "ds-report-shell__header", children: [
-            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ds-report-shell__header-content", children: [
-              title && /* @__PURE__ */ jsxRuntime.jsx("h1", { className: "ds-report-shell__title", children: title }),
-              subtitle && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ds-report-shell__subtitle", children: subtitle })
-            ] }),
-            actions && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ds-report-shell__actions", children: actions })
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsx("main", { className: "ds-report-shell__content", children })
-        ]
-      }
-    ) });
-  }
-);
-ReportShell.displayName = "ReportShell";
-var ExecutiveThesis = React2__default.default.forwardRef(
-  ({ thesis, context, metric, aiGenerated, className, ...props }, ref) => {
-    const { features } = useReportMode();
-    return /* @__PURE__ */ jsxRuntime.jsxs(
-      "section",
-      {
-        ref,
-        className: clsx12__default.default("ds-executive-thesis", className),
-        "aria-labelledby": "executive-thesis-title",
-        ...props,
-        children: [
-          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ds-executive-thesis__content", children: [
-            /* @__PURE__ */ jsxRuntime.jsxs("h2", { id: "executive-thesis-title", className: "ds-executive-thesis__title", children: [
-              "Key Finding",
-              aiGenerated && features.showConfidenceScores && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-executive-thesis__ai-badge", children: "AI Generated" })
-            ] }),
-            /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ds-executive-thesis__thesis", children: thesis }),
-            context && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ds-executive-thesis__context", children: context })
-          ] }),
-          metric && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ds-executive-thesis__metric", children: [
-            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-executive-thesis__metric-label", children: metric.label }),
-            /* @__PURE__ */ jsxRuntime.jsxs(
-              "span",
-              {
-                className: clsx12__default.default(
-                  "ds-executive-thesis__metric-value",
-                  metric.trend && `ds-executive-thesis__metric-value--${metric.trend}`
-                ),
-                children: [
-                  metric.trend === "up" && "\u2191 ",
-                  metric.trend === "down" && "\u2193 ",
-                  metric.value
-                ]
-              }
-            )
-          ] })
-        ]
-      }
-    );
-  }
-);
-ExecutiveThesis.displayName = "ExecutiveThesis";
-var InsightBlock = React2__default.default.forwardRef(
-  ({ type, headline, description, confidence, methodology, children, className, ...props }, ref) => {
-    const { features } = useReportMode();
-    const contract = INSIGHT_TYPE_CONTRACTS[type];
-    const getConfidenceClass = () => {
-      if (confidence === void 0) return "";
-      if (confidence >= 90) return "ds-insight-block--confidence-high";
-      if (confidence >= 70) return "ds-insight-block--confidence-moderate";
-      if (confidence >= 50) return "ds-insight-block--confidence-low";
-      return "ds-insight-block--confidence-insufficient";
-    };
-    return /* @__PURE__ */ jsxRuntime.jsxs(
-      "section",
-      {
-        ref,
-        className: clsx12__default.default("ds-insight-block", getConfidenceClass(), className),
-        "data-insight-type": type,
-        "aria-labelledby": `insight-${type}-title`,
-        ...props,
-        children: [
-          /* @__PURE__ */ jsxRuntime.jsxs("header", { className: "ds-insight-block__header", children: [
-            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ds-insight-block__meta", children: [
-              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-insight-block__type", children: type.replace(/-/g, " ") }),
-              features.showConfidenceScores && confidence !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ds-insight-block__confidence", children: [
-                confidence,
-                "% confidence"
-              ] })
-            ] }),
-            /* @__PURE__ */ jsxRuntime.jsx("h3", { id: `insight-${type}-title`, className: "ds-insight-block__headline", children: headline }),
-            description && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ds-insight-block__description", children: description })
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ds-insight-block__evidence", children }),
-          features.showMethodology && methodology && /* @__PURE__ */ jsxRuntime.jsxs("footer", { className: "ds-insight-block__methodology", children: [
-            /* @__PURE__ */ jsxRuntime.jsx("h4", { className: "ds-insight-block__methodology-title", children: "Methodology" }),
-            /* @__PURE__ */ jsxRuntime.jsx("p", { className: "ds-insight-block__methodology-text", children: methodology }),
-            contract && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "ds-insight-block__methodology-contract", children: [
-              "Min sample: ",
-              contract.minSampleSize,
-              " | Allowed charts:",
-              " ",
-              contract.allowedCharts.join(", ")
-            ] })
-          ] })
-        ]
-      }
-    );
-  }
-);
-InsightBlock.displayName = "InsightBlock";
-var EvidenceGroup = React2__default.default.forwardRef(
-  ({ title, layout = "row", columns = 2, children, className, ...props }, ref) => {
-    const childCount = React2__default.default.Children.count(children);
-    if (childCount > 3) {
-      console.warn(
-        `EvidenceGroup: Maximum 3 charts allowed per insight block (received ${childCount}). This violates composition rule R6.`
-      );
-    }
-    return /* @__PURE__ */ jsxRuntime.jsxs(
-      "div",
-      {
-        ref,
-        className: clsx12__default.default(
-          "ds-evidence-group",
-          `ds-evidence-group--${layout}`,
-          layout === "grid" && `ds-evidence-group--cols-${columns}`,
-          className
-        ),
-        role: "group",
-        "aria-label": title || "Evidence charts",
-        ...props,
-        children: [
-          title && /* @__PURE__ */ jsxRuntime.jsx("h4", { className: "ds-evidence-group__title", children: title }),
-          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ds-evidence-group__content", children })
-        ]
-      }
-    );
-  }
-);
-EvidenceGroup.displayName = "EvidenceGroup";
-var ConfidenceIndicator = React2__default.default.forwardRef(
-  ({ score, showScore = true, showLabel = true, size = "md", className, ...props }, ref) => {
-    const threshold = getConfidenceThreshold(score);
-    const normalizedScore = Math.max(0, Math.min(100, score));
-    return /* @__PURE__ */ jsxRuntime.jsxs(
-      "div",
-      {
-        ref,
-        className: clsx12__default.default(
-          "ds-confidence-indicator",
-          `ds-confidence-indicator--${size}`,
-          `ds-confidence-indicator--${threshold.level}`,
-          className
-        ),
-        role: "meter",
-        "aria-valuenow": normalizedScore,
-        "aria-valuemin": 0,
-        "aria-valuemax": 100,
-        "aria-label": `Confidence: ${threshold.label} (${normalizedScore}%)`,
-        ...props,
-        children: [
-          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ds-confidence-indicator__bar", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ds-confidence-indicator__fill", style: { width: `${normalizedScore}%` } }) }),
-          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ds-confidence-indicator__text", children: [
-            showScore && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ds-confidence-indicator__score", children: [
-              normalizedScore,
-              "%"
-            ] }),
-            showLabel && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-confidence-indicator__label", children: threshold.label })
-          ] })
-        ]
-      }
-    );
-  }
-);
-ConfidenceIndicator.displayName = "ConfidenceIndicator";
-var DataCoverageBadge = React2__default.default.forwardRef(
-  ({ sampleSize, requiredSize, dateRange, showDateRange = true, size = "md", className, ...props }, ref) => {
-    const isSufficient = !requiredSize || sampleSize >= requiredSize;
-    const percentage = requiredSize ? Math.min(100, Math.round(sampleSize / requiredSize * 100)) : 100;
-    return /* @__PURE__ */ jsxRuntime.jsxs(
-      "div",
-      {
-        ref,
-        className: clsx12__default.default(
-          "ds-data-coverage-badge",
-          `ds-data-coverage-badge--${size}`,
-          !isSufficient && "ds-data-coverage-badge--insufficient",
-          className
-        ),
-        ...props,
-        children: [
-          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ds-data-coverage-badge__sample", children: [
-            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-data-coverage-badge__icon", children: /* @__PURE__ */ jsxRuntime.jsxs(
-              "svg",
-              {
-                width: "14",
-                height: "14",
-                viewBox: "0 0 24 24",
-                fill: "none",
-                stroke: "currentColor",
-                strokeWidth: "2",
-                children: [
-                  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2" }),
-                  /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "9", cy: "7", r: "4" }),
-                  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M23 21v-2a4 4 0 0 0-3-3.87" }),
-                  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M16 3.13a4 4 0 0 1 0 7.75" })
-                ]
-              }
-            ) }),
-            /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ds-data-coverage-badge__count", children: [
-              "n=",
-              sampleSize.toLocaleString()
-            ] }),
-            requiredSize && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ds-data-coverage-badge__required", children: [
-              "(",
-              percentage,
-              "% of min ",
-              requiredSize,
-              ")"
-            ] })
-          ] }),
-          showDateRange && dateRange && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ds-data-coverage-badge__date", children: [
-            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-data-coverage-badge__icon", children: /* @__PURE__ */ jsxRuntime.jsxs(
-              "svg",
-              {
-                width: "14",
-                height: "14",
-                viewBox: "0 0 24 24",
-                fill: "none",
-                stroke: "currentColor",
-                strokeWidth: "2",
-                children: [
-                  /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "3", y: "4", width: "18", height: "18", rx: "2", ry: "2" }),
-                  /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "16", y1: "2", x2: "16", y2: "6" }),
-                  /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "8", y1: "2", x2: "8", y2: "6" }),
-                  /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "3", y1: "10", x2: "21", y2: "10" })
-                ]
-              }
-            ) }),
-            /* @__PURE__ */ jsxRuntime.jsxs("span", { children: [
-              dateRange.start,
-              " \u2013 ",
-              dateRange.end
-            ] })
-          ] })
-        ]
-      }
-    );
-  }
-);
-DataCoverageBadge.displayName = "DataCoverageBadge";
-var DataStateIndicator = React2__default.default.forwardRef(
-  ({ state, details, variant = "compact", onAction, className, ...props }, ref) => {
-    const config = ANALYTICAL_STATE_CONFIG[state];
-    if (state === "VALID" && variant === "compact") {
-      return null;
-    }
-    const renderIcon = () => {
-      switch (config.icon) {
-        case "check":
-          return /* @__PURE__ */ jsxRuntime.jsx(
-            "svg",
-            {
-              width: "16",
-              height: "16",
-              viewBox: "0 0 24 24",
-              fill: "none",
-              stroke: "currentColor",
-              strokeWidth: "2",
-              children: /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "20,6 9,17 4,12" })
-            }
-          );
-        case "alert-triangle":
-          return /* @__PURE__ */ jsxRuntime.jsxs(
-            "svg",
-            {
-              width: "16",
-              height: "16",
-              viewBox: "0 0 24 24",
-              fill: "none",
-              stroke: "currentColor",
-              strokeWidth: "2",
-              children: [
-                /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z" }),
-                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "9", x2: "12", y2: "13" }),
-                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "17", x2: "12.01", y2: "17" })
-              ]
-            }
-          );
-        case "alert-circle":
-          return /* @__PURE__ */ jsxRuntime.jsxs(
-            "svg",
-            {
-              width: "16",
-              height: "16",
-              viewBox: "0 0 24 24",
-              fill: "none",
-              stroke: "currentColor",
-              strokeWidth: "2",
-              children: [
-                /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "12", cy: "12", r: "10" }),
-                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "8", x2: "12", y2: "12" }),
-                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "16", x2: "12.01", y2: "16" })
-              ]
-            }
-          );
-        case "x-circle":
-          return /* @__PURE__ */ jsxRuntime.jsxs(
-            "svg",
-            {
-              width: "16",
-              height: "16",
-              viewBox: "0 0 24 24",
-              fill: "none",
-              stroke: "currentColor",
-              strokeWidth: "2",
-              children: [
-                /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "12", cy: "12", r: "10" }),
-                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "15", y1: "9", x2: "9", y2: "15" }),
-                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "9", y1: "9", x2: "15", y2: "15" })
-              ]
-            }
-          );
-        case "cpu":
-          return /* @__PURE__ */ jsxRuntime.jsxs(
-            "svg",
-            {
-              width: "16",
-              height: "16",
-              viewBox: "0 0 24 24",
-              fill: "none",
-              stroke: "currentColor",
-              strokeWidth: "2",
-              children: [
-                /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "4", y: "4", width: "16", height: "16", rx: "2", ry: "2" }),
-                /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "9", y: "9", width: "6", height: "6" }),
-                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "9", y1: "1", x2: "9", y2: "4" }),
-                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "15", y1: "1", x2: "15", y2: "4" }),
-                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "9", y1: "20", x2: "9", y2: "23" }),
-                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "15", y1: "20", x2: "15", y2: "23" }),
-                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "20", y1: "9", x2: "23", y2: "9" }),
-                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "20", y1: "14", x2: "23", y2: "14" }),
-                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "1", y1: "9", x2: "4", y2: "9" }),
-                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "1", y1: "14", x2: "4", y2: "14" })
-              ]
-            }
-          );
-        default:
-          return /* @__PURE__ */ jsxRuntime.jsxs(
-            "svg",
-            {
-              width: "16",
-              height: "16",
-              viewBox: "0 0 24 24",
-              fill: "none",
-              stroke: "currentColor",
-              strokeWidth: "2",
-              children: [
-                /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "12", cy: "12", r: "10" }),
-                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "16", x2: "12", y2: "12" }),
-                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "8", x2: "12.01", y2: "8" })
-              ]
-            }
-          );
-      }
-    };
-    return /* @__PURE__ */ jsxRuntime.jsxs(
-      "div",
-      {
-        ref,
-        className: clsx12__default.default(
-          "ds-data-state-indicator",
-          `ds-data-state-indicator--${variant}`,
-          `ds-data-state-indicator--${state.toLowerCase().replace(/_/g, "-")}`,
-          className
-        ),
-        role: "status",
-        "aria-live": "polite",
-        ...props,
-        children: [
-          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-data-state-indicator__icon", style: { color: config.color }, children: renderIcon() }),
-          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ds-data-state-indicator__content", children: [
-            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-data-state-indicator__label", children: config.label }),
-            variant === "full" && details && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ds-data-state-indicator__details", children: [
-              details.message,
-              details.sampleSize !== void 0 && details.requiredSize !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-                " ",
-                "(n=",
-                details.sampleSize,
-                "/",
-                details.requiredSize,
-                ")"
-              ] }),
-              details.confidence !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-                " \u2022 ",
-                details.confidence,
-                "% confidence"
-              ] }),
-              details.missingFields && details.missingFields.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-                " \u2022 Missing: ",
-                details.missingFields.join(", ")
-              ] })
-            ] })
-          ] }),
-          config.action && onAction && /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className: "ds-data-state-indicator__action", onClick: onAction, children: config.action })
-        ]
-      }
-    );
-  }
-);
-DataStateIndicator.displayName = "DataStateIndicator";
-var MethodologyNote = React2__default.default.forwardRef(
-  ({ children, sampleSize, sources, calculation, forceShow = false, className, labels, ...props }, ref) => {
-    const titleText = labels?.title ?? "Methodology";
-    const sampleSizeLabel = labels?.sampleSize ?? "Sample Size";
-    const dataSourcesLabel = labels?.dataSources ?? "Data Sources";
-    const calculationLabel = labels?.calculation ?? "Calculation";
-    const { features } = useReportMode();
-    const shouldShow = forceShow || features.showMethodology || sampleSize !== void 0 && sampleSize < 100;
-    if (!shouldShow) {
-      return null;
-    }
-    return /* @__PURE__ */ jsxRuntime.jsxs(
-      "aside",
-      {
-        ref,
-        className: clsx12__default.default("ds-methodology-note", className),
-        "aria-label": titleText,
-        ...props,
-        children: [
-          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ds-methodology-note__header", children: [
-            /* @__PURE__ */ jsxRuntime.jsxs(
-              "svg",
-              {
-                className: "ds-methodology-note__icon",
-                width: "16",
-                height: "16",
-                viewBox: "0 0 24 24",
-                fill: "none",
-                stroke: "currentColor",
-                strokeWidth: "2",
-                children: [
-                  /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "12", cy: "12", r: "10" }),
-                  /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "16", x2: "12", y2: "12" }),
-                  /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "8", x2: "12.01", y2: "8" })
-                ]
-              }
-            ),
-            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-methodology-note__title", children: titleText })
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ds-methodology-note__content", children }),
-          (sources || calculation || sampleSize !== void 0) && /* @__PURE__ */ jsxRuntime.jsxs("dl", { className: "ds-methodology-note__details", children: [
-            sampleSize !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-              /* @__PURE__ */ jsxRuntime.jsx("dt", { children: sampleSizeLabel }),
-              /* @__PURE__ */ jsxRuntime.jsxs("dd", { children: [
-                "n=",
-                sampleSize.toLocaleString()
-              ] })
-            ] }),
-            sources && sources.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-              /* @__PURE__ */ jsxRuntime.jsx("dt", { children: dataSourcesLabel }),
-              /* @__PURE__ */ jsxRuntime.jsx("dd", { children: sources.join(", ") })
-            ] }),
-            calculation && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-              /* @__PURE__ */ jsxRuntime.jsx("dt", { children: calculationLabel }),
-              /* @__PURE__ */ jsxRuntime.jsx("dd", { children: calculation })
-            ] })
-          ] })
-        ]
-      }
-    );
-  }
-);
-MethodologyNote.displayName = "MethodologyNote";
-var CaveatBlock = React2__default.default.forwardRef(
-  ({
-    title = "Important Caveat",
-    children,
-    severity = "warning",
-    confidence,
-    forceShow = false,
-    className,
-    ...props
-  }, ref) => {
-    const { features } = useReportMode();
-    const shouldShow = forceShow || features.showMethodology || confidence !== void 0 && confidence < 70;
-    if (!shouldShow) {
-      return null;
-    }
-    const renderIcon = () => {
-      if (severity === "critical") {
-        return /* @__PURE__ */ jsxRuntime.jsxs(
-          "svg",
-          {
-            width: "18",
-            height: "18",
-            viewBox: "0 0 24 24",
-            fill: "none",
-            stroke: "currentColor",
-            strokeWidth: "2",
-            children: [
-              /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "12", cy: "12", r: "10" }),
-              /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "15", y1: "9", x2: "9", y2: "15" }),
-              /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "9", y1: "9", x2: "15", y2: "15" })
-            ]
-          }
-        );
-      }
-      if (severity === "info") {
-        return /* @__PURE__ */ jsxRuntime.jsxs(
-          "svg",
-          {
-            width: "18",
-            height: "18",
-            viewBox: "0 0 24 24",
-            fill: "none",
-            stroke: "currentColor",
-            strokeWidth: "2",
-            children: [
-              /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "12", cy: "12", r: "10" }),
-              /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "16", x2: "12", y2: "12" }),
-              /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "8", x2: "12.01", y2: "8" })
-            ]
-          }
-        );
-      }
-      return /* @__PURE__ */ jsxRuntime.jsxs(
-        "svg",
-        {
-          width: "18",
-          height: "18",
-          viewBox: "0 0 24 24",
-          fill: "none",
-          stroke: "currentColor",
-          strokeWidth: "2",
-          children: [
-            /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z" }),
-            /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "9", x2: "12", y2: "13" }),
-            /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "17", x2: "12.01", y2: "17" })
-          ]
-        }
-      );
-    };
-    return /* @__PURE__ */ jsxRuntime.jsxs(
-      "aside",
-      {
-        ref,
-        className: clsx12__default.default("ds-caveat-block", `ds-caveat-block--${severity}`, className),
-        role: "note",
-        "aria-label": title,
-        ...props,
-        children: [
-          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ds-caveat-block__header", children: [
-            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-caveat-block__icon", children: renderIcon() }),
-            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-caveat-block__title", children: title }),
-            confidence !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ds-caveat-block__confidence", children: [
-              confidence,
-              "% confidence"
-            ] })
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ds-caveat-block__content", children })
-        ]
-      }
-    );
-  }
-);
-CaveatBlock.displayName = "CaveatBlock";
-var KeyMetric = React2__default.default.forwardRef(
-  ({
-    title,
-    value,
-    prefix,
-    suffix,
-    trend,
-    secondary,
-    sampleSize,
-    confidence,
-    onClick,
-    loading,
-    size = "md",
-    className,
-    ...props
-  }, ref) => {
-    const { features } = useReportMode();
-    const { isValid } = useDataState({
-      sampleSize: sampleSize ?? 100,
-      requiredSize: 30
-    });
-    const isClickable = onClick && !loading;
-    const formatValue = (val) => {
-      if (typeof val === "number") {
-        return val.toLocaleString();
-      }
-      return val;
-    };
-    const getTrendIcon = (direction) => {
-      switch (direction) {
-        case "up":
-          return "\u2191";
-        case "down":
-          return "\u2193";
-        default:
-          return "\u2192";
-      }
-    };
-    const Component = isClickable ? "button" : "div";
-    return /* @__PURE__ */ jsxRuntime.jsxs(
-      Component,
-      {
-        ref,
-        className: clsx12__default.default(
-          "ds-key-metric",
-          `ds-key-metric--${size}`,
-          loading && "ds-key-metric--loading",
-          isClickable && "ds-key-metric--clickable",
-          !isValid && "ds-key-metric--invalid",
-          className
-        ),
-        onClick: isClickable ? onClick : void 0,
-        type: isClickable ? "button" : void 0,
-        ...props,
-        children: [
-          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ds-key-metric__header", children: [
-            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-key-metric__title", children: title }),
-            features.showConfidenceScores && confidence !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ds-key-metric__confidence", children: [
-              confidence,
-              "%"
-            ] })
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ds-key-metric__value-row", children: [
-            /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ds-key-metric__value", children: [
-              prefix && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-key-metric__prefix", children: prefix }),
-              loading ? "\u2014" : formatValue(value),
-              suffix && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-key-metric__suffix", children: suffix })
-            ] }),
-            trend && /* @__PURE__ */ jsxRuntime.jsxs(
-              "span",
-              {
-                className: clsx12__default.default("ds-key-metric__trend", `ds-key-metric__trend--${trend.direction}`),
-                children: [
-                  /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-key-metric__trend-icon", children: getTrendIcon(trend.direction) }),
-                  /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ds-key-metric__trend-value", children: [
-                    Math.abs(trend.value),
-                    "%"
-                  ] }),
-                  trend.label && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-key-metric__trend-label", children: trend.label })
-                ]
-              }
-            )
-          ] }),
-          secondary && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ds-key-metric__secondary", children: [
-            /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ds-key-metric__secondary-label", children: [
-              secondary.label,
-              ":"
-            ] }),
-            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-key-metric__secondary-value", children: formatValue(secondary.value) })
-          ] }),
-          features.showMethodology && sampleSize !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ds-key-metric__sample", children: [
-            "n=",
-            sampleSize.toLocaleString()
-          ] })
-        ]
-      }
-    );
-  }
-);
-KeyMetric.displayName = "KeyMetric";
-var TrendIndicator = React2__default.default.forwardRef(
-  ({
-    value,
-    direction: directionOverride,
-    positiveIsGood = true,
-    showIcon = true,
-    showPercent = true,
-    size = "md",
-    className,
-    ...props
-  }, ref) => {
-    const direction = directionOverride ?? (value > 0 ? "up" : value < 0 ? "down" : "neutral");
-    const isGood = positiveIsGood ? direction === "up" : direction === "down";
-    const isBad = positiveIsGood ? direction === "down" : direction === "up";
-    const getIcon = () => {
-      switch (direction) {
-        case "up":
-          return /* @__PURE__ */ jsxRuntime.jsx(
-            "svg",
-            {
-              width: "12",
-              height: "12",
-              viewBox: "0 0 24 24",
-              fill: "none",
-              stroke: "currentColor",
-              strokeWidth: "3",
-              children: /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "18,15 12,9 6,15" })
-            }
-          );
-        case "down":
-          return /* @__PURE__ */ jsxRuntime.jsx(
-            "svg",
-            {
-              width: "12",
-              height: "12",
-              viewBox: "0 0 24 24",
-              fill: "none",
-              stroke: "currentColor",
-              strokeWidth: "3",
-              children: /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "6,9 12,15 18,9" })
-            }
-          );
-        default:
-          return /* @__PURE__ */ jsxRuntime.jsx(
-            "svg",
-            {
-              width: "12",
-              height: "12",
-              viewBox: "0 0 24 24",
-              fill: "none",
-              stroke: "currentColor",
-              strokeWidth: "3",
-              children: /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "5", y1: "12", x2: "19", y2: "12" })
-            }
-          );
-      }
-    };
-    return /* @__PURE__ */ jsxRuntime.jsxs(
-      "span",
-      {
-        ref,
-        className: clsx12__default.default(
-          "ds-trend-indicator",
-          `ds-trend-indicator--${size}`,
-          `ds-trend-indicator--${direction}`,
-          isGood && "ds-trend-indicator--good",
-          isBad && "ds-trend-indicator--bad",
-          className
-        ),
-        "aria-label": `${direction === "up" ? "Increased" : direction === "down" ? "Decreased" : "No change"} by ${Math.abs(value)}%`,
-        ...props,
-        children: [
-          showIcon && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-trend-indicator__icon", children: getIcon() }),
-          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ds-trend-indicator__value", children: [
-            value > 0 && "+",
-            value.toFixed(1),
-            showPercent && "%"
-          ] })
-        ]
-      }
-    );
-  }
-);
-TrendIndicator.displayName = "TrendIndicator";
-function Select({
-  value,
-  defaultValue,
-  onValueChange,
-  disabled,
-  required,
-  name,
-  items,
-  children
-}) {
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    select.Select.Root,
-    {
-      value,
-      defaultValue,
-      onValueChange: onValueChange ? (val) => onValueChange(val) : void 0,
-      disabled,
-      required,
-      name,
-      items,
-      children
-    }
-  );
-}
-Select.displayName = "Select";
-var SelectTrigger = React2__default.default.forwardRef(
-  ({ className, placeholder = "Select...", size = "md", ...props }, ref) => {
-    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "ds-select__trigger-wrapper", children: /* @__PURE__ */ jsxRuntime.jsxs(
-      select.Select.Trigger,
-      {
-        ref,
-        className: clsx12__default.default("ds-select__trigger", `ds-select__trigger--${size}`, className),
-        "aria-label": props["aria-label"] || (typeof placeholder === "string" ? placeholder : "Select"),
-        ...props,
-        children: [
-          /* @__PURE__ */ jsxRuntime.jsx(select.Select.Value, { className: "ds-select__value", placeholder }),
-          /* @__PURE__ */ jsxRuntime.jsx(select.Select.Icon, { className: "ds-select__icon", "aria-hidden": true, children: /* @__PURE__ */ jsxRuntime.jsx(ChevronDownIcon, {}) })
-        ]
-      }
-    ) });
-  }
-);
-SelectTrigger.displayName = "SelectTrigger";
-var SelectContent = React2__default.default.forwardRef(
-  ({ className, side = "bottom", sideOffset = 4, align = "start", children, ...props }, ref) => {
-    return /* @__PURE__ */ jsxRuntime.jsx(select.Select.Portal, { children: /* @__PURE__ */ jsxRuntime.jsx(
-      select.Select.Positioner,
-      {
-        side,
-        sideOffset,
-        align,
-        alignItemWithTrigger: false,
-        children: /* @__PURE__ */ jsxRuntime.jsx(select.Select.Popup, { ref, className: clsx12__default.default("ds-select__content", className), ...props, children: /* @__PURE__ */ jsxRuntime.jsx(select.Select.List, { className: "ds-select__list", children }) })
-      }
-    ) });
-  }
-);
-SelectContent.displayName = "SelectContent";
-var SelectItem = React2__default.default.forwardRef(
-  ({ className, value, children, disabled, ...props }, ref) => {
-    return /* @__PURE__ */ jsxRuntime.jsxs(
-      select.Select.Item,
-      {
-        ref,
-        value,
-        disabled,
-        className: clsx12__default.default("ds-select__item", className),
-        ...props,
-        children: [
-          /* @__PURE__ */ jsxRuntime.jsx(select.Select.ItemIndicator, { className: "ds-select__item-indicator", children: /* @__PURE__ */ jsxRuntime.jsx(CheckIcon, {}) }),
-          /* @__PURE__ */ jsxRuntime.jsx(select.Select.ItemText, { children })
-        ]
-      }
-    );
-  }
-);
-SelectItem.displayName = "SelectItem";
-var SelectGroup = React2__default.default.forwardRef(
-  ({ className, label, children, ...props }, ref) => {
-    return /* @__PURE__ */ jsxRuntime.jsxs(select.Select.Group, { ref, className: clsx12__default.default("ds-select__group", className), ...props, children: [
-      label && /* @__PURE__ */ jsxRuntime.jsx(select.Select.GroupLabel, { className: "ds-select__group-label", children: label }),
-      children
-    ] });
-  }
-);
-SelectGroup.displayName = "SelectGroup";
-var SelectSeparator = React2__default.default.forwardRef(({ className, ...props }, ref) => {
-  return /* @__PURE__ */ jsxRuntime.jsx("div", { ref, className: clsx12__default.default("ds-select__separator", className), ...props });
+Object.defineProperty(exports, "CaveatBlock", {
+  enumerable: true,
+  get: function () { return chunk4GM5BGBN_cjs.CaveatBlock; }
 });
-SelectSeparator.displayName = "SelectSeparator";
-function ChevronDownIcon() {
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    "svg",
-    {
-      xmlns: "http://www.w3.org/2000/svg",
-      width: "16",
-      height: "16",
-      viewBox: "0 0 24 24",
-      fill: "none",
-      stroke: "currentColor",
-      strokeWidth: "2",
-      strokeLinecap: "round",
-      strokeLinejoin: "round",
-      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "m6 9 6 6 6-6" })
-    }
-  );
-}
-function CheckIcon() {
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    "svg",
-    {
-      xmlns: "http://www.w3.org/2000/svg",
-      width: "14",
-      height: "14",
-      viewBox: "0 0 24 24",
-      fill: "none",
-      stroke: "currentColor",
-      strokeWidth: "2",
-      strokeLinecap: "round",
-      strokeLinejoin: "round",
-      children: /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "20 6 9 17 4 12" })
-    }
-  );
-}
-var DropdownMenu = menu.Menu.Root;
-var DropdownMenuTrigger = React2__default.default.forwardRef(({ className, ...props }, ref) => {
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    menu.Menu.Trigger,
-    {
-      ref,
-      className: clsx12__default.default("ds-dropdown-menu__trigger", className),
-      ...props
-    }
-  );
+Object.defineProperty(exports, "EvidenceGroup", {
+  enumerable: true,
+  get: function () { return chunk4GM5BGBN_cjs.EvidenceGroup; }
 });
-DropdownMenuTrigger.displayName = "DropdownMenuTrigger";
-var DropdownMenuContent = React2__default.default.forwardRef(
-  ({ className, side = "bottom", align = "start", sideOffset = 4, alignOffset = 0, ...props }, ref) => {
-    return /* @__PURE__ */ jsxRuntime.jsx(menu.Menu.Portal, { children: /* @__PURE__ */ jsxRuntime.jsx(
-      menu.Menu.Positioner,
-      {
-        side,
-        align,
-        sideOffset,
-        alignOffset,
-        children: /* @__PURE__ */ jsxRuntime.jsx(
-          menu.Menu.Popup,
-          {
-            ref,
-            className: clsx12__default.default("ds-dropdown-menu__content", className),
-            ...props
-          }
-        )
-      }
-    ) });
-  }
-);
-DropdownMenuContent.displayName = "DropdownMenuContent";
-var DropdownMenuItem = React2__default.default.forwardRef(
-  ({ className, ...props }, ref) => {
-    return /* @__PURE__ */ jsxRuntime.jsx(menu.Menu.Item, { ref, className: clsx12__default.default("ds-dropdown-menu__item", className), ...props });
-  }
-);
-DropdownMenuItem.displayName = "DropdownMenuItem";
-var DropdownMenuSeparator = React2__default.default.forwardRef(({ className, ...props }, ref) => {
-  return /* @__PURE__ */ jsxRuntime.jsx("div", { ref, className: clsx12__default.default("ds-dropdown-menu__separator", className), ...props });
+Object.defineProperty(exports, "ExecutiveThesis", {
+  enumerable: true,
+  get: function () { return chunk4GM5BGBN_cjs.ExecutiveThesis; }
 });
-DropdownMenuSeparator.displayName = "DropdownMenuSeparator";
-var DropdownMenuLabel = React2__default.default.forwardRef(({ className, ...props }, ref) => {
-  return /* @__PURE__ */ jsxRuntime.jsx("div", { ref, className: clsx12__default.default("ds-dropdown-menu__label", className), ...props });
+Object.defineProperty(exports, "ExportMenu", {
+  enumerable: true,
+  get: function () { return chunk4GM5BGBN_cjs.ExportMenu; }
+});
+Object.defineProperty(exports, "InsightBlock", {
+  enumerable: true,
+  get: function () { return chunk4GM5BGBN_cjs.InsightBlock; }
+});
+Object.defineProperty(exports, "KeyMetric", {
+  enumerable: true,
+  get: function () { return chunk4GM5BGBN_cjs.KeyMetric; }
+});
+Object.defineProperty(exports, "MethodologyNote", {
+  enumerable: true,
+  get: function () { return chunk4GM5BGBN_cjs.MethodologyNote; }
+});
+Object.defineProperty(exports, "ReportShell", {
+  enumerable: true,
+  get: function () { return chunk4GM5BGBN_cjs.ReportShell; }
+});
+Object.defineProperty(exports, "TrendIndicator", {
+  enumerable: true,
+  get: function () { return chunk4GM5BGBN_cjs.TrendIndicator; }
+});
+Object.defineProperty(exports, "ANALYST_MODE", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.ANALYST_MODE; }
+});
+Object.defineProperty(exports, "ANALYTICAL_STATE_CONFIG", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.ANALYTICAL_STATE_CONFIG; }
+});
+Object.defineProperty(exports, "CHART_REGISTRY", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.CHART_REGISTRY; }
+});
+Object.defineProperty(exports, "CONFIDENCE_THRESHOLDS", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.CONFIDENCE_THRESHOLDS; }
+});
+Object.defineProperty(exports, "ConfidenceIndicator", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.ConfidenceIndicator; }
+});
+Object.defineProperty(exports, "DataCoverageBadge", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.DataCoverageBadge; }
+});
+Object.defineProperty(exports, "DataStateIndicator", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.DataStateIndicator; }
+});
+Object.defineProperty(exports, "EXECUTIVE_MODE", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.EXECUTIVE_MODE; }
+});
+Object.defineProperty(exports, "INSIGHT_TYPE_CONTRACTS", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.INSIGHT_TYPE_CONTRACTS; }
+});
+Object.defineProperty(exports, "INTENT_CHART_FAMILIES", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.INTENT_CHART_FAMILIES; }
+});
+Object.defineProperty(exports, "MINIMUM_SAMPLE_SIZES", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.MINIMUM_SAMPLE_SIZES; }
+});
+Object.defineProperty(exports, "ReportModeProvider", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.ReportModeProvider; }
+});
+Object.defineProperty(exports, "calculateCompleteness", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.calculateCompleteness; }
+});
+Object.defineProperty(exports, "calculateConfidence", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.calculateConfidence; }
+});
+Object.defineProperty(exports, "calculateNormalizedVariance", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.calculateNormalizedVariance; }
+});
+Object.defineProperty(exports, "calculateRecency", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.calculateRecency; }
+});
+Object.defineProperty(exports, "canSwitchChart", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.canSwitchChart; }
+});
+Object.defineProperty(exports, "getAllowedSwitchTargets", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.getAllowedSwitchTargets; }
+});
+Object.defineProperty(exports, "getConfidenceLevel", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.getConfidenceLevel; }
+});
+Object.defineProperty(exports, "getConfidenceThreshold", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.getConfidenceThreshold; }
+});
+Object.defineProperty(exports, "getDefaultChartForIntent", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.getDefaultChartForIntent; }
+});
+Object.defineProperty(exports, "getMVPChartsForIntent", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.getMVPChartsForIntent; }
+});
+Object.defineProperty(exports, "suggestChartType", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.suggestChartType; }
+});
+Object.defineProperty(exports, "useChartData", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.useChartData; }
+});
+Object.defineProperty(exports, "useDataState", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.useDataState; }
+});
+Object.defineProperty(exports, "useReportMode", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.useReportMode; }
+});
+Object.defineProperty(exports, "validateChartData", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.validateChartData; }
+});
+Object.defineProperty(exports, "validateReportStructure", {
+  enumerable: true,
+  get: function () { return chunkQ2MFGYTE_cjs.validateReportStructure; }
+});
+Object.defineProperty(exports, "Select", {
+  enumerable: true,
+  get: function () { return chunk3TGSIILM_cjs.Select; }
+});
+Object.defineProperty(exports, "SelectContent", {
+  enumerable: true,
+  get: function () { return chunk3TGSIILM_cjs.SelectContent; }
+});
+Object.defineProperty(exports, "SelectGroup", {
+  enumerable: true,
+  get: function () { return chunk3TGSIILM_cjs.SelectGroup; }
+});
+Object.defineProperty(exports, "SelectItem", {
+  enumerable: true,
+  get: function () { return chunk3TGSIILM_cjs.SelectItem; }
+});
+Object.defineProperty(exports, "SelectSeparator", {
+  enumerable: true,
+  get: function () { return chunk3TGSIILM_cjs.SelectSeparator; }
+});
+Object.defineProperty(exports, "SelectTrigger", {
+  enumerable: true,
+  get: function () { return chunk3TGSIILM_cjs.SelectTrigger; }
 });
-DropdownMenuLabel.displayName = "DropdownMenuLabel";
-var DEFAULT_OPTIONS = [
-  { format: "pdf", label: "PDF Document", description: "Best for sharing reports" },
-  { format: "pptx", label: "PowerPoint", description: "Editable presentation" },
-  { format: "xlsx", label: "Excel Spreadsheet", description: "Data with charts" },
-  { format: "csv", label: "CSV Data", description: "Raw data only" },
-  { format: "png", label: "PNG Image", description: "Chart screenshot" },
-  { format: "json", label: "JSON", description: "Developer format" }
-];
-var FORMAT_ICONS = {
-  pdf: /* @__PURE__ */ jsxRuntime.jsx(PdfIcon, {}),
-  csv: /* @__PURE__ */ jsxRuntime.jsx(CsvIcon, {}),
-  xlsx: /* @__PURE__ */ jsxRuntime.jsx(ExcelIcon, {}),
-  pptx: /* @__PURE__ */ jsxRuntime.jsx(PptIcon, {}),
-  png: /* @__PURE__ */ jsxRuntime.jsx(ImageIcon, {}),
-  json: /* @__PURE__ */ jsxRuntime.jsx(JsonIcon, {})
-};
-function ExportMenu({
-  options = DEFAULT_OPTIONS,
-  onExport,
-  isExporting = false,
-  label = "Export",
-  size = "md",
-  variant = "secondary",
-  className,
-  disabled
-}) {
-  const documentOptions = options.filter((o) => ["pdf", "pptx"].includes(o.format));
-  const dataOptions = options.filter((o) => ["xlsx", "csv", "json"].includes(o.format));
-  const imageOptions = options.filter((o) => ["png"].includes(o.format));
-  return /* @__PURE__ */ jsxRuntime.jsxs(DropdownMenu, { children: [
-    /* @__PURE__ */ jsxRuntime.jsx(
-      DropdownMenuTrigger,
-      {
-        className: clsx12__default.default(
-          "ds-export-menu__trigger",
-          "ds-button",
-          `ds-button--${variant}`,
-          `ds-button--${size}`,
-          className
-        ),
-        disabled: disabled || isExporting,
-        children: isExporting ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-          /* @__PURE__ */ jsxRuntime.jsx(LoadingIcon, {}),
-          "Exporting..."
-        ] }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-          /* @__PURE__ */ jsxRuntime.jsx(ExportIcon, {}),
-          label
-        ] })
-      }
-    ),
-    /* @__PURE__ */ jsxRuntime.jsxs(DropdownMenuContent, { side: "bottom", align: "end", sideOffset: 4, children: [
-      documentOptions.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-        /* @__PURE__ */ jsxRuntime.jsx(DropdownMenuLabel, { children: "Documents" }),
-        documentOptions.map((option) => /* @__PURE__ */ jsxRuntime.jsxs(
-          DropdownMenuItem,
-          {
-            disabled: option.disabled,
-            onClick: () => onExport(option.format),
-            children: [
-              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-export-menu__item-icon", children: FORMAT_ICONS[option.format] }),
-              /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ds-export-menu__item-content", children: [
-                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-export-menu__item-label", children: option.label }),
-                option.description && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-export-menu__item-description", children: option.description })
-              ] })
-            ]
-          },
-          option.format
-        ))
-      ] }),
-      documentOptions.length > 0 && dataOptions.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(DropdownMenuSeparator, {}),
-      dataOptions.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-        /* @__PURE__ */ jsxRuntime.jsx(DropdownMenuLabel, { children: "Data" }),
-        dataOptions.map((option) => /* @__PURE__ */ jsxRuntime.jsxs(
-          DropdownMenuItem,
-          {
-            disabled: option.disabled,
-            onClick: () => onExport(option.format),
-            children: [
-              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-export-menu__item-icon", children: FORMAT_ICONS[option.format] }),
-              /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ds-export-menu__item-content", children: [
-                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-export-menu__item-label", children: option.label }),
-                option.description && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-export-menu__item-description", children: option.description })
-              ] })
-            ]
-          },
-          option.format
-        ))
-      ] }),
-      imageOptions.length > 0 && (dataOptions.length > 0 || documentOptions.length > 0) && /* @__PURE__ */ jsxRuntime.jsx(DropdownMenuSeparator, {}),
-      imageOptions.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-        /* @__PURE__ */ jsxRuntime.jsx(DropdownMenuLabel, { children: "Image" }),
-        imageOptions.map((option) => /* @__PURE__ */ jsxRuntime.jsxs(
-          DropdownMenuItem,
-          {
-            disabled: option.disabled,
-            onClick: () => onExport(option.format),
-            children: [
-              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-export-menu__item-icon", children: FORMAT_ICONS[option.format] }),
-              /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "ds-export-menu__item-content", children: [
-                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-export-menu__item-label", children: option.label }),
-                option.description && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ds-export-menu__item-description", children: option.description })
-              ] })
-            ]
-          },
-          option.format
-        ))
-      ] })
-    ] })
-  ] });
-}
-ExportMenu.displayName = "ExportMenu";
-function ExportIcon() {
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    "svg",
-    {
-      xmlns: "http://www.w3.org/2000/svg",
-      width: "16",
-      height: "16",
-      viewBox: "0 0 24 24",
-      fill: "none",
-      stroke: "currentColor",
-      strokeWidth: "2",
-      strokeLinecap: "round",
-      strokeLinejoin: "round",
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" }),
-        /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "17 8 12 3 7 8" }),
-        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "3", x2: "12", y2: "15" })
-      ]
-    }
-  );
-}
-function LoadingIcon() {
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    "svg",
-    {
-      className: "ds-export-menu__loading-icon",
-      xmlns: "http://www.w3.org/2000/svg",
-      width: "16",
-      height: "16",
-      viewBox: "0 0 24 24",
-      fill: "none",
-      stroke: "currentColor",
-      strokeWidth: "2",
-      strokeLinecap: "round",
-      strokeLinejoin: "round",
-      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M21 12a9 9 0 1 1-6.219-8.56" })
-    }
-  );
-}
-function PdfIcon() {
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    "svg",
-    {
-      xmlns: "http://www.w3.org/2000/svg",
-      width: "16",
-      height: "16",
-      viewBox: "0 0 24 24",
-      fill: "none",
-      stroke: "currentColor",
-      strokeWidth: "2",
-      strokeLinecap: "round",
-      strokeLinejoin: "round",
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z" }),
-        /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "14 2 14 8 20 8" }),
-        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "16", y1: "13", x2: "8", y2: "13" }),
-        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "16", y1: "17", x2: "8", y2: "17" }),
-        /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "10 9 9 9 8 9" })
-      ]
-    }
-  );
-}
-function CsvIcon() {
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    "svg",
-    {
-      xmlns: "http://www.w3.org/2000/svg",
-      width: "16",
-      height: "16",
-      viewBox: "0 0 24 24",
-      fill: "none",
-      stroke: "currentColor",
-      strokeWidth: "2",
-      strokeLinecap: "round",
-      strokeLinejoin: "round",
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z" }),
-        /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "14 2 14 8 20 8" }),
-        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "8", y1: "13", x2: "16", y2: "13" }),
-        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "8", y1: "17", x2: "16", y2: "17" })
-      ]
-    }
-  );
-}
-function ExcelIcon() {
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    "svg",
-    {
-      xmlns: "http://www.w3.org/2000/svg",
-      width: "16",
-      height: "16",
-      viewBox: "0 0 24 24",
-      fill: "none",
-      stroke: "currentColor",
-      strokeWidth: "2",
-      strokeLinecap: "round",
-      strokeLinejoin: "round",
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "3", y: "3", width: "18", height: "18", rx: "2" }),
-        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M3 9h18" }),
-        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M3 15h18" }),
-        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M9 3v18" }),
-        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M15 3v18" })
-      ]
-    }
-  );
-}
-function PptIcon() {
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    "svg",
-    {
-      xmlns: "http://www.w3.org/2000/svg",
-      width: "16",
-      height: "16",
-      viewBox: "0 0 24 24",
-      fill: "none",
-      stroke: "currentColor",
-      strokeWidth: "2",
-      strokeLinecap: "round",
-      strokeLinejoin: "round",
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "2", y: "3", width: "20", height: "14", rx: "2" }),
-        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "8", y1: "21", x2: "16", y2: "21" }),
-        /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "17", x2: "12", y2: "21" })
-      ]
-    }
-  );
-}
-function ImageIcon() {
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    "svg",
-    {
-      xmlns: "http://www.w3.org/2000/svg",
-      width: "16",
-      height: "16",
-      viewBox: "0 0 24 24",
-      fill: "none",
-      stroke: "currentColor",
-      strokeWidth: "2",
-      strokeLinecap: "round",
-      strokeLinejoin: "round",
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "3", y: "3", width: "18", height: "18", rx: "2" }),
-        /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "8.5", cy: "8.5", r: "1.5" }),
-        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "m21 15-5-5L5 21" })
-      ]
-    }
-  );
-}
-function JsonIcon() {
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    "svg",
-    {
-      xmlns: "http://www.w3.org/2000/svg",
-      width: "16",
-      height: "16",
-      viewBox: "0 0 24 24",
-      fill: "none",
-      stroke: "currentColor",
-      strokeWidth: "2",
-      strokeLinecap: "round",
-      strokeLinejoin: "round",
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M8 3H7a2 2 0 0 0-2 2v5a2 2 0 0 1-2 2 2 2 0 0 1 2 2v5a2 2 0 0 0 2 2h1" }),
-        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M16 21h1a2 2 0 0 0 2-2v-5a2 2 0 0 1 2-2 2 2 0 0 1-2-2V5a2 2 0 0 0-2-2h-1" })
-      ]
-    }
-  );
-}
-
-exports.ANALYST_MODE = ANALYST_MODE;
-exports.ANALYTICAL_STATE_CONFIG = ANALYTICAL_STATE_CONFIG;
-exports.CHART_REGISTRY = CHART_REGISTRY;
-exports.CONFIDENCE_THRESHOLDS = CONFIDENCE_THRESHOLDS;
-exports.CaveatBlock = CaveatBlock;
-exports.ConfidenceIndicator = ConfidenceIndicator;
-exports.DataCoverageBadge = DataCoverageBadge;
-exports.DataStateIndicator = DataStateIndicator;
-exports.EXECUTIVE_MODE = EXECUTIVE_MODE;
-exports.EvidenceGroup = EvidenceGroup;
-exports.ExecutiveThesis = ExecutiveThesis;
-exports.ExportMenu = ExportMenu;
-exports.INSIGHT_TYPE_CONTRACTS = INSIGHT_TYPE_CONTRACTS;
-exports.INTENT_CHART_FAMILIES = INTENT_CHART_FAMILIES;
-exports.InsightBlock = InsightBlock;
-exports.KeyMetric = KeyMetric;
-exports.MINIMUM_SAMPLE_SIZES = MINIMUM_SAMPLE_SIZES;
-exports.MethodologyNote = MethodologyNote;
-exports.ReportModeProvider = ReportModeProvider;
-exports.ReportShell = ReportShell;
-exports.Select = Select;
-exports.SelectContent = SelectContent;
-exports.SelectGroup = SelectGroup;
-exports.SelectItem = SelectItem;
-exports.SelectSeparator = SelectSeparator;
-exports.SelectTrigger = SelectTrigger;
-exports.TrendIndicator = TrendIndicator;
-exports.calculateCompleteness = calculateCompleteness;
-exports.calculateConfidence = calculateConfidence;
-exports.calculateNormalizedVariance = calculateNormalizedVariance;
-exports.calculateRecency = calculateRecency;
-exports.canSwitchChart = canSwitchChart;
-exports.getAllowedSwitchTargets = getAllowedSwitchTargets;
-exports.getConfidenceLevel = getConfidenceLevel;
-exports.getConfidenceThreshold = getConfidenceThreshold;
-exports.getDefaultChartForIntent = getDefaultChartForIntent;
-exports.getMVPChartsForIntent = getMVPChartsForIntent;
-exports.suggestChartType = suggestChartType;
-exports.useChartData = useChartData;
-exports.useDataState = useDataState;
-exports.useReportMode = useReportMode;
-exports.validateChartData = validateChartData;
-exports.validateReportStructure = validateReportStructure;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.cjs.map