test(lower): composition of counter-derivatives with outer/nested funcs (#44)

Pin how the new counter-derivative intents compose with the rest of the
lowering — they are per-series/label-preserving, so they reuse the general
nesting path with no special-casing:

- outer cross-series stat over a derivative nests two levels and threads
  the outer group key + any scalar param (`avg by (dc)(predict_linear(...))`)
- `topk(k, deriv(...))` is generic Sort+Limit, not a heavy-hitter TopK
- as a binary-op operand and under `sum(rate(...) + changes(...))`
- counter-derivative over a sub-query stays cleanly rejected (a #42 follow-up)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: zz_y

crates/lower/tests/promql_conformance.rs

@@ -812,3 +812,77 @@ fn aggregation_over_counter_derivative_keeps_labels() {
     assert!(intents(&qe).iter().any(|i| matches!(i, AggIntent::Changes)));
     let _ = child;
 }
+
+#[test]
+fn outer_stat_over_counter_derivative_nests_two_levels() {
+    // A cross-series stat over a counter-derivative is a genuine two-level
+    // reduction: the derivative runs per series (inner), the stat aggregates
+    // across series (outer). They must not collapse into one node — and a
+    // grouped outer (`avg by (dc)`) must resolve its key against the labels the
+    // inner reduction preserved, threading any scalar param (predict horizon).
+    let qe = ok("avg by (dc) (predict_linear(m[3h], 3600))");
+    let QueryExpr::Aggregate { by, aggs, child, .. } = &qe else {
+        panic!("expected outer Aggregate, got {qe:?}");
+    };
+    assert!(!by.is_empty(), "outer `avg by (dc)` groups on a label");
+    assert!(matches!(aggs.as_slice(), [AggIntent::Avg { .. }]));
+    let QueryExpr::Aggregate { by: inner_by, aggs: inner_aggs, .. } = child.as_ref() else {
+        panic!("expected inner per-series Aggregate, got {child:?}");
+    };
+    assert!(inner_by.is_empty(), "inner derivative stays per-series");
+    assert_eq!(
+        inner_aggs.as_slice(),
+        std::slice::from_ref(&AggIntent::PredictLinear { seconds: 3600.0 })
+    );
+}
+
+#[test]
+fn topk_over_counter_derivative_is_generic_sort_limit() {
+    // `topk(k, deriv(...))` ranks the per-series derivative values — a generic
+    // `Sort + Limit`, NOT a heavy-hitter `TopK` (that's only `count_over_time`).
+    let qe = ok("topk(3, deriv(m[5m]))");
+    let QueryExpr::Limit { n, child, .. } = &qe else {
+        panic!("expected Limit, got {qe:?}");
+    };
+    assert_eq!(*n, 3);
+    assert!(matches!(child.as_ref(), QueryExpr::Sort { .. }));
+    assert!(intents(&qe).iter().any(|i| matches!(i, AggIntent::Deriv)));
+    assert!(
+        !intents(&qe).iter().any(|i| matches!(i, AggIntent::TopK { .. })),
+        "counter-derivative topk is generic ranking, not a heavy-hitter sketch"
+    );
+}
+
+#[test]
+fn counter_derivative_composes_in_binary_ops() {
+    // As a vector operand: `delta(a[5m]) / delta(b[5m])` is a BinaryOp of two
+    // per-series Delta reductions.
+    let ratio = ok("delta(a[5m]) / delta(b[5m])");
+    let QueryExpr::BinaryOp { op, lhs, rhs, .. } = &ratio else {
+        panic!("expected BinaryOp, got {ratio:?}");
+    };
+    assert_eq!(*op, BinaryOpKind::Arith(ArithOp::Div));
+    assert!(matches!(lhs.as_ref(), QueryExpr::Aggregate { aggs, .. } if aggs.as_slice() == [AggIntent::Delta]));
+    assert!(matches!(rhs.as_ref(), QueryExpr::Aggregate { aggs, .. } if aggs.as_slice() == [AggIntent::Delta]));
+
+    // Under an aggregate over a binary op mixing a counter-derivative with
+    // another per-series function: `sum(rate(m[5m]) + changes(m[5m]))`.
+    let mixed = ok("sum(rate(m[5m]) + changes(m[5m]))");
+    let QueryExpr::Aggregate { aggs, child, .. } = &mixed else {
+        panic!("expected Aggregate, got {mixed:?}");
+    };
+    assert!(matches!(aggs.as_slice(), [AggIntent::Sum { .. }]));
+    assert!(matches!(child.as_ref(), QueryExpr::BinaryOp { .. }));
+    assert!(intents(&mixed).iter().any(|i| matches!(i, AggIntent::Rate)));
+    assert!(intents(&mixed).iter().any(|i| matches!(i, AggIntent::Changes)));
+}
+
+#[test]
+fn counter_derivative_over_a_subquery_is_rejected__GAP() {
+    // Unlike `*_over_time` (issue #42), the counter-derivative functions do not
+    // yet accept a sub-query argument — only a bare matrix selector. This is
+    // valid PromQL and rejects cleanly (never mislowered); wiring them into the
+    // sub-query path is a follow-up to #42/#44.
+    let _ = rejected("changes(rate(m[5m])[1h:])");
+    let _ = rejected("delta(sum(m)[5m:])");
+}