use alloc::rc::Rc;
use serde_json::Value;
use crate::{
data::catalog::{
document::{
AxisKind,
CatalogEntry,
EntryKind,
},
error::CatalogErrorExt,
lookup::LeafMatch,
name::CatalogName,
presets::PresetSelection,
select::{
query::{
LabeledStage,
NameList,
PerStage,
Predicate,
SelectQuery,
SortKey,
SortKeys,
Stage,
query_error,
},
run::MEMBERSHIP_KINDS,
state::{
SelectBuild,
SelectEnv,
SelectRun,
SelectTable,
StageOrigin,
},
},
stack::BunsenCatalogStack,
},
errors::{
BunsenError,
BunsenResult,
},
};
#[derive(Clone, Debug, PartialEq)]
pub struct OriginStage {
pub stage: LabeledStage,
pub origin: StageOrigin,
}
impl OriginStage {
pub fn new(
stage: Stage,
origin: StageOrigin,
) -> Self {
Self::labeled(stage.into(), origin)
}
pub fn labeled(
stage: LabeledStage,
origin: StageOrigin,
) -> Self {
Self { stage, origin }
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct NamedSelection {
pub name: String,
pub description: String,
pub run: Vec<LabeledStage>,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SelectionContext {
pub defaults: Vec<LabeledStage>,
pub named: Vec<NamedSelection>,
}
#[derive(Clone, Debug, PartialEq)]
pub struct SelectRequest {
pub kind: EntryKind,
pub names: Vec<String>,
pub stages: Vec<OriginStage>,
pub floor: Option<f64>,
}
impl Default for SelectRequest {
fn default() -> Self {
Self {
kind: EntryKind::Build,
names: Vec::new(),
stages: Vec::new(),
floor: None,
}
}
}
impl SelectRequest {
pub fn of_kind(kind: EntryKind) -> Self {
Self {
kind,
..Self::default()
}
}
pub fn name(
mut self,
name: impl Into<String>,
) -> Self {
self.names.push(name.into());
self
}
pub fn stage(
mut self,
stage: Stage,
origin: StageOrigin,
) -> Self {
self.stages.push(OriginStage::new(stage, origin));
self
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct ComposedQuery {
pub query: SelectQuery,
pub origins: Vec<StageOrigin>,
pub exact: Option<CatalogName>,
}
impl PresetSelection {
pub fn prefix_stage(
&self,
flags: Vec<String>,
) -> Option<OriginStage> {
if self.presets.is_empty() {
return None;
}
let names = self.presets.iter().cloned().map(Value::String).collect();
Some(OriginStage::new(
Stage::Keep(Predicate::Test {
key: "$presets".to_string(),
value: Value::Array(names),
}),
StageOrigin::Prefix(flags),
))
}
}
impl BunsenCatalogStack {
pub fn bool_axis_member(
&self,
axis: &str,
on: bool,
) -> BunsenResult<String> {
let name = self
.find(axis, &[EntryKind::Axis], LeafMatch::Exact)
.map_err(|e| query_error(format!("`{axis}`: {}", e.problem_message())))?;
let decl = self.declaration(&name).expect("found");
match decl.body() {
CatalogEntry::Axis(a) if a.axis == AxisKind::Bool => Ok(if on {
a.name.clone()
} else {
a.negate(&a.name).expect("a bool axis negates its positive")
}),
_ => Err(query_error(format!(
"`{name}` is not a bool axis: name its member as a preset"
))),
}
}
}
impl SelectRun {
pub fn empty_error(&self) -> BunsenError {
let stages: Vec<String> = self
.trace
.stages
.iter()
.filter(|s| s.dropped > 0)
.map(|s| {
format!(
"stage {} (`{}`, {}) dropped {}",
s.index, s.op, s.origin, s.dropped
)
})
.collect();
let mut message = "no build is left to choose".to_string();
if !stages.is_empty() {
message.push_str(&format!(": {}", stages.join("; ")));
}
query_error(message)
}
}
const MAX_USE_DEPTH: usize = 8;
impl SelectionContext {
pub fn named(
&self,
name: &str,
) -> Option<&NamedSelection> {
self.named
.iter()
.find(|n| n.name.eq_ignore_ascii_case(name))
}
pub fn compose(
&self,
env: &SelectEnv<'_>,
prefix: Option<OriginStage>,
request: &SelectRequest,
choosing: bool,
) -> BunsenResult<ComposedQuery> {
let mut stages: Vec<OriginStage> = prefix.into_iter().collect();
let (uses, refs): (Vec<&String>, Vec<&String>) =
request.names.iter().partition(|n| self.named(n).is_some());
let exact = match (refs.as_slice(), uses.is_empty()) {
([only], true) if request.kind == EntryKind::Build => env
.stack()
.find(only, &MEMBERSHIP_KINDS, LeafMatch::Exact)
.ok()
.filter(|n| {
env.stack()
.declaration(n)
.is_some_and(|d| d.kind() == EntryKind::Build)
}),
_ => None,
};
if exact.is_none() {
for stage in &self.defaults {
self.push(&mut stages, stage, StageOrigin::Default, 0)?;
}
}
for name in uses {
let stage = Stage::Use(name.clone()).into();
self.push(&mut stages, &stage, StageOrigin::Query, 0)?;
}
if !refs.is_empty() {
stages.push(OriginStage::new(
Stage::From(NameList(refs.into_iter().cloned().collect())),
StageOrigin::Query,
));
}
for stage in &request.stages {
self.push(&mut stages, &stage.stage, stage.origin.clone(), 0)?;
}
if !stages
.iter()
.any(|s| matches!(s.stage.stage, Stage::Order(_)))
{
stages.push(OriginStage::new(
Stage::Order(SortKeys(vec![SortKey::desc("$weight")])),
StageOrigin::Tail,
));
}
if choosing {
stages.push(OriginStage::new(Stage::Limit(1), StageOrigin::Tail));
}
let (run, origins) = stages.into_iter().map(|s| (s.stage, s.origin)).unzip();
Ok(ComposedQuery {
query: SelectQuery {
kind: request.kind,
floor: request.floor,
run,
},
origins,
exact,
})
}
fn push(
&self,
stages: &mut Vec<OriginStage>,
stage: &LabeledStage,
origin: StageOrigin,
depth: usize,
) -> BunsenResult<()> {
match &stage.stage {
Stage::Use(name) => {
for inner in &self.named_run(name, depth)?.run {
self.push(stages, inner, StageOrigin::Use(name.clone()), depth + 1)?;
}
}
Stage::Unset(label) => {
let at = stages
.iter()
.position(|s| s.stage.label.as_ref() == Some(label))
.ok_or_else(|| {
query_error(format!(
"`unset: {label}`: no earlier stage is labeled `{label}`"
))
})?;
stages.remove(at);
}
other => {
if let Some(label) = &stage.label
&& stages.iter().any(|s| s.stage.label.as_ref() == Some(label))
{
return Err(query_error(format!("two stages are labeled `{label}`")));
}
let mut stage = stage.clone();
if let Stage::Per(per) = other {
let mut inner = Vec::new();
for s in &per.run {
self.push(&mut inner, s, StageOrigin::Query, depth)?;
}
stage.stage = Stage::Per(PerStage {
group: per.group.clone(),
run: inner.into_iter().map(|s| s.stage).collect(),
});
}
stages.push(OriginStage::labeled(stage, origin));
}
}
Ok(())
}
fn named_run(
&self,
name: &str,
depth: usize,
) -> BunsenResult<&NamedSelection> {
if depth >= MAX_USE_DEPTH {
return Err(query_error(format!(
"`use: {name}` nests more than {MAX_USE_DEPTH} deep"
)));
}
self.named(name)
.ok_or_else(|| query_error(format!("`use: {name}`: no named selection `{name}`")))
}
pub fn run_composed(
&self,
env: &SelectEnv<'_>,
universe: Option<&[CatalogName]>,
composed: &ComposedQuery,
) -> BunsenResult<SelectRun> {
let mut compiled = composed.query.compile(env)?;
for (index, origin) in composed.origins.iter().enumerate() {
compiled.set_origin(index, origin.clone());
}
let kind = composed.query.kind;
let table = match universe {
Some(names) => SelectTable::of(kind, names.iter().cloned()),
None => SelectTable::universe(env, kind),
};
let run = compiled.run_traced(env, table)?;
if let Some(build) = &composed.exact
&& !run.table.rows.iter().any(|r| &r.entry.path == build)
{
let why = run
.trace
.dropped
.iter()
.find(|d| &d.entry.path == build)
.map(|d| format!(": {}", d.why))
.unwrap_or_default();
return Err(query_error(format!(
"the build `{build}` was named, but can't be chosen{why}"
)));
}
Ok(run)
}
pub fn rank(
&self,
env: &SelectEnv<'_>,
universe: Option<&[CatalogName]>,
prefix: Option<OriginStage>,
request: &SelectRequest,
) -> BunsenResult<SelectRun> {
let composed = self.compose(env, prefix, request, false)?;
self.run_composed(env, universe, &composed)
}
pub fn choose(
&self,
env: &SelectEnv<'_>,
universe: Option<&[CatalogName]>,
prefix: Option<OriginStage>,
request: &SelectRequest,
) -> BunsenResult<(Rc<SelectBuild>, SelectRun)> {
if request.kind != EntryKind::Build {
return Err(query_error(format!(
"choosing takes a build, not a `{}`; rank a query of other kinds",
request.kind
)));
}
let composed = self.compose(env, prefix, request, true)?;
let run = self.run_composed(env, universe, &composed)?;
let Some(row) = run.table.rows.first() else {
return Err(run.empty_error());
};
let build = env.build(&row.entry.path)?;
Ok((build, run))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::data::catalog::testing::fixtures;
fn leaves(run: &SelectRun) -> Vec<String> {
run.table
.names()
.iter()
.map(|n| n.leaf().to_string())
.collect()
}
fn stages(yaml: &str) -> Vec<LabeledStage> {
serde_saphyr::from_str(yaml).unwrap()
}
fn context() -> SelectionContext {
SelectionContext {
defaults: stages("[{keep: instruct}, {order: {desc: parameters}}]"),
named: vec![NamedSelection {
name: "en".into(),
description: "English speech.".into(),
run: stages("[{from: whisper}, {keep: {language: en}}]"),
}],
}
}
#[test]
fn test_defaults_apply_unless_one_build_is_named() {
let stack = fixtures::example_stack().unwrap();
let env = SelectEnv::new(&stack);
let run = context()
.rank(&env, None, None, &SelectRequest::default())
.unwrap();
assert_eq!(leaves(&run), ["qwen3-4b-thinking-2507", "qwen3-0.6b"]);
let base = SelectRequest::default().name("qwen3-0.6b-base");
let run = context().rank(&env, None, None, &base).unwrap();
assert_eq!(leaves(&run), ["qwen3-0.6b-base"]);
}
#[test]
fn test_a_named_selection_is_spliced_where_it_is_named() {
let stack = fixtures::example_stack().unwrap();
let env = SelectEnv::new(&stack);
let context = SelectionContext {
defaults: Vec::new(),
..context()
};
let request = SelectRequest::default().name("en");
let composed = context.compose(&env, None, &request, false).unwrap();
assert_eq!(
composed.origins,
[
StageOrigin::Use("en".into()),
StageOrigin::Use("en".into()),
StageOrigin::Tail
]
);
let run = context.run_composed(&env, None, &composed).unwrap();
assert_eq!(run.table.len(), 4);
let unknown = SelectRequest::default().stage(Stage::Use("fr".into()), StageOrigin::Query);
assert!(context.compose(&env, None, &unknown, false).is_err());
}
#[test]
fn test_the_prefix_holds_for_every_row_whatever_follows() {
let stack = fixtures::example_stack().unwrap();
let env = SelectEnv::new(&stack);
let off = stack.bool_axis_member("thinking", false).unwrap();
assert_eq!(off, "no-thinking");
let prefix =
|| PresetSelection::of([off.as_str()]).prefix_stage(vec!["--off thinking".into()]);
let request = SelectRequest::default()
.stage(Stage::Limit(1), StageOrigin::Flag("--limit 1".into()))
.name("qwen3");
let context = SelectionContext::default();
let run = context.rank(&env, None, prefix(), &request).unwrap();
assert_eq!(leaves(&run), ["qwen3-0.6b"]);
assert_eq!(
run.trace.stages[0].origin,
StageOrigin::Prefix(vec!["--off thinking".into()])
);
let named = SelectRequest::default().name("qwen3-4b-thinking-2507");
let err = context.rank(&env, None, prefix(), &named).unwrap_err();
assert!(
err.problem_message()
.contains("was named, but can't be chosen"),
"{err}"
);
assert!(err.problem_message().contains("no-thinking"), "{err}");
assert!(stack.bool_axis_member("task", true).is_err());
}
#[test]
fn test_choose_takes_the_first_and_an_empty_result_says_why() {
let stack = fixtures::example_stack().unwrap();
let env = SelectEnv::new(&stack);
let (build, _) = context()
.choose(&env, None, None, &SelectRequest::default())
.unwrap();
assert_eq!(build.build.name.leaf(), "qwen3-4b-thinking-2507");
let none = SelectRequest::default().name("whisper");
let err = context().choose(&env, None, None, &none).unwrap_err();
assert!(
err.problem_message()
.starts_with("no build is left to choose"),
"{err}"
);
assert!(err.problem_message().contains("defaults"), "{err}");
}
}