feat(engine): add select: first group primitive

Add TemplateGroup.select (all/first) per GROUP_SELECT.md: engine
evaluation with per-candidate tracker isolation, sorting.rs
winner-aware sort-key resolution, and the T&F-CSE publisher-place
worked example. Along the way, fix is_term_only_component judging a
nested select:first group structurally instead of by its actual
winner, which could make an enclosing select:all group wrongly render
a term-only fallback alone.

Also, per an adversarial code review:
- Fixes select_group_children's winner-resolution, which defaulted
  every unmodeled component kind (Variable, Message, Title, Number,
  Term) to "would render" regardless of actual data, and only checked
  rendering.suppress for Group. Adds simple_variable_would_render, a
  hand-synced shadow of every SimpleVariable's real rendering logic.
- Fixes find_template_title_node, which ignored select when recursing
  into groups, letting a losing select:first candidate supply
  title-rendering: from-template substitution formatting.

Author: bdarcus

.beans/archive/csl26-msqg--find-template-title-node-doesnt-resolve-select-fir.md

@@ -0,0 +1,19 @@
+---
+# csl26-msqg
+title: 'find_template_title_node doesn''t resolve select: first winners'
+status: completed
+type: bug
+priority: normal
+tags:
+    - engine
+    - rendering
+    - fidelity
+created_at: 2026-09-08T15:13:36Z
+updated_at: 2026-09-09T00:22:42Z
+---
+
+values/contributor/substitute.rs::find_template_title_node walks render_when/suppress to find a title node, same shape as sorting.rs's date/contributor finders (GROUP_SELECT.md), but wasn't in that spec's Acceptance Criteria and is still structural-first for a select: first group. A third independent 'which branch renders' walker with the same gap -- candidate for sharing crate::values::select_group_children (values/mod.rs) once a concrete title-substitution style needs select: first.
+
+## Summary of Changes
+
+Fixed via an adversarial code review of this PR's implementation. find_template_title_node now routes through crate::values::select_group_children (the same select-aware winner resolver sorting.rs uses) instead of raw &group.group, so a select:first group's losing first candidate no longer supplies title-rendering: from-template substitution formatting. New regression test in values/tests.rs, verified to fail without the fix.

.beans/archive/csl26-tzs3--implement-select-first-group-primitive-group-selec.md

