@salesmind-ai/design-system 0.6.0 → 0.7.0

package/dist/report/index.cjs

@@ -1,182 +1,1173 @@
 'use strict';
 
-var chunk4GM5BGBN_cjs = require('../chunk-4GM5BGBN.cjs');
-var chunkQ2MFGYTE_cjs = require('../chunk-Q2MFGYTE.cjs');
-var chunk3TGSIILM_cjs = require('../chunk-3TGSIILM.cjs');
+var React2 = require('react');
+var jsxRuntime = require('react/jsx-runtime');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+var React2__default = /*#__PURE__*/_interopDefault(React2);
 
-Object.defineProperty(exports, "CaveatBlock", {
-  enumerable: true,
-  get: function () { return chunk4GM5BGBN_cjs.CaveatBlock; }
-});
-Object.defineProperty(exports, "EvidenceGroup", {
-  enumerable: true,
-  get: function () { return chunk4GM5BGBN_cjs.EvidenceGroup; }
-});
-Object.defineProperty(exports, "ExecutiveThesis", {
-  enumerable: true,
-  get: function () { return chunk4GM5BGBN_cjs.ExecutiveThesis; }
-});
-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; }
-});
+// 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");
+};
+
+exports.ANALYST_MODE = ANALYST_MODE;
+exports.ANALYTICAL_STATE_CONFIG = ANALYTICAL_STATE_CONFIG;
+exports.CHART_REGISTRY = CHART_REGISTRY;
+exports.CONFIDENCE_THRESHOLDS = CONFIDENCE_THRESHOLDS;
+exports.EXECUTIVE_MODE = EXECUTIVE_MODE;
+exports.INSIGHT_TYPE_CONTRACTS = INSIGHT_TYPE_CONTRACTS;
+exports.INTENT_CHART_FAMILIES = INTENT_CHART_FAMILIES;
+exports.MINIMUM_SAMPLE_SIZES = MINIMUM_SAMPLE_SIZES;
+exports.ReportModeProvider = ReportModeProvider;
+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