diff --git a/shared/yeast-macros/src/ast.rs b/shared/yeast-macros/src/ast.rs
index f400257fd1d4..a08d56e9661d 100644
--- a/shared/yeast-macros/src/ast.rs
+++ b/shared/yeast-macros/src/ast.rs
@@ -100,6 +100,15 @@ pub(crate) enum Template {
     Node(Node),
     /// An embedded Rust block such as `{args}`.
     Splice(syn::Block),
+    /// Ordered alternatives such as `[(identifier #{name}) (missing)]`.
+    Choice(Vec<Alternative>),
+}
+
+pub(crate) struct Alternative {
+    /// Template to construct when the guard and dependencies succeed.
+    pub(crate) template: Template,
+    /// Optional postfix guard such as `if { name.is_some() }`.
+    pub(crate) guard: Option<syn::Block>,
 }
 
 pub(crate) struct Node {
@@ -121,15 +130,13 @@ pub(crate) enum Content {
 
 pub(crate) enum Field {
     /// A named field such as `argument: {args}` or
-    /// `label: (identifier #{name})?`.
+    /// `label: (identifier #{name})`.
     Named {
         /// The field name before `:`, such as `argument`.
         name: Ident,
         /// The node or Rust splice after `:`, such as `(identifier "x")` or
         /// `{args}`.
         value: Template,
-        /// Whether the field value has a trailing `?`.
-        optional: bool,
     },
     /// Source-location metadata such as `location: {source}`.
     Location {
diff --git a/shared/yeast-macros/src/lib.rs b/shared/yeast-macros/src/lib.rs
index 75d737372965..ad686403a3d4 100644
--- a/shared/yeast-macros/src/lib.rs
+++ b/shared/yeast-macros/src/lib.rs
@@ -52,6 +52,8 @@ pub fn query(input: TokenStream) -> TokenStream {
 
 /// Build a single AST node from a template, returning its `OutputId`.
 ///
+/// A top-level choice returns `Option<OutputId>`.
+///
 /// # Template syntax
 ///
 /// ```text
@@ -63,36 +65,43 @@ pub fn query(input: TokenStream) -> TokenStream {
 ///                                `Option<OutputId>`, iterator chains) splice
 ///                                their elements
 /// field: {expr}                - extend a named field with `{expr}`'s ids
-/// field: (kind ...)?           - set the field only if every `#{expr}`
-///                                beneath it has a value (see below)
 /// location: {expr}             - override this node's source range with the
 ///                                span of one or more nodes; may be repeated
+/// field: [(kind ...)]          - set the field only if the alternative can
+///                                be constructed (see below)
+/// field: [(a) (b)]             - use the first constructible alternative
+/// field: [(a) if {guard} (b)]  - skip an alternative when its guard is false
 /// ```
 ///
-/// # Optional fields
+/// # Template choices
 ///
-/// A `?` on a field's value makes that field fallible: if a `#{expr}`
-/// anywhere beneath it interpolates an absent value — an `Option` that is
-/// `None` — the subtree is abandoned and the field is left unset. This
-/// replaces the surrounding `Option::map` that would otherwise be needed:
+/// Brackets contain one or more ordered alternatives. For each alternative,
+/// its optional `if {guard}` is evaluated first, followed by every `#{expr}`
+/// dependency beneath it. An absent dependency — an `Option` that is `None` —
+/// skips the alternative without constructing any of its template nodes. The
+/// first alternative whose guard and dependencies succeed is constructed:
 ///
 /// ```text
 /// (break_expr label: {lbl.map(|l| tree!((identifier #{l})))})   // before
-/// (break_expr label: (identifier #{lbl})?)                      // after
+/// (break_expr label: [(identifier #{lbl})])                     // after
 /// ```
 ///
-/// The value may be nested arbitrarily deeply, and a nested `?` catches
-/// first, so an inner absent value need not discard the outer node:
+/// Dependencies may be nested arbitrarily deeply. A nested choice handles its
+/// own dependencies, so an inner absent value need not discard an outer node:
 ///
 /// ```text
-/// (parameter pattern: (name_pattern identifier: (identifier #{name}))? type: {ty})
+/// (parameter pattern: [
+///     (name_pattern identifier: [(identifier #{name})])
+/// ] type: {ty})
 /// ```
 ///
-/// Only `#{expr}` propagates absence. A `{expr}` splice is unaffected, since
-/// yielding no ids already leaves a field unset, and `?` is rejected on one.
-/// Outside a `?`, interpolating an `Option` with `#{expr}` remains a compile
-/// error, so the choice between "unset the field" and "unwrap it" stays
-/// explicit.
+/// Only `#{expr}` is treated as a dependency. A `{expr}` splice is unaffected,
+/// since yielding no ids already leaves its field unset. Outside a choice,
+/// interpolating an `Option` with `#{expr}` remains a compile error.
+///
+/// A choice used as a field or list item contributes zero or one node. A
+/// top-level choice passed to `tree!` returns `Option<OutputId>`; ordinary
+/// templates continue to return `OutputId`.
 ///
 /// Uses the `BuildCtx` binding named `ctx` from the surrounding scope:
 ///
diff --git a/shared/yeast-macros/src/lower.rs b/shared/yeast-macros/src/lower.rs
index 6bf22c7e8b9e..6ed98725a086 100644
--- a/shared/yeast-macros/src/lower.rs
+++ b/shared/yeast-macros/src/lower.rs
@@ -1,19 +1,32 @@
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::quote;
+use std::cell::RefCell;
 use std::sync::atomic::{AtomicUsize, Ordering};
-use syn::Lifetime;
 
-use crate::ast::{Cardinality, Content, Field, Node, Pattern, Replacement, Rule, Template};
+use crate::ast::{
+    Alternative, Cardinality, Content, Field, Node, Pattern, Replacement, Rule, Template,
+};
 
+#[derive(Clone, Copy, Default)]
 struct LoweringContext<'a> {
-    /// Enclosing optional-field label to exit when a computed value is absent.
-    fallible_scope: Option<&'a Lifetime>,
+    dependency_scope: Option<DependencyScope<'a>>,
 }
 
-fn fresh_fallible_label() -> Lifetime {
+#[derive(Clone, Copy)]
+struct DependencyScope<'a> {
+    preparations: &'a RefCell<Vec<DependencyPreparation>>,
+}
+
+struct DependencyPreparation {
+    value: Ident,
+    source_range: Ident,
+    expression: TokenStream,
+}
+
+fn fresh_prepared_ident(suffix: &str) -> Ident {
     static COUNTER: AtomicUsize = AtomicUsize::new(0);
     let n = COUNTER.fetch_add(1, Ordering::Relaxed);
-    Lifetime::new(&format!("'__yeast_field_{n}"), Span::call_site())
+    Ident::new(&format!("__yeast_prepared_{suffix}_{n}"), Span::call_site())
 }
 
 #[derive(Clone)]
@@ -286,20 +299,19 @@ fn capture_bindings<'a>(
 
 impl Template {
     pub(crate) fn lower_root(&self) -> TokenStream {
-        self.lower(&LoweringContext {
-            fallible_scope: None,
-        })
+        match self {
+            Template::Choice(alternatives) => Self::lower_choice(alternatives),
+            _ => self.lower_single(LoweringContext::default()),
+        }
     }
 
     pub(crate) fn lower_list(templates: &[Self]) -> TokenStream {
-        let context = LoweringContext {
-            fallible_scope: None,
-        };
+        let context = LoweringContext::default();
         let items = templates
             .iter()
             .map(|template| match template {
                 Template::Node(node) => {
-                    let node = node.lower(&context);
+                    let node = node.lower(context);
                     quote! { __nodes.push(#node); }
                 }
                 Template::Splice(block) => {
@@ -310,6 +322,14 @@ impl Template {
                         ctx.extend_field_ids(__value, &mut __nodes);
                     }
                 }
+                Template::Choice(alternatives) => {
+                    let pick = Self::lower_choice(alternatives);
+                    quote! {
+                        if let ::std::option::Option::Some(__id) = #pick {
+                            __nodes.push(__id);
+                        }
+                    }
+                }
             })
             .collect::<Vec<_>>();
 
@@ -322,19 +342,102 @@ impl Template {
         }
     }
 
-    fn lower(&self, context: &LoweringContext<'_>) -> TokenStream {
+    fn lower_single(&self, context: LoweringContext<'_>) -> TokenStream {
         match self {
             Template::Node(node) => node.lower(context),
             Template::Splice(block) => {
                 let block = rust_block(block);
                 quote! { ::std::convert::Into::<yeast::OutputId>::into(#block) }
             }
+            Template::Choice(_) => {
+                unreachable!("choices are lowered through Template::lower_choice")
+            }
+        }
+    }
+
+    fn lower_choice(alternatives: &[Alternative]) -> TokenStream {
+        let pick = alternatives.iter().rev().fold(
+            quote! { ::std::option::Option::None },
+            |fallback, alternative| {
+                alternative.lower_candidate(fallback)
+            },
+        );
+        quote! {{ #pick }}
+    }
+}
+
+impl Alternative {
+    fn lower_candidate(&self, fallback: TokenStream) -> TokenStream {
+        let preparations = RefCell::new(Vec::new());
+        let context = LoweringContext {
+            dependency_scope: Some(DependencyScope {
+                preparations: &preparations,
+            }),
+        };
+        let value = self.template.lower_single(context);
+        let preparations = preparations.into_inner();
+        let prepared_values = preparations
+            .iter()
+            .flat_map(|preparation| {
+                [
+                    preparation.value.clone(),
+                    preparation.source_range.clone(),
+                ]
+            })
+            .collect::<Vec<_>>();
+        let prepared = quote! {
+            ::std::option::Option::Some((#(#prepared_values),*))
+        };
+
+        // Nest dependency matches around preparation in reverse, so they are
+        // evaluated in source order. Construction happens only after the
+        // resulting option has been matched, keeping it in a separate branch
+        // from the fallback.
+        let prepared = preparations.into_iter().rev().fold(
+            prepared,
+            |candidate, preparation| {
+                let DependencyPreparation {
+                    value,
+                    source_range,
+                    expression,
+                } = preparation;
+                // Do not use `map`/`and_then` here: `candidate` may contain
+                // embedded user Rust, and putting it in a closure would change
+                // the target of `return` and the result type seen by `?`.
+                quote! {
+                    match #expression {
+                        ::std::option::Option::Some((#value, #source_range)) => #candidate,
+                        ::std::option::Option::None => ::std::option::Option::None,
+                    }
+                }
+            },
+        );
+        let prepared = if let Some(guard) = &self.guard {
+            let guard = rust_block(guard);
+            quote! {
+                if #guard {
+                    #prepared
+                } else {
+                    ::std::option::Option::None
+                }
+            }
+        } else {
+            prepared
+        };
+
+        quote! {
+            match #prepared {
+                ::std::option::Option::Some((#(#prepared_values),*)) => {
+                    ::std::option::Option::Some(#value)
+                }
+                ::std::option::Option::None => #fallback,
+            }
         }
     }
 }
 
 impl Node {
-    fn lower(&self, context: &LoweringContext<'_>) -> TokenStream {
+    fn lower(&self, context: LoweringContext<'_>) -> TokenStream {
         let ctx = Ident::new("ctx", Span::call_site());
         let kind_str = self.kind.to_string();
 
@@ -343,25 +446,38 @@ impl Node {
                 Content::Static(lit) => quote! { #ctx.literal(#kind_str, #lit) },
                 Content::Computed(block) => {
                     let block = rust_block(block);
-                    if let Some(label) = context.fallible_scope {
+                    if let Some(scope) = context.dependency_scope {
+                        let value = fresh_prepared_ident("value");
+                        let source_range = fresh_prepared_ident("source_range");
+                        scope.preparations.borrow_mut().push(DependencyPreparation {
+                            value: value.clone(),
+                            source_range: source_range.clone(),
+                            expression: quote! {
+                                {
+                                    let __expr = #block;
+                                    yeast::MaybeYeastValue::maybe_yeast_value(&__expr).map(
+                                        |__value_ref| {
+                                            (
+                                                yeast::YeastDisplay::yeast_to_string(
+                                                    __value_ref,
+                                                    &#ctx,
+                                                ),
+                                                yeast::YeastSourceRange::yeast_source_range(
+                                                    __value_ref,
+                                                    &#ctx,
+                                                ),
+                                            )
+                                        },
+                                    )
+                                }
+                            },
+                        });
                         quote! {
-                            {
-                                let __expr = #block;
-                                let ::std::option::Option::Some(__value_ref) =
-                                    yeast::MaybeYeastValue::maybe_yeast_value(&__expr)
-                                else {
-                                    break #label ::std::option::Option::None;
-                                };
-                                let __value =
-                                    yeast::YeastDisplay::yeast_to_string(__value_ref, &#ctx);
-                                let __source_range =
-                                    yeast::YeastSourceRange::yeast_source_range(__value_ref, &#ctx);
-                                #ctx.literal_with_source_range(
-                                    #kind_str,
-                                    &__value,
-                                    __source_range,
-                                )
-                            }
+                            #ctx.literal_with_source_range(
+                                #kind_str,
+                                &#value,
+                                #source_range,
+                            )
                         }
                     } else {
                         quote! {
@@ -399,11 +515,7 @@ impl Node {
                         #ctx.extend_location_ranges(__value, &mut __location_ranges);
                     });
                 }
-                Field::Named {
-                    name,
-                    value,
-                    optional,
-                } => {
+                Field::Named { name, value } => {
                     let field_name = name.to_string();
                     let field_str = field_name
                         .strip_prefix("r#")
@@ -413,10 +525,8 @@ impl Node {
                         &format!("__field_{field_str}_{field_counter}"),
                         Span::call_site(),
                     );
-
                     match value {
                         Template::Splice(block) => {
-                            debug_assert!(!optional);
                             let block = rust_block(block);
                             stmts.push(quote! {
                                 let mut #temp: Vec<yeast::OutputId> = Vec::new();
@@ -430,16 +540,10 @@ impl Node {
                                 }
                             });
                         }
-                        Template::Node(child) if *optional => {
-                            let label = fresh_fallible_label();
-                            let value = child.lower(&LoweringContext {
-                                fallible_scope: Some(&label),
-                            });
+                        Template::Choice(alternatives) => {
+                            let pick = Template::lower_choice(alternatives);
                             stmts.push(quote! {
-                                #[allow(unused_labels)]
-                                let #temp: ::std::option::Option<yeast::OutputId> = #label: {
-                                    ::std::option::Option::Some(#value)
-                                };
+                                let #temp: ::std::option::Option<yeast::OutputId> = #pick;
                             });
                             field_args.push(quote! {
                                 if let ::std::option::Option::Some(__id) = #temp {
diff --git a/shared/yeast-macros/src/template_parse.rs b/shared/yeast-macros/src/template_parse.rs
index 782407466a46..5d63a1e45c27 100644
--- a/shared/yeast-macros/src/template_parse.rs
+++ b/shared/yeast-macros/src/template_parse.rs
@@ -1,7 +1,7 @@
 use proc_macro2::{Delimiter, Ident, Literal, Span, TokenStream, TokenTree};
 use std::iter::Peekable;
 
-use crate::ast::{Content, Field, Node, Template};
+use crate::ast::{Alternative, Content, Field, Node, Template};
 
 type Tokens = Peekable<proc_macro2::token_stream::IntoIter>;
 type Result<T> = std::result::Result<T, syn::Error>;
@@ -9,7 +9,6 @@ type Result<T> = std::result::Result<T, syn::Error>;
 pub(crate) fn parse_template(input: TokenStream) -> Result<Template> {
     let mut tokens = input.into_iter().peekable();
     let template = parse_one(&mut tokens)?;
-    reject_stray_optional(&mut tokens, false)?;
     if let Some(token) = tokens.next() {
         return Err(syn::Error::new_spanned(
             token,
@@ -41,9 +40,13 @@ fn parse_one(tokens: &mut Tokens) -> Result<Template> {
             let group = expect_group(tokens, Delimiter::Parenthesis)?;
             Ok(Template::Node(parse_node(group)?))
         }
+        Some(TokenTree::Group(group)) if group.delimiter() == Delimiter::Bracket => {
+            let group = expect_group(tokens, Delimiter::Bracket)?;
+            Ok(Template::Choice(parse_alternatives(group)?))
+        }
         Some(token) => Err(syn::Error::new_spanned(
             token.clone(),
-            "expected `(` or `{` in tree template",
+            "expected `(`, `{`, or `[` in tree template",
         )),
         None => Err(syn::Error::new(
             Span::call_site(),
@@ -93,33 +96,12 @@ fn parse_node(group: proc_macro2::Group) -> Result<Node> {
                 return Err(error);
             }
             let block = parse_block(expect_group(&mut tokens, Delimiter::Brace)?)?;
-            if let Some(TokenTree::Punct(punctuation)) = tokens.peek() {
-                if punctuation.as_char() == '?' {
-                    return Err(syn::Error::new_spanned(
-                        punctuation.clone(),
-                        "`?` is not valid on a `location` field",
-                    ));
-                }
-            }
             fields.push(Field::Location { block });
             continue;
         }
 
         let value = parse_one(&mut tokens)?;
-        let optional = if matches!(value, Template::Splice(_)) {
-            reject_stray_optional(&mut tokens, true)?;
-            false
-        } else if peek_is_punct(&mut tokens, '?') {
-            tokens.next();
-            true
-        } else {
-            false
-        };
-        fields.push(Field::Named {
-            name,
-            value,
-            optional,
-        });
+        fields.push(Field::Named { name, value });
     }
 
     if let Some(token) = tokens.next() {
@@ -137,6 +119,42 @@ fn parse_node(group: proc_macro2::Group) -> Result<Node> {
     })
 }
 
+fn parse_alternatives(group: proc_macro2::Group) -> Result<Vec<Alternative>> {
+    let mut tokens = group.stream().into_iter().peekable();
+    let mut alternatives = Vec::new();
+    while tokens.peek().is_some() {
+        if peek_is_group(&mut tokens, Delimiter::Bracket) {
+            let nested = expect_group(&mut tokens, Delimiter::Bracket)?;
+            return Err(syn::Error::new(
+                nested.span(),
+                "a choice cannot be used directly as another choice's alternative; \
+                 list its alternatives directly in the enclosing choice",
+            ));
+        }
+        let template = parse_one(&mut tokens)?;
+        let guard = if peek_is_ident(&mut tokens, "if") {
+            tokens.next();
+            let group = expect_group(&mut tokens, Delimiter::Brace).map_err(|error| {
+                syn::Error::new(
+                    error.span(),
+                    "expected `{ ... }` guard condition after `if`",
+                )
+            })?;
+            Some(parse_block(group)?)
+        } else {
+            None
+        };
+        alternatives.push(Alternative { template, guard });
+    }
+    if alternatives.is_empty() {
+        return Err(syn::Error::new(
+            group.span(),
+            "template choices must contain at least one alternative",
+        ));
+    }
+    Ok(alternatives)
+}
+
 fn parse_list(tokens: &mut Tokens) -> Result<Vec<Template>> {
     let mut templates = Vec::new();
     while tokens.peek().is_some() {
@@ -146,7 +164,6 @@ fn parse_list(tokens: &mut Tokens) -> Result<Vec<Template>> {
                 continue;
             }
             templates.push(Template::Node(parse_node(group)?));
-            reject_stray_optional(tokens, false)?;
             continue;
         }
 
@@ -155,7 +172,14 @@ fn parse_list(tokens: &mut Tokens) -> Result<Vec<Template>> {
                 tokens,
                 Delimiter::Brace,
             )?)?));
-            reject_stray_optional(tokens, true)?;
+            continue;
+        }
+
+        if peek_is_group(tokens, Delimiter::Bracket) {
+            templates.push(Template::Choice(parse_alternatives(expect_group(
+                tokens,
+                Delimiter::Bracket,
+            )?)?));
             continue;
         }
 
@@ -164,23 +188,6 @@ fn parse_list(tokens: &mut Tokens) -> Result<Vec<Template>> {
     Ok(templates)
 }
 
-fn reject_stray_optional(tokens: &mut Tokens, after_splice: bool) -> Result<()> {
-    let Some(TokenTree::Punct(punctuation)) = tokens.peek() else {
-        return Ok(());
-    };
-    if punctuation.as_char() != '?' {
-        return Ok(());
-    }
-    let message = if after_splice {
-        "`?` is not valid on a `{...}` splice; a splice that yields no value \
-         already leaves its field unset"
-    } else {
-        "`?` is only valid on the value of a named field, as in \
-         `label: (identifier #{lbl})?`"
-    };
-    Err(syn::Error::new_spanned(punctuation.clone(), message))
-}
-
 fn parse_block(group: proc_macro2::Group) -> Result<syn::Block> {
     syn::parse2(TokenStream::from(TokenTree::Group(group)))
 }
@@ -201,8 +208,8 @@ fn peek_is_group(tokens: &mut Tokens, delimiter: Delimiter) -> bool {
     matches!(tokens.peek(), Some(TokenTree::Group(group)) if group.delimiter() == delimiter)
 }
 
-fn peek_is_punct(tokens: &mut Tokens, expected: char) -> bool {
-    matches!(tokens.peek(), Some(TokenTree::Punct(punctuation)) if punctuation.as_char() == expected)
+fn peek_is_ident(tokens: &mut Tokens, expected: &str) -> bool {
+    matches!(tokens.peek(), Some(TokenTree::Ident(identifier)) if identifier == expected)
 }
 
 fn expect_ident(tokens: &mut Tokens, message: &str) -> Result<Ident> {
@@ -256,7 +263,7 @@ mod tests {
         let template = parse_template(quote! {
             (call
                 argument: {args}
-                method: (identifier #{name})?)
+                method: [(identifier #{name})])
         })
         .unwrap();
 
@@ -298,14 +305,51 @@ mod tests {
     }
 
     #[test]
-    fn rejects_optional_location_fields() {
+    fn parses_choice_guards() {
+        let template = parse_template(quote! {
+            [
+                (parameter type: {ty}) if { in_function_type }
+                (argument value: {ty})
+            ]
+        })
+        .unwrap();
+
+        let Template::Choice(alternatives) = template else {
+            panic!("expected template choice");
+        };
+        assert_eq!(alternatives.len(), 2);
+        assert!(alternatives[0].guard.is_some());
+        assert!(alternatives[1].guard.is_none());
+    }
+
+    #[test]
+    fn rejects_empty_choices() {
+        let result = parse_template(quote! { [] });
+        let Err(error) = result else {
+            panic!("expected empty choice to be rejected");
+        };
+        assert_eq!(
+            error.to_string(),
+            "template choices must contain at least one alternative"
+        );
+    }
+
+    #[test]
+    fn rejects_choice_as_direct_alternative() {
         let result = parse_template(quote! {
-            (identifier "name" location: {source}?)
+            [
+                [(identifier "nested")]
+                (identifier "fallback")
+            ]
         });
         let Err(error) = result else {
-            panic!("expected an optional location field to be rejected");
+            panic!("expected a direct nested choice to be rejected");
         };
-        assert_eq!(error.to_string(), "`?` is not valid on a `location` field");
+        assert_eq!(
+            error.to_string(),
+            "a choice cannot be used directly as another choice's alternative; \
+             list its alternatives directly in the enclosing choice"
+        );
     }
 
     #[test]
diff --git a/shared/yeast/doc/yeast.md b/shared/yeast/doc/yeast.md
index a58949db4438..78e4e1c21d71 100644
--- a/shared/yeast/doc/yeast.md
+++ b/shared/yeast/doc/yeast.md
@@ -331,47 +331,56 @@ accessor_declaration source="⟨accessor_kind⟩"
 Node and child ranges are still validated against the source text and UTF-8
 boundaries.
 
-### Optional fields (`?`)
+### Template choices (`[]`)
 
-A `?` on a field's value makes that field fallible. If a `#{expr}` anywhere
-beneath it interpolates an absent value — an `Option` that is `None` — the
-subtree is abandoned and the field is left unset:
+Brackets contain one or more ordered template alternatives. For each
+alternative, Yeast evaluates its optional `if {guard}` and preflights every
+`#{expr}` beneath it. If the guard is false or an interpolation produces
+`None`, that alternative is skipped without constructing any of its template
+nodes. The first alternative that can be constructed is emitted:
 
 ```rust
-rule!((breakStmt label: _? @@lbl) => (break_expr label: (identifier #{lbl})?))
+rule!((breakStmt label: _? @@lbl) => (break_expr label: [(identifier #{lbl})]))
 ```
 
-Here an optional capture is being wrapped in a leaf, which without `?` needs
-an `Option::map` to build the leaf only in the `Some` case:
+Here an optional capture is being wrapped in a leaf. A multi-way choice can
+provide a fallback, and alternatives can have explicit guards:
 
 ```rust
-// Equivalent, but the intent is buried in the closure:
-(break_expr label: {lbl.map(|l| tree!((identifier #{l})))})
+(import_declaration
+    pattern: [
+        (identifier #{last}) if { kind.is_some() }
+        (bulk_importing_pattern)
+    ])
 ```
 
-The marker mirrors the query language, where a quantifier likewise follows the
-value it applies to (`label: _? @@lbl`). Note that the schema puts it on the
-other side of the colon — `external_name?: identifier` — because it is
-*declaring* a field's cardinality rather than supplying a value for it.
-
-Absence propagates outwards through as many levels as necessary, and a nested
-`?` catches first, so an inner absent value need not discard the outer node:
+A choice may contain any nonzero number of alternatives. A single-alternative
+choice expresses an optional tree. Nested choices handle their own
+dependencies, so an inner absent value need not discard the outer node:
 
 ```rust
 // If `name` is absent, `pattern` is left unset — but `type` is still set.
-(parameter pattern: (name_pattern identifier: (identifier #{name}))? type: {ty})
+(parameter
+    pattern: [
+        (name_pattern identifier: [(identifier #{name})])
+    ]
+    type: {ty})
 ```
 
 Only `#{expr}` propagates absence, because it supplies a node's *content*: with
 no value there is no leaf to build. A `{expr}` splice supplies *children*, where
-yielding nothing already leaves the field unset (see below), so `?` is rejected
-on one. Repetition has no marker at all, in templates or elsewhere: how many
-children a `{expr}` contributes is a property of the expression rather than of
-the syntax.
+yielding nothing already leaves the field unset (see below). How many children
+a `{expr}` contributes is a property of the expression rather than of the
+template syntax.
+
+Outside a choice, interpolating an `Option` with `#{expr}` remains a compile
+error. That is deliberate: it keeps the choice between rejecting an
+alternative and unwrapping the value explicit at every interpolation.
 
-Outside a `?`, interpolating an `Option` with `#{expr}` remains a compile error.
-That is deliberate: it keeps the choice between "leave the field unset" and
-"unwrap it" explicit at every interpolation.
+Choice dependencies are evaluated before construction begins. A rejected
+alternative therefore leaves no partially constructed template nodes in the
+AST. Guards and dependencies are evaluated once, in source order. A nested
+choice is a separate dependency boundary.
 
 ### Embedded Rust expressions
 
@@ -399,9 +408,10 @@ yeast::trees!(
 ```
 
 Because an `Option<Id>` splices as zero or one id, `field: {opt}` already
-leaves the field unset when `opt` is `None`. Use [`?`](#optional-fields-)
-instead when the optional value has to be *wrapped* in a node first, so that
-there is nothing to wrap when it is absent.
+leaves the field unset when `opt` is `None`. Use a
+[single-alternative template choice](#template-choices-) instead when the
+optional value has to be *wrapped* in a node first, so that there is nothing
+to wrap when it is absent.
 
 The contents of `{…}` are treated as a Rust block, so multi-statement
 expressions (with `let` bindings) work too:
diff --git a/shared/yeast/src/lib.rs b/shared/yeast/src/lib.rs
index d950504b4e2a..6f2a7e821b99 100644
--- a/shared/yeast/src/lib.rs
+++ b/shared/yeast/src/lib.rs
@@ -248,8 +248,8 @@ where
 /// blanket `impl<T: Display>`, so additional types must be added explicitly.
 #[diagnostic::on_unimplemented(
     message = "`{Self}` cannot be interpolated with `#{{...}}`",
-    note = "if the value is optional, mark the enclosing field's value with `?` to leave \
-            that field unset when it is absent, as in `label: (identifier #{{lbl}})?`"
+    note = "if the value is optional, place the node in a template choice to leave \
+            that field unset when it is absent, as in `label: [(identifier #{{lbl}})]`"
 )]
 pub trait YeastDisplay {
     fn yeast_to_string<C>(&self, ctx: &build::BuildCtx<'_, C>) -> String;
@@ -327,8 +327,8 @@ impl<T: YeastSourceRange + ?Sized> YeastSourceRange for &T {
 }
 
 /// Normalizes a `#{expr}` interpolation to an optional value, so that a
-/// fallible field — `field: (kind #{expr})?` — can tell "there is a value to
-/// interpolate" apart from "there is none, so leave the field unset".
+/// template choice — `field: [(kind #{expr})]` — can tell "there is a value
+/// to interpolate" apart from "there is none, so try the next alternative".
 ///
 /// Implemented for every [`YeastDisplay`] type, which always yields a value,
 /// and for `Option` of the same, which yields one only when it is `Some`.
@@ -338,14 +338,15 @@ impl<T: YeastSourceRange + ?Sized> YeastSourceRange for &T {
 /// coherence cannot rule out a future `impl YeastDisplay for Option<T>`.
 /// [`YeastDisplay`] itself is enumerated for the same reason.
 ///
-/// Note that this is used *only* inside a fallible field. Elsewhere `#{expr}`
-/// still goes directly through [`YeastDisplay`], so interpolating an `Option`
-/// without a `?` remains a compile error rather than silently dropping a node.
+/// Note that this is used *only* while preparing a choice alternative.
+/// Elsewhere `#{expr}` still goes directly through [`YeastDisplay`], so
+/// interpolating an `Option` outside a choice remains a compile error rather
+/// than silently dropping a node.
 pub trait MaybeYeastValue {
     /// The interpolated value's type, which knows how to render itself.
     type Value: YeastDisplay + YeastSourceRange + ?Sized;
 
-    /// Returns the value to interpolate, or `None` to leave the field unset.
+    /// Returns the value to interpolate, or `None` to reject the alternative.
     fn maybe_yeast_value(&self) -> Option<&Self::Value>;
 }
 
diff --git a/shared/yeast/tests/test.rs b/shared/yeast/tests/test.rs
index 68a83db8ab91..a63a05f2e4af 100644
--- a/shared/yeast/tests/test.rs
+++ b/shared/yeast/tests/test.rs
@@ -713,13 +713,13 @@ fn test_tree_builder() {
     );
 }
 
-/// Builds `(assignment left: … right: (integer #{value})?)`, where a `None`
+/// Builds `(assignment left: … right: [(integer #{value})])`, where a `None`
 /// `value` leaves `right` unset rather than producing an `integer` with no
 /// content.
-fn build_optional_right(
+fn build_choice_right(
     input_ast: &Ast,
     ast: &mut OutputAst,
-    value: Option<yeast::OutputId>,
+    value: Option<yeast::Id>,
 ) -> (yeast::OutputId, yeast::OutputId) {
     let mut user_ctx = ();
     let mut ctx = yeast::build::BuildCtx::new(input_ast, ast, &mut user_ctx);
@@ -727,22 +727,26 @@ fn build_optional_right(
     let root = yeast::tree!(
         (assignment
             left: {left}
-            right: (integer #{value})?
+            right: [(integer #{value})]
         )
     );
     (root, left)
 }
 
 #[test]
-fn test_optional_field_is_set_when_the_value_is_present() {
-    let input_ast = parse_input("x = 1");
-    let mut ast = empty_output_ast("x = 1");
+fn test_choice_is_set_when_the_value_is_present() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
 
-    let some = ast.create_named_token("identifier", "x = 1".to_string());
+    // Any node will do as the interpolated value; `#{…}` renders its source text.
+    let mut cursor = AstCursor::new(&input_ast);
+    cursor.goto_first_child();
+    let some = cursor.node_id();
 
-    let (root, _) = build_optional_right(&input_ast, &mut ast, Some(some));
+    let (root, _) = build_choice_right(&input_ast, &mut ast, Some(some));
     assert_dump_eq(
-        &dump_ast(&ast, root, "x = 1"),
+        &dump_ast(&ast, root, input),
         r#"
         assignment
           left: identifier "x"
@@ -752,13 +756,14 @@ fn test_optional_field_is_set_when_the_value_is_present() {
 }
 
 #[test]
-fn test_optional_field_is_unset_when_the_value_is_absent() {
-    let input_ast = parse_input("x = 1");
-    let mut ast = empty_output_ast("x = 1");
+fn test_choice_is_unset_when_the_value_is_absent() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
 
-    let (root, _) = build_optional_right(&input_ast, &mut ast, None);
+    let (root, _) = build_choice_right(&input_ast, &mut ast, None);
     assert_dump_eq(
-        &dump_ast(&ast, root, "x = 1"),
+        &dump_ast(&ast, root, input),
         r#"
         assignment
           left: identifier "x"
@@ -767,26 +772,189 @@ fn test_optional_field_is_unset_when_the_value_is_absent() {
 }
 
 #[test]
-fn test_optional_field_propagates_through_nested_nodes() {
-    let input_ast = parse_input("x = 1");
-    let mut ast = empty_output_ast("x = 1");
+fn test_choice_uses_first_constructible_alternative() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
 
     let mut user_ctx = ();
     let mut ctx = yeast::build::BuildCtx::new(&input_ast, &mut ast, &mut user_ctx);
+    let absent: Option<yeast::Id> = None;
+    let root = yeast::tree!(
+        (assignment
+            left: [
+                (identifier #{absent})
+                (identifier "fallback")
+            ]
+        )
+    );
 
-    // The absent value sits two levels below the `?`, so the whole
+    assert_dump_eq(
+        &dump_ast(ctx.output, root, input),
+        r#"
+        assignment
+          left: identifier "fallback"
+    "#,
+    );
+}
+
+#[test]
+fn test_choice_guard_skips_an_alternative() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
+
+    let mut user_ctx = ();
+    let mut ctx = yeast::build::BuildCtx::new(&input_ast, &mut ast, &mut user_ctx);
+    let use_first = false;
+    let root = yeast::tree!(
+        (assignment
+            left: [
+                (identifier "first") if { use_first }
+                (identifier "fallback")
+            ]
+        )
+    );
+
+    assert_dump_eq(
+        &dump_ast(ctx.output, root, input),
+        r#"
+        assignment
+          left: identifier "fallback"
+    "#,
+    );
+}
+
+#[test]
+fn test_choice_fallback_can_reuse_consumed_splice() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
+
+    let mut user_ctx = ();
+    let mut ctx = yeast::build::BuildCtx::new(&input_ast, &mut ast, &mut user_ctx);
+    let items = vec![
+        yeast::tree!((identifier "x")),
+        yeast::tree!((identifier "y")),
+    ];
+    let use_first = false;
+    let root = yeast::tree!(
+        (assignment
+            left: [
+                (left_assignment_list
+                    child: {items}
+                    child: (identifier "first")) if { use_first }
+                (left_assignment_list
+                    child: {items}
+                    child: (identifier "fallback"))
+            ]
+        )
+    );
+
+    assert_dump_eq(
+        &dump_ast(ctx.output, root, input),
+        r#"
+        assignment
+          left:
+            left_assignment_list
+              identifier "x"
+              identifier "y"
+              identifier "fallback"
+    "#,
+    );
+}
+
+#[test]
+fn test_root_choice_returns_an_optional_node() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
+    let node_count = ast.nodes().len();
+
+    let mut user_ctx = ();
+    let mut ctx = yeast::build::BuildCtx::new(&input_ast, &mut ast, &mut user_ctx);
+    let absent: Option<yeast::Id> = None;
+    let missing = yeast::tree!([(identifier #{absent})]);
+    assert_eq!(missing, None);
+    assert_eq!(ctx.output.nodes().len(), node_count);
+
+    let root = yeast::tree!([
+        (identifier #{absent})
+        (identifier "fallback")
+    ])
+    .unwrap();
+    assert_dump_eq(
+        &dump_ast(ctx.output, root, input),
+        r#"
+        identifier "fallback"
+    "#,
+    );
+
+    let source = ctx.ast().get_root();
+    let located = yeast::tree!([
+        (identifier #{absent})
+        (identifier "located fallback" location: {source})
+    ])
+    .unwrap();
+    assert_eq!(
+        ctx.output.get_node(located).unwrap().source_range(),
+        ctx.ast().get_node(source).unwrap().source_range()
+    );
+}
+
+#[test]
+fn test_choice_preflights_dependencies_before_constructing() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
+    let node_count = ast.nodes().len();
+
+    let mut user_ctx = ();
+    let mut ctx = yeast::build::BuildCtx::new(&input_ast, &mut ast, &mut user_ctx);
+    let absent: Option<yeast::Id> = None;
+    let root = yeast::tree!(
+        (assignment
+            left: [
+                (left_assignment_list
+                    child: (identifier "would-be-orphan")
+                    child: (identifier #{absent}))
+                (identifier "fallback")
+            ]
+        )
+    );
+
+    assert_eq!(ctx.output.nodes().len(), node_count + 2);
+    assert_dump_eq(
+        &dump_ast(ctx.output, root, input),
+        r#"
+        assignment
+          left: identifier "fallback"
+    "#,
+    );
+}
+
+#[test]
+fn test_choice_propagates_through_nested_nodes() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
+
+    let mut user_ctx = ();
+    let mut ctx = yeast::build::BuildCtx::new(&input_ast, &mut ast, &mut user_ctx);
+
+    // The absent value sits two levels below the choice, so the whole
     // `left_assignment_list` subtree is abandoned along with it.
-    let absent: Option<yeast::OutputId> = None;
+    let absent: Option<yeast::Id> = None;
     let right = yeast::tree!((integer "1"));
     let root = yeast::tree!(
         (assignment
-            left: (left_assignment_list child: (identifier #{absent}))?
+            left: [(left_assignment_list child: (identifier #{absent}))]
             right: {right}
         )
     );
 
     assert_dump_eq(
-        &dump_ast(&ast, root, "x = 1"),
+        &dump_ast(ctx.output, root, input),
         r#"
         assignment
           right: integer "1"
@@ -795,23 +963,26 @@ fn test_optional_field_propagates_through_nested_nodes() {
 }
 
 #[test]
-fn test_innermost_optional_field_catches_first() {
-    let input_ast = parse_input("x = 1");
-    let mut ast = empty_output_ast("x = 1");
+fn test_innermost_choice_catches_first() {
+    let input = "x = 1";
+    let input_ast = parse_input(input);
+    let mut ast = empty_output_ast(input);
 
     let mut user_ctx = ();
     let mut ctx = yeast::build::BuildCtx::new(&input_ast, &mut ast, &mut user_ctx);
 
-    // The inner `?` catches, so only `child` is dropped; `left` survives.
-    let absent: Option<yeast::OutputId> = None;
+    // The inner choice catches, so only `child` is dropped; `left` survives.
+    let absent: Option<yeast::Id> = None;
     let root = yeast::tree!(
         (assignment
-            left: (left_assignment_list child: (identifier #{absent})?)?
+            left: [
+                (left_assignment_list child: [(identifier #{absent})])
+            ]
         )
     );
 
     assert_dump_eq(
-        &dump_ast(&ast, root, "x = 1"),
+        &dump_ast(ctx.output, root, input),
         r#"
         assignment
           left: left_assignment_list
@@ -1489,6 +1660,28 @@ fn test_hash_brace_renders_capture_source_text() {
     );
 }
 
+#[test]
+fn test_choice_accepts_optional_translated_capture() {
+    let rule: Rule = rule!(
+        (call method: (identifier) @name)
+        =>
+        (call
+            method: [(identifier #{Some(name)})]
+            arguments: (argument_list)
+        )
+    );
+    let dump = run_and_dump("foo()", vec![rule]);
+    assert_dump_eq(
+        &dump,
+        r#"
+        program
+          call
+            arguments: argument_list
+            method: identifier "foo"
+    "#,
+    );
+}
+
 /// Regression test: non-`OutputId` values in `#{expr}` still render via their
 /// `Display` impl (covered by `YeastDisplay`'s blanket impls for primitives).
 #[test]
diff --git a/unified/extractor/src/languages/swift/swift.rs b/unified/extractor/src/languages/swift/swift.rs
index 75b7c4e9c5c5..d492c078147f 100644
--- a/unified/extractor/src/languages/swift/swift.rs
+++ b/unified/extractor/src/languages/swift/swift.rs
@@ -60,18 +60,6 @@ impl SwiftContext {
     }
 }
 
-/// Build a freshly-created `chained_declaration` modifier node if
-/// `ctx.is_chained`, else `None`. Used by inner declaration rules to
-/// emit the chained tag for non-first children of a flattening outer
-/// rule. Returns `Option<OutputId>` so it splices via `{…}` to 0 or 1 ids.
-fn chained_modifier(ctx: &mut yeast::build::BuildCtx<'_, SwiftContext>) -> Option<yeast::OutputId> {
-    if ctx.is_chained {
-        Some(tree!((modifier "chained_declaration")))
-    } else {
-        None
-    }
-}
-
 fn implicit_parameterless_initializer(
     ctx: &mut yeast::build::BuildCtx<'_, SwiftContext>,
     members: &[yeast::OutputId],
@@ -411,7 +399,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
                         Vec::new()
                     }
                 }
-                modifier: {chained_modifier(&mut ctx)}
+                modifier: [(modifier "chained_declaration") if { ctx.is_chained }]
                 name_node: {
                     ctx.property_name_node
                         .ok_or("accessor outside property context")?
@@ -437,7 +425,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
             =>
             (variable_declaration
                 modifier: {ctx.outer_modifiers.clone()}
-                modifier: {chained_modifier(&mut ctx)}
+                modifier: [(modifier "chained_declaration") if { ctx.is_chained }]
                 pattern: {pattern}
                 type: {ty}
                 value: {ctx.reset(); val})
@@ -474,7 +462,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
         rule!(
             (enumCaseParameter firstName: _? @@name type: @ty)
             =>
-            (parameter pattern: (identifier #{name})? type: {ty})
+            (parameter pattern: [(identifier #{name})] type: {ty})
         ),
         // An enum element with associated values (`case circle(radius: Double)`)
         // becomes a nested `class_like_declaration` whose constructor carries the
@@ -496,7 +484,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
                     location: {clause}));
                 tree!((class_like_declaration
                     modifier: {ctx.outer_modifiers.clone()}
-                    modifier: {chained_modifier(&mut ctx)}
+                    modifier: [(modifier "chained_declaration") if { ctx.is_chained }]
                     modifier: (modifier "enum_case")
                     name_node: (identifier #{name})
                     member: {constructor}))
@@ -507,7 +495,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
             =>
             (variable_declaration
                 modifier: {ctx.outer_modifiers.clone()}
-                modifier: {chained_modifier(&mut ctx)}
+                modifier: [(modifier "chained_declaration") if { ctx.is_chained }]
                 modifier: (modifier "enum_case")
                 pattern: (identifier #{name})
                 value: {val})
@@ -517,7 +505,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
             =>
             (variable_declaration
                 modifier: {ctx.outer_modifiers.clone()}
-                modifier: {chained_modifier(&mut ctx)}
+                modifier: [(modifier "chained_declaration") if { ctx.is_chained }]
                 modifier: (modifier "enum_case")
                 pattern: (identifier #{name}))
         ),
@@ -566,7 +554,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
         rule!(
             (tuplePatternElement label: _? @@label pattern: @p)
             =>
-            (argument name_node: (identifier #{label})? value: {p})
+            (argument name_node: [(identifier #{label})] value: {p})
         ),
         // A type-casting pattern (`case is T`). Not yet supported, so it is
         // mapped to `unsupported_node` — an explicit reminder that this needs
@@ -720,7 +708,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
         rule!(
             (labeledExpr label: _? @@lbl expression: @val)
             =>
-            (argument name_node: (identifier #{lbl})? value: {val})
+            (argument name_node: [(identifier #{lbl})] value: {val})
         ),
         // An additional labeled trailing closure, such as the `c: { ... }` in
         // `foo { 42 } c: { ... }`, is turned into an argument to the function.
@@ -781,8 +769,8 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
         // value; `break` / `continue` an optional target label; `throw` its
         // thrown expression.
         rule!((returnStmt expression: _? @val) => (return_expr value: {val})),
-        rule!((breakStmt label: _? @@lbl) => (break_expr label_name_node: (identifier #{lbl})?)),
-        rule!((continueStmt label: _? @@lbl) => (continue_expr label_name_node: (identifier #{lbl})?)),
+        rule!((breakStmt label: _? @@lbl) => (break_expr label_name_node: [(identifier #{lbl})])),
+        rule!((continueStmt label: _? @@lbl) => (continue_expr label_name_node: [(identifier #{lbl})])),
         rule!((throwStmt expression: @val) => (throw_expr value: {val})),
         // ---- Closures ----
         // A closure (`{ (x: Int) -> Int in … }`) becomes a `function_expr`. The
@@ -816,7 +804,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
                 initializer: (initializerClause value: @val)?)
             =>
             (variable_declaration
-                modifier: (modifier #{spec})?
+                modifier: [(modifier #{spec})]
                 pattern: (identifier #{name})
                 value: {
                     // Expand [x] into [x = x]
@@ -1127,20 +1115,16 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
             =>
             import_declaration {
                 let last = *parts.last().ok_or("import has no path")?;
-                let pattern = match kind {
-                    None => {
-                        let bulk = tree!((bulk_importing_pattern location: {decl}));
-                        tree!((named_pattern
-                            name_node: (identifier #{last})
-                            sub_pattern: {bulk}))
-                    }
-                    Some(_) => tree!((identifier #{last})),
-                };
                 tree!((import_declaration
-                    modifier: (modifier #{kind})?
+                    modifier: [(modifier #{kind})]
                     modifier: {attrs}
                     modifier: {mods}
-                    pattern: {pattern}
+                    pattern: [
+                        (identifier #{last}) if { kind.is_some() }
+                        (named_pattern
+                            name_node: (identifier #{last})
+                            sub_pattern: (bulk_importing_pattern location: {decl}))
+                    ]
                     imported_expr: {member_chain(&mut ctx, parts)}))
             }
         ),
@@ -1247,13 +1231,11 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
                 firstName: _? @@name
                 type: @ty)
             =>
-            argument {
-                if ctx.in_function_type {
-                    tree!((parameter external_name_node: (identifier #{name})? type: {ty}))
-                } else {
-                    tree!((argument name_node: (identifier #{name})? value: {ty}))
-                }
-            }
+            [
+                (parameter external_name_node: [(identifier #{name})] type: {ty})
+                    if { ctx.in_function_type }
+                (argument name_node: [(identifier #{name})] value: {ty})
+            ]
         ),
         // A nominal type's `inheritanceClause` (`: Base, Proto`) becomes a list
         // of `base_type`s, one per inherited type. Each declaration keyword
@@ -1267,7 +1249,7 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
             =>
             (type_parameter
                 modifier: {attrs}
-                modifier: (modifier #{spec})?
+                modifier: [(modifier #{spec})]
                 name_node: (identifier #{name})
                 bound: {bound})
         ),