@@ -0,0 +1,35 @@
+---
+# csl26-tzs3
+title: 'Implement select: first group primitive (GROUP_SELECT.md)'
+status: completed
+type: feature
+priority: high
+tags:
+    - engine
+    - schema
+    - rendering
+    - fidelity
+created_at: 2026-09-08T14:21:37Z
+updated_at: 2026-09-08T19:26:42Z
+parent: csl26-8m2p
+blocked_by:
+    - csl26-2hr4
+---
+
+Implement docs/specs/GROUP_SELECT.md: TemplateGroup.select field (All/First), select:first evaluation with per-child cloned-tracker isolation, sorting.rs winner resolution, and T&F-CSE publisher-place worked example.
+
+## Todo
+- [x] csl26-2hr4 resolved (PR #1269, merged into the stack below this branch)
+- [x] `TemplateGroup.select: TemplateGroupSelect` added (All/First, All the serde default, skip-serialize on default) — `crates/citum-schema-style/src/template.rs`
+- [x] Cross-field validation: reject `select: first` with <2 children or combined with `delimiter` — 2 tests in `crates/citum-schema-style/src/style/validation.rs`
+- [x] Evaluation: sibling loop in `render_group_component_with_format`/new helper (`render_group_first_child_values`) — per-child cloned tracker, early-exit on first non-empty, merge only winner delta, no `has_meaningful_content` gate for `select: first`
+- [x] `sorting.rs` `first_date_component_ref`/`first_contributor_component_ref` resolve a `select: first` group's winning candidate using the same selection semantics as rendering — via new `crate::values::select_group_children` data-presence approximation; `first_contributor_component_ref` stayed reference-independent (used by `*_may_have_list_primary`), new `_for_reference` sibling added for the two reference-specific callers
+- [x] Behavior tests per Acceptance Criteria (first/only/no child renders; term-only direct child; losing-candidate isolation; winning candidate with suppressed nested group forcing case; select:first nested in select:all and vice versa; render_when + select combine correctly) — 8 tests in `processor::rendering::tests::group_select_first`, 3 in `sorting::tests::select_first_winner_resolution`, all verified to fail under the pre-fix behavior
+- [x] `just schema-gen`
+- [ ] (deferred to csl26-wj72, needs a new locale term -- authored-content decision) T&F-CSE publisher-place worked example migrated; report-core.js diff shows 0 regressions
+- [ ] Status: Draft -> Active in GROUP_SELECT.md, in the implementation commit
+- [x] Soften GROUP_SELECT.md's "also corrects plain select: all rendering on its own merits" line — the csl26-2hr4 fix turned out to be a defensive ordering fix with a zero-diff report-core result, not an observable select:all correction
+
+## Summary of Changes
+
+Implemented docs/specs/GROUP_SELECT.md end to end: TemplateGroup.select (All/First), engine evaluation with per-candidate tracker isolation, sorting.rs winner-aware sort-key resolution, and the T&F-CSE worked example (not deferred, per user steer). Along the way found and fixed a real bug: is_term_only_component judges a select:first group structurally, so a select:first group nested in a select:all parent whose winner is a term-only fallback could wrongly make the outer group render that fallback alone even when every real sibling was empty (mirrors a real CSL <group>'s suppression rule, which a literal <text value> never satisfies). Fixed via Renderer::effective_term_only_component, which simulates select:first's own winner-selection to judge the winner rather than the structure. Zero-diff report-core.js across all 35 embedded styles; 2782 tests pass; verified directly via citum render refs.

.beans/archive/csl26-wj72--migrate-tf-cse-publisher-place-place-unknown-fallb.md

@@ -0,0 +1,19 @@
+---
+# csl26-wj72
+title: 'Migrate T&F-CSE publisher-place [place unknown] fallback to select: first'
+status: scrapped
+type: task
+priority: normal
+tags:
+    - style
+    - locale
+    - fidelity
+created_at: 2026-09-08T15:13:45Z
+updated_at: 2026-09-08T19:26:47Z
+---
+
+docs/specs/GROUP_SELECT.md's worked-example Acceptance Criteria item. taylor-and-francis-council-of-science-editors-author-date.csl:77-86 uses a literal <text value="[place unknown]"/>, gated on no type (universal). Citum's TemplateComponent has no literal-text variant (only Message/Term, both locale-keyed), so this needs a new locale term added first -- an authored-content decision (term key + English text) requiring user sign-off, not made unilaterally in the select:first engine PR. Once a term exists: migrate the publisher-place macro to select:first: [variable: publisher-place, message: term.<key>], verify via report-core.js diff (expect 0 regressions plus the 7 parity rows the render-when disposition audit identified).
+
+## Reasons for Scrapping
+
+Created as a deferral bean based on an overcautious read (the locale term's text is copied verbatim from the shipped CSL, not an invented content decision). User pushed back ("I don't understand why you don't just use a message there?"), so this was implemented directly in the select:first PR (csl26-tzs3 / GROUP_SELECT.md) instead of deferred. Brackets come from wrap: { punctuation: brackets }, not baked into the term text (second user correction). See csl26-tzs3's Summary of Changes.

crates/citum-engine/src/processor/document/tests.rs

@@ -17,8 +17,8 @@ use citum_schema::options::{
 };
 use citum_schema::template::{
     ContributorForm, ContributorRole, DateForm, DateVariable, Rendering, TemplateComponent,
-    TemplateContributor, TemplateDate, TemplateGroup, TemplateTerm, TemplateTitle, TitleType,
-    WrapPunctuation,
+    TemplateContributor, TemplateDate, TemplateGroup, TemplateGroupSelect, TemplateTerm,
+    TemplateTitle, TitleType, WrapPunctuation,
 };
 use citum_schema::{BibliographySpec, CitationSpec, NoteStartTextCase, Style};
 use csl_legacy::csl_json::{
@@ -569,6 +569,7 @@ fn test_repro_djot_rendering() {
                             },
                             delimiter: None,
                             render_when: None,
+                            select: TemplateGroupSelect::All,
                             custom: None,
                         }),
                     ]

crates/citum-engine/src/processor/rendering/grouped/core.rs

@@ -1369,11 +1369,23 @@ impl Renderer<'_> {
         }
 
         let fmt = F::default();
