fix: compute position stacking per-facet-panel instead of globally (#244)

Stacking `.over()` partitions now include facet columns, so cumulative
sums reset within each facet panel. Previously, bars in later panels
stacked on top of cumulative values from earlier panels.

Also applies to Fill and Center stacking modes.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: cpsievert

src/execute/position.rs

@@ -322,4 +322,80 @@ mod tests {
             assert!((-0.3..=0.3).contains(&v));
         }
     }
+
+    #[test]
+    fn test_stack_resets_per_facet_panel() {
+        // Stacking should compute independently within each facet panel.
+        // Without this, bars in the second facet panel stack on top of
+        // cumulative values from the first panel (see issue #244).
+        //
+        // Two facet panels (F1, F2) each with the same x="A" and two
+        // fill groups (X, Y). Stacking within each panel should start from 0.
+        let df = df! {
+            "__ggsql_aes_pos1__" => ["A", "A", "A", "A"],
+            "__ggsql_aes_pos2__" => [10.0, 20.0, 30.0, 40.0],
+            "__ggsql_aes_pos2end__" => [0.0, 0.0, 0.0, 0.0],
+            "__ggsql_aes_fill__" => ["X", "Y", "X", "Y"],
+            "__ggsql_aes_facet1__" => ["F1", "F1", "F2", "F2"],
+        }
+        .unwrap();
+
+        let mut layer = crate::plot::Layer::new(Geom::bar());
+        layer.mappings = {
+            let mut m = Mappings::new();
+            m.insert("pos1", AestheticValue::standard_column("__ggsql_aes_pos1__"));
+            m.insert("pos2", AestheticValue::standard_column("__ggsql_aes_pos2__"));
+            m.insert("pos2end", AestheticValue::standard_column("__ggsql_aes_pos2end__"));
+            m.insert("fill", AestheticValue::standard_column("__ggsql_aes_fill__"));
+            m.insert("facet1", AestheticValue::standard_column("__ggsql_aes_facet1__"));
+            m
+        };
+        layer.partition_by = vec![
+            "__ggsql_aes_fill__".to_string(),
+            "__ggsql_aes_facet1__".to_string(),
+        ];
+        layer.position = Position::stack();
+        layer.data_key = Some("__ggsql_layer_0__".to_string());
+
+        let mut spec = Plot::new();
+        spec.scales.push(make_discrete_scale("pos1"));
+        spec.scales.push(make_continuous_scale("pos2"));
+        let mut data_map = HashMap::new();
+        data_map.insert("__ggsql_layer_0__".to_string(), df);
+
+        let mut spec_with_layer = spec;
+        spec_with_layer.layers.push(layer);
+
+        apply_position_adjustments(&mut spec_with_layer, &mut data_map).unwrap();
+
+        let result_df = data_map.get("__ggsql_layer_0__").unwrap();
+
+        // Sort by facet then fill so we can assert in predictable order
+        let result_df = result_df
+            .clone()
+            .lazy()
+            .sort_by_exprs(
+                [col("__ggsql_aes_facet1__"), col("__ggsql_aes_fill__")],
+                SortMultipleOptions::default(),
+            )
+            .collect()
+            .unwrap();
+
+        let pos2 = result_df.column("__ggsql_aes_pos2__").unwrap().f64().unwrap();
+        let pos2end = result_df.column("__ggsql_aes_pos2end__").unwrap().f64().unwrap();
+
+        let pos2_vals: Vec<f64> = pos2.into_iter().flatten().collect();
+        let pos2end_vals: Vec<f64> = pos2end.into_iter().flatten().collect();
+
+        // Expected (sorted by facet, fill):
+        // F1/X: pos2end=0,  pos2=10  (first in panel, starts at 0)
+        // F1/Y: pos2end=10, pos2=30  (stacks on X)
+        // F2/X: pos2end=0,  pos2=30  (first in panel, should reset to 0)
+        // F2/Y: pos2end=30, pos2=70  (stacks on X)
+        assert_eq!(
+            pos2end_vals[2], 0.0,
+            "F2 panel first bar should start at 0, not carry over from F1. pos2end={:?}, pos2={:?}",
+            pos2end_vals, pos2_vals
+        );
+    }
 }

src/plot/layer/position/stack.rs

@@ -266,22 +266,36 @@ fn apply_stack(df: DataFrame, layer: &Layer, spec: &Plot, mode: StackMode) -> Re
     // 2. stack_end_col = lag(stack_col, 1, 0) - the bar bottom/start (previous stack top)
     // The cumsum naturally stacks across the grouping column values
 
+    // Build the partition columns for .over(): group column + facet columns.
+    // Facet columns must be included so stacking resets per facet panel,
+    // matching ggplot2 where position adjustments are computed per-panel.
+    let mut over_cols: Vec<Expr> = vec![col(&group_col)];
+    for partition_col in &layer.partition_by {
+        if naming::is_aesthetic_column(partition_col) {
+            if let Some(aes) = naming::extract_aesthetic_name(partition_col) {
+                if aes.starts_with("facet") {
+                    over_cols.push(col(partition_col));
+                }
+            }
+        }
+    }
+
     // Treat NA heights as 0 for stacking
     // Compute cumulative sums (shared by all modes)
     let lf = lf
         .with_column(col(&stack_col).fill_null(lit(0.0)).alias(&stack_col))
         .with_column(
             col(&stack_col)
                 .cum_sum(false)
-                .over([col(&group_col)])
+                .over(&over_cols)
                 .alias("__cumsum__"),
         )
         .with_column(
             col(&stack_col)
                 .cum_sum(false)
                 .shift(lit(1))
                 .fill_null(lit(0.0))
-                .over([col(&group_col)])
+                .over(&over_cols)
                 .alias("__cumsum_lag__"),
         );
 
@@ -293,15 +307,15 @@ fn apply_stack(df: DataFrame, layer: &Layer, spec: &Plot, mode: StackMode) -> Re
             vec!["__cumsum__", "__cumsum_lag__"],
         ),
         StackMode::Fill(target) => {
-            let total = col(&stack_col).sum().over([col(&group_col)]);
+            let total = col(&stack_col).sum().over(&over_cols);
             (
                 (col("__cumsum__") / total.clone() * lit(target)).alias(&stack_col),
                 (col("__cumsum_lag__") / total * lit(target)).alias(&stack_end_col),
                 vec!["__cumsum__", "__cumsum_lag__"],
             )
         }
         StackMode::Center => {
-            let half_total = col(&stack_col).sum().over([col(&group_col)]) / lit(2.0);
+            let half_total = col(&stack_col).sum().over(&over_cols) / lit(2.0);
             (
                 (col("__cumsum__") - half_total.clone()).alias(&stack_col),
                 (col("__cumsum_lag__") - half_total).alias(&stack_end_col),