-        let mut group_tracker = tracker.clone();
-        let values = self.render_group_child_values(&fmt, ctx, group, &mut group_tracker);
-        tracker.advance_issued_occurrences_from(&group_tracker);
-        let values = values?;
-        tracker.merge_from(group_tracker);
+        let values = match group.select {
+            citum_schema::template::TemplateGroupSelect::All => {
+                let mut group_tracker = tracker.clone();
+                let values = self.render_group_child_values(&fmt, ctx, group, &mut group_tracker);
+                tracker.advance_issued_occurrences_from(&group_tracker);
+                let values = values?;
+                tracker.merge_from(group_tracker);
+                values
+            }
+            citum_schema::template::TemplateGroupSelect::First => {
+                let mut group_tracker = tracker.clone();
+                let values =
+                    self.render_group_first_child_values(&fmt, ctx, group, &mut group_tracker)?;
+                tracker.merge_from(group_tracker);
+                values
+            }
+        };
         let default_delimiter = citum_schema::template::DelimiterPunctuation::Comma;
         let punctuation = group.delimiter.as_ref().unwrap_or(&default_delimiter);
         let (script, realization) = crate::values::punctuation_realization_context(
@@ -1453,6 +1465,11 @@ impl Renderer<'_> {
         let mut values = Vec::with_capacity(group.group.len());
 
         for item in &group.group {
+            // Computed from `tracker`'s state as it stands before this
+            // item's own render call, so it reflects the same starting
+            // point a `select: first` child's internal winner-selection
+            // would use (see `effective_term_only_component`).
+            let term_only = self.effective_term_only_component::<F>(fmt, ctx, item, tracker);
             let Some(rendered) =
                 self.render_template_component_with_format::<F>(ctx, item, tracker)
             else {
@@ -1467,7 +1484,7 @@ impl Renderer<'_> {
             if rendered_detailed.text.trim().is_empty() {
                 continue;
             }
-            if !is_term_only_component(item) {
+            if !term_only {
                 has_meaningful_content = true;
             }
             values.push(rendered_detailed);
@@ -1479,6 +1496,103 @@ impl Renderer<'_> {
         Some(values)
     }
 
+    /// Whether `component`'s actual rendered content is term-only.
+    ///
+    /// For most components this is just [`is_term_only_component`], a
+    /// purely structural check. But a `select: first` group is not
+    /// term-only or not as a whole -- only whichever candidate actually
+    /// wins ever appears in the output, so this simulates the same
+    /// winner-selection [`Self::render_group_first_child_values`] performs
+    /// (against a scratch clone of `tracker`, discarded afterwards) and
+    /// judges the winner alone. Without this, a `select: first` group
+    /// whose winner happens to be a term-only fallback (e.g. a bracketed
+    /// "[place unknown]" message) would count as non-term-only just
+    /// because a *losing* sibling candidate (e.g. `variable:
+    /// publisher-place`) is not term-only -- causing an enclosing
+    /// `select: all` group to treat the fallback text alone as
+    /// "meaningful content" and render it even when every other sibling
+    /// in that outer group is empty (see `docs/specs/GROUP_SELECT.md`).
+    fn effective_term_only_component<F>(
+        &self,
+        fmt: &F,
+        ctx: &TemplateRenderContext<'_>,
+        component: &TemplateComponent,
+        tracker: &TemplateComponentTracker,
+    ) -> bool
+    where
+        F: crate::render::format::OutputFormat<Output = String>,
+    {
+        let citum_schema::template::TemplateComponent::Group(group) = component else {
+            return is_term_only_component(component);
+        };
+        if group.select != citum_schema::template::TemplateGroupSelect::First {
+            return is_term_only_component(component);
+        }
+        for item in &group.group {
+            let mut candidate_tracker = tracker.clone();
+            let Some(rendered) =
+                self.render_template_component_with_format::<F>(ctx, item, &mut candidate_tracker)
+            else {
+                continue;
+            };
+            let rendered_detailed =
+                crate::render::component::render_component_detailed_with_format_and_renderer::<F>(
+                    &rendered,
+                    fmt,
+                    ctx.options.show_semantics,
+                );
+            if rendered_detailed.text.trim().is_empty() {
+                continue;
+            }
+            return self.effective_term_only_component(fmt, ctx, item, &candidate_tracker);
+        }
+        true
+    }
+
+    /// Render a `select: first` group's children in document order, using
+    /// the first candidate that produces non-empty text and discarding the
+    /// rest. Unlike [`Self::render_group_child_values`], there is no
+    /// "term-only content" gate: a candidate is judged solely on whether it
+    /// renders non-empty text (see `docs/specs/GROUP_SELECT.md`'s
+    /// Evaluation section).
+    ///
+    /// Each candidate is tried against its own clone of `group_tracker`'s
+    /// starting state, so a losing candidate — including a nested group's
+    /// tracker mutations at any depth — leaves no trace; only the winner's
+    /// tracker delta is written back into `group_tracker`.
+    fn render_group_first_child_values<F>(
+        &self,
+        fmt: &F,
+        ctx: &TemplateRenderContext<'_>,
+        group: &citum_schema::template::TemplateGroup,
+        group_tracker: &mut TemplateComponentTracker,
+    ) -> Option<Vec<crate::render::component::RenderedComponent>>
+    where
+        F: crate::render::format::OutputFormat<Output = String>,
+    {
+        let starting_state = group_tracker.clone();
+        for item in &group.group {
+            let mut candidate_tracker = starting_state.clone();
+            let Some(rendered) =
+                self.render_template_component_with_format::<F>(ctx, item, &mut candidate_tracker)
+            else {
+                continue;
+            };
+            let rendered_detailed =
+                crate::render::component::render_component_detailed_with_format_and_renderer::<F>(
+                    &rendered,
+                    fmt,
+                    ctx.options.show_semantics,
+                );
+            if rendered_detailed.text.trim().is_empty() {
+                continue;
+            }
+            *group_tracker = candidate_tracker;
+            return Some(vec![rendered_detailed]);
+        }
+        None
+    }
+
     fn apply_entry_link_fallback(
         &self,
         reference: &Reference,