SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Parameters: one meaning for value in every reply; round reported numbers (#10747) (#10812)
Dahak Buildsef939b52ebe3
diff --git a/crates/doc/src/expr.rs b/crates/doc/src/expr.rsindex bcd484d7df..d7f9b7cbdd 100644--- a/crates/doc/src/expr.rs+++ b/crates/doc/src/expr.rs@@ -304,6 +304,28 @@ pub fn value_in_unit(v: Value, unit: &str) -> f64 {}}+/// The number a reply reports for a value: millimetres for a length, degrees for an angle,+/// as-is for a unit-less or compound value. One meaning of `value` in every reply (#10747).+pub fn reported_value(v: Value) -> f64 {+ match v.kind() {+ Some(Kind::Angle) => v.v.to_degrees(),+ _ => v.v,+ }+}++/// The number a person would read for `v`: the shortest decimal that reads back after+/// rounding off the last few bits (12 significant digits), so `30 deg` stored as+/// 29.999999999999996 reports 30 and `0.1 + 0.2` reports 0.3. Only what is *reported*+/// is rounded; stored values and evaluation keep full precision (#10747).+pub fn round_reported(v: f64) -> f64 {+ if !v.is_finite() {+ return v;+ }+ // `:.11e` keeps 12 significant digits; parsing back gives the f64 nearest that decimal,+ // which serializes as the shortest form that reads back to it.+ format!("{v:.11e}").parse().unwrap_or(v)+}+fn unit(name: &str) -> Option<Value> {UNITS.iter().find(|(n, _, _)| *n == name).map(|(_, k, s)| match k {Kind::Angle => Value::angle(*s),@@ -1637,4 +1659,36 @@ mod tests {defs[2].expr = "bad +".into();assert!(eval_params(&defs, 1.0).1.contains_key("c"));}++ /// #10747: reported numbers are the shortest decimals that read back after rounding off+ /// the last few bits (12 significant digits); stored values keep full precision.+ #[test]+ fn round_reported_reads_as_a_person_would() {+ for (noisy, read) in [+ (30f64.to_radians().to_degrees(), 30.0),+ (0.1 + 0.2, 0.3),+ (3.0 * 25.4, 76.2),+ (1.2 * 25.4, 30.48),+ (29.999999999999996, 30.0),+ (0.30000000000000004, 0.3),+ (-0.1 - 0.2, -0.3),+ ] {+ assert_eq!(round_reported(noisy), read, "{noisy}");+ }+ // A number with real digits of its own keeps them up to 12 significant digits.+ assert_eq!(round_reported(1.234567890123), 1.23456789012);+ assert_eq!(round_reported(1.0000000000001), 1.0);+ // Zero and non-finite values pass through.+ assert_eq!(round_reported(0.0), 0.0);+ assert!(round_reported(f64::INFINITY).is_infinite());+ assert!(round_reported(f64::NAN).is_nan());+ }++ /// #10747: `value` means millimetres and degrees in every reply.+ #[test]+ fn reported_value_is_mm_and_degrees() {+ assert_eq!(reported_value(Value::length(50.8)), 50.8);+ assert_eq!(round_reported(reported_value(Value::angle(30f64.to_radians()))), 30.0);+ assert_eq!(reported_value(Value::num(4.0)), 4.0);+ }}diff --git a/crates/doc/src/params.rs b/crates/doc/src/params.rsindex b480999fac..a605622ea5 100644--- a/crates/doc/src/params.rs+++ b/crates/doc/src/params.rs@@ -90,7 +90,11 @@ pub struct ParamRow {pub name: String,pub expression: String,pub unit: String,+ /// Always millimetres for a length, degrees for an angle, whatever the parameter's own+ /// unit — the same meaning `value` has in every reply (#10747).pub value: Option<f64>,+ /// The value in the parameter's own `unit`, as the Parameters window shows it.+ pub display_value: Option<f64>,pub error: Option<String>,pub comment: String,/// "user", "sketch" (a dimension) or "feature".@@ -367,14 +371,20 @@ impl Document {}}let used_by = |n: &str| -> Vec<String> { users.get(n).cloned().unwrap_or_default() };- let value = |n: &str, k: Kind| vals.get(n).and_then(|v| v.to_kind(k).ok()).map(|x| if k == Kind::Angle { x.to_degrees() } else { x });+ let value = |n: &str, k: Kind| {+ vals.get(n).and_then(|v| v.to_kind(k).ok()).map(|x| if k == Kind::Angle { x.to_degrees() } else { x }).map(expr::round_reported)+ };+ // `value` is mm / degrees in every row (#10747); the parameter's own unit goes to+ // `display_value`. Both carry the number a person would read, not the float noise.+ let unified = |n: &str| vals.get(n).map(|v| expr::round_reported(expr::reported_value(*v)));let mut rows = Vec::new();for p in &self.params {rows.push(ParamRow {name: p.name.clone(),expression: p.expr.clone(),unit: p.unit.clone(),- value: self.param_display_value(&vals, &p.name),+ value: unified(&p.name),+ display_value: self.param_display_value(&vals, &p.name).map(expr::round_reported),error: errs.get(&p.name).cloned(),comment: p.comment.clone(),source: if p.model { "sketch" } else { "user" },@@ -396,6 +406,8 @@ impl Document {expression: e,unit: unit_of(k).into(),value: value(name, k),+ // A feature input's own unit is mm / deg, so its display value is its value.+ display_value: value(name, k),error: errs.get(name).cloned(),comment: self.param_comments.get(name).cloned().unwrap_or_default(),source: "feature",@@ -415,6 +427,7 @@ impl Document {expression: p.text.clone(),unit: crate::text_params::TEXT_UNIT.into(),value: None,+ display_value: None,error: None,comment: p.comment.clone(),source: "user",@@ -460,7 +473,8 @@ impl Document {Ok(())}- /// User parameters as CSV (`name,unit,expression,value,comment`).+ /// User parameters as CSV (`name,unit,expression,value,comment`). The `value` column is the+ /// number in the `unit` column, rounded for reading (#10747); import reads `expression`.pub fn params_csv(&self) -> String {let q = |s: &str| if s.contains([',', '"', '\r', '\n']) { format!("\"{}\"", s.replace('"', "\"\"")) } else { s.to_string() };let mut out = String::from("name,unit,expression,value,comment,favorite\n");@@ -470,7 +484,7 @@ impl Document {q(&r.name),q(&r.unit),q(&r.expression),- r.value.map(|v| format!("{v}")).unwrap_or_default(),+ r.display_value.or(r.value).map(|v| format!("{v}")).unwrap_or_default(),q(&r.comment),r.favorite);diff --git a/crates/engine/src/cmd/joints.rs b/crates/engine/src/cmd/joints.rsindex 7bdd392963..3648dadbd9 100644--- a/crates/engine/src/cmd/joints.rs+++ b/crates/engine/src/cmd/joints.rs@@ -6,7 +6,7 @@use std::collections::{BTreeMap, BTreeSet};use serde_json::{Value, json};-use solidcraft_doc::expr::Kind;+use solidcraft_doc::expr::{self, Kind};use solidcraft_doc::joints::cam::{self, Cam, CamProfile, Follower};use solidcraft_doc::joints::{self, Coupling, Joint, JointExprs, JointKind, JointOrigin, MotionLink, NamedOrigin, Size, Snap, XRef};use solidcraft_geom::{Aabb3, Vec3};@@ -232,7 +232,8 @@ fn sol_json(sol: &joints::Solution, p: &Value) -> Value {}/// A joint's values as `joint.list` gives them: degrees for angles, mm for distances, each with-/// its name and limits.+/// its name and limits. The numbers are rounded for reading (#10747); the joint keeps full+/// precision.pub(crate) fn named_values(j: &Joint, q: &[f64]) -> Vec<Value> {j.kind.dofs()@@ -240,8 +241,8 @@ pub(crate) fn named_values(j: &Joint, q: &[f64]) -> Vec<Value> {.enumerate().map(|(i, n)| {let (v, angle) = (q.get(i).copied().unwrap_or(0.0), j.kind.is_angle(i));- json!({"name": n, "value": if angle { v.to_degrees() } else { v }, "unit": if angle { "deg" } else { "mm" },- "limits": j.limits.get(i).copied().flatten().map(|(a, b)| if angle { [a.to_degrees(), b.to_degrees()] } else { [a, b] })})+ json!({"name": n, "value": expr::round_reported(if angle { v.to_degrees() } else { v }), "unit": if angle { "deg" } else { "mm" },+ "limits": j.limits.get(i).copied().flatten().map(|(a, b)| if angle { [expr::round_reported(a.to_degrees()), expr::round_reported(b.to_degrees())] } else { [expr::round_reported(a), expr::round_reported(b)] })})}).collect()}@@ -1103,7 +1104,7 @@ fn held_values(s: &Session, j: &Joint, requested: &[f64], driven: &[usize], r: &continue;}let angle = j.kind.is_angle(i);- let shown = |v: f64| if angle { v.to_degrees() } else { v };+ let shown = |v: f64| expr::round_reported(if angle { v.to_degrees() } else { v });let name = names.get(i).copied().unwrap_or("value");let why = if let Some(l) = s.doc.assembly.links.iter().find(|l| l.b == j.id && l.ib == i) {let coupling = match &l.coupling {diff --git a/crates/engine/src/cmd/joints_tests.rs b/crates/engine/src/cmd/joints_tests.rsindex e4614b1c99..44d38676f7 100644--- a/crates/engine/src/cmd/joints_tests.rs+++ b/crates/engine/src/cmd/joints_tests.rs@@ -2570,3 +2570,21 @@ fn driving_one_cylindrical_coordinate_preserves_the_other_expression_and_reportsassert!(s.execute("joint.drive", &json!({"joint":joint,"index":bad,"value":0})).is_err());}}++/// #10747: driving a joint to 30 reports 30, not 29.999999999999996; the joint keeps+/// full precision.+#[test]+fn driving_an_angle_reports_the_number_a_person_would_read() {+ let mut s = two_cubes();+ run(+ &mut s,+ "joint.create",+ json!({"type": "revolute", "a": {"occurrence": "A", "point": [5.0, 5.0, 10.0]}, "b": {"occurrence": "B", "point": [25.0, 5.0, 10.0]}, "name": "Turn"}),+ );+ let r = run(&mut s, "joint.drive", json!({"joint": "Turn", "value": 30}));+ assert_eq!(r["values"][0]["value"], json!(30.0), "{r}");+ assert_eq!(r["requested"][0]["value"], json!(30.0), "{r}");+ // Only what is reported is rounded: the stored value keeps full precision.+ let j = s.doc.assembly.joints.iter().find(|j| j.name == "Turn").unwrap();+ assert_ne!(j.values[0].to_degrees(), 30.0, "the stored angle keeps its bits");+}diff --git a/crates/engine/src/cmd/parameters.rs b/crates/engine/src/cmd/parameters.rsindex d8b89d0e5e..cda10522b7 100644--- a/crates/engine/src/cmd/parameters.rs+++ b/crates/engine/src/cmd/parameters.rs@@ -23,8 +23,8 @@ pub static COMMANDS: &[CommandSpec] = &[activation; driven parameters and restrictions wait for a configuration edit or activation)",),CommandSpec::new("parameters.list", "List Parameters", list).icon("list").noundo().doc_only().params(- "favorites?: bool (only favourites), filter?: all|user|sketch|feature|favorites → parameters (name, expression, unit, value in its unit, \- source, feature/input, comment, favorite, uses, used_by, error) and cycles",+ "favorites?: bool (only favourites), filter?: all|user|sketch|feature|favorites → parameters (name, expression, unit, value (mm/deg in every \+ reply), display_value (in its own unit), source, feature/input, comment, favorite, uses, used_by, error) and cycles",),CommandSpec::new("parameters.add", "Add User Parameter", add).icon("new")@@ -177,8 +177,8 @@ fn change_param(s: &mut Session, p: &Value) -> Result<Value> {if let Some(t) = s.doc.text_param(&name) {out["text"] = json!(t.text);}- out["value"] = json!(vals.get(&name).map(|v| v.v));- out["display_value"] = json!(s.doc.param_display_value(&vals, &name));+ out["value"] = json!(vals.get(&name).map(|v| expr::round_reported(expr::reported_value(*v))));+ out["display_value"] = json!(s.doc.param_display_value(&vals, &name).map(expr::round_reported));out["recomputed"] = json!(s.model.last_recomputed);out["restored"] = json!(s.model.last_restored);out["errors"] = json!(failing(s));@@ -280,7 +280,8 @@ fn change_many(s: &mut Session, changes: &Value, solved: &crate::SketchValues) -}s.settle_value_edit(solved)?;let (vals, _) = s.doc.param_values();- let values: serde_json::Map<String, Value> = list.iter().map(|(n, _)| (n.clone(), json!(vals.get(n).map(|v| v.v)))).collect();+ let values: serde_json::Map<String, Value> =+ list.iter().map(|(n, _)| (n.clone(), json!(vals.get(n).map(|v| expr::round_reported(expr::reported_value(*v)))))).collect();let mut out = json!({"changed": values, "recomputed": s.model.last_recomputed, "restored": s.model.last_restored, "errors": failing(s)});if !switched.is_empty() {out["switched"] = json!(switched);@@ -343,7 +344,7 @@ fn add(s: &mut Session, p: &Value) -> Result<Value> {return Ok(json!({"name": name, "unit": solidcraft_doc::text_params::TEXT_UNIT, "text": t.text, "value": null}));}Ok(- json!({"name": name, "unit": s.doc.param(&name).map(|x| x.unit.clone()), "value": vals.get(&name).map(|v| v.v), "display_value": s.doc.param_display_value(&vals, &name)}),+ json!({"name": name, "unit": s.doc.param(&name).map(|x| x.unit.clone()), "value": vals.get(&name).map(|v| expr::round_reported(expr::reported_value(*v))), "display_value": s.doc.param_display_value(&vals, &name).map(expr::round_reported)}),)}@@ -426,7 +427,9 @@ fn export(s: &mut Session, p: &Value) -> Result<Value> {.param_rows().into_iter().filter(|r| r.source == "user")- .map(|r| json!({"name": r.name, "expression": r.expression, "unit": r.unit, "value": r.value, "comment": r.comment, "favorite": r.favorite}))+ // The `value` field keeps the number in the parameter's own unit, as the CSV+ // column does, rounded for reading (#10747).+ .map(|r| json!({"name": r.name, "expression": r.expression, "unit": r.unit, "value": r.display_value.or(r.value), "comment": r.comment, "favorite": r.favorite})).collect();serde_json::to_string_pretty(&rows).map_err(|e| bad(cmd, e.to_string()))?}@@ -501,7 +504,7 @@ fn evaluate(s: &mut Session, p: &Value) -> Result<Value> {(None, Kind::Angle) => v.to_degrees(),(None, _) => v,};- json!({"ok": true, "value": v, "kind": k, "display_value": shown, "references": refs})+ json!({"ok": true, "value": expr::round_reported(v), "kind": k, "display_value": expr::round_reported(shown), "references": refs})}Err(err) => json!({"ok": false, "error": err.to_string().trim_start_matches("expression: ").to_string(), "references": refs}),};@@ -526,7 +529,8 @@ fn complete(s: &mut Session, p: &Value) -> Result<Value> {// parameters, then the others.rows.sort_by_key(|r| (!starts(&r.name), !r.favorite, r.source != "user"));for r in rows.into_iter().take(200) {- let v = r.value.map(|v| format!("{v:.4} {}", r.unit).trim().to_string()).unwrap_or_else(|| "error".into());+ // The completion shows the parameter's own unit, so it reads `display_value`.+ let v = r.display_value.or(r.value).map(|v| format!("{v:.4} {}", r.unit).trim().to_string()).unwrap_or_else(|| "error".into());let mut detail = format!("{} = {v}", r.expression);if let (Some(f), Some(i)) = (&r.feature, r.input) {detail.push_str(&format!(" ({f} {i})"));diff --git a/crates/engine/src/cmd/parameters_tests.rs b/crates/engine/src/cmd/parameters_tests.rsindex 04642c6bc6..e4f3b16c68 100644--- a/crates/engine/src/cmd/parameters_tests.rs+++ b/crates/engine/src/cmd/parameters_tests.rs@@ -60,7 +60,9 @@ fn width_follows_an_expression() {run(&mut s, "parameters.change", json!({"name": "len", "expression": "5", "unit": "in"}));assert!(rel(volume(&mut s), 40.0 * 63.5 * 10.0) < 1e-9);let l = run(&mut s, "parameters.list", json!({}));- assert_eq!(row(&l, "len")["value"], 5.0, "{l}");+ // `value` is mm in every reply; the own-unit number is `display_value` (#10747).+ assert_eq!(row(&l, "len")["value"], 127.0, "{l}");+ assert_eq!(row(&l, "len")["display_value"], 5.0, "{l}");assert_eq!(row(&l, "len")["unit"], "in");// A failing parameter fails the features using it, with its error.let e = err(&mut s, "parameters.change", json!({"name": "len", "expression": "5 deg"}));@@ -389,7 +391,8 @@ fn text_parameter_imports_accept_mixed_case_units() {assert_eq!(label["comment"], "quoted label");assert!(label["value"].is_null());assert_eq!(row(&list, "width")["unit"], "in");- assert_eq!(row(&list, "width")["value"], 1.0);+ assert_eq!(row(&list, "width")["value"], 25.4);+ assert_eq!(row(&list, "width")["display_value"], 1.0);assert_eq!(s.doc.param_values().0["width"].v, 25.4);}// Export still uses the canonical marker and round-trips the unquoted text.@@ -933,8 +936,8 @@ fn a_parameter_added_without_a_unit_takes_the_design_unit() {let r = run(s, "parameters.add", p);(r["unit"].as_str().unwrap_or("?").to_string(), r["value"].as_f64().unwrap_or(f64::NAN), r["display_value"].as_f64().unwrap_or(f64::NAN))};- let close = |got: (String, f64, f64), unit: &str, mm: f64, shown: f64| {- assert!(got.0 == unit && rel(got.1, mm) < 1e-9 && rel(got.2, shown) < 1e-9, "{got:?}, expected {unit} {mm} mm ({shown})");+ let close = |got: (String, f64, f64), unit: &str, val: f64, shown: f64| {+ assert!(got.0 == unit && rel(got.1, val) < 1e-9 && rel(got.2, shown) < 1e-9, "{got:?}, expected {unit} {val} ({shown})");};// A millimetre design is as it was.let mut s = Session::default();@@ -951,8 +954,8 @@ fn a_parameter_added_without_a_unit_takes_the_design_unit() {// One that refers to another parameter: its bare number is an inch too.close(added(&mut s, json!({"name": "more", "expression": "v + 1"})), "in", 533.4, 21.0);close(added(&mut s, json!({"name": "half", "expression": "v / 2"})), "in", 254.0, 10.0);- // An angle stays in degrees, a unit-less count stays unit-less.- close(added(&mut s, json!({"name": "turn", "expression": "30 deg"})), "deg", 30f64.to_radians(), 30.0);+ // An angle reports degrees like every other reply, a unit-less count stays unit-less.+ close(added(&mut s, json!({"name": "turn", "expression": "30 deg"})), "deg", 30.0, 30.0);close(added(&mut s, json!({"name": "n", "expression": "4", "unit": ""})), "", 4.0, 4.0);close(added(&mut s, json!({"name": "twice", "expression": "n * 2"})), "", 8.0, 8.0);// parameters.change and parameters.import make a new parameter the same way.@@ -1195,3 +1198,51 @@ fn a_configuration_row_that_shrinks_a_dimensioned_line_to_a_point_is_refused() {run(&mut s, "config.activate", json!({"row": "Default"}));assert!((far_x(&s, feature) - 30.0).abs() < 1e-6);}++/// #10747: `value` means millimetres (and degrees) in every reply — add, change and list —+/// with the parameter's own unit in `display_value`. Reported numbers carry no float noise;+/// stored values keep full precision.+#[test]+fn value_means_the_same_unit_in_every_reply() {+ let mut s = Session::default();+ run(&mut s, "document.units", json!({"units": "in"}));+ let a = run(&mut s, "parameters.add", json!({"name": "L", "expression": "2"}));+ assert_eq!((a["value"].as_f64(), a["display_value"].as_f64()), (Some(50.8), Some(2.0)), "{a}");+ // The change reply is rounded too: 3 in is 76.2, not 76.19999999999999.+ let c = run(&mut s, "parameters.change", json!({"name": "L", "expression": "3"}));+ assert_eq!((c["value"].as_f64(), c["display_value"].as_f64()), (Some(76.2), Some(3.0)), "{c}");+ run(&mut s, "parameters.add", json!({"name": "d1", "expression": "L"}));+ run(&mut s, "parameters.add", json!({"name": "d2", "expression": "1 in"}));+ let l = run(&mut s, "parameters.list", json!({}));+ // Every row's `value` is mm, whatever the parameter's own unit (#10747).+ for (name, mm) in [("L", 76.2), ("d1", 76.2), ("d2", 25.4)] {+ assert_eq!(row(&l, name)["value"], mm, "{name}: {l}");+ }+ assert_eq!(row(&l, "L")["display_value"], 3.0, "{l}");+ assert_eq!(row(&l, "d2")["display_value"], 1.0, "{l}");+ // An angle reports degrees like every other reply, without the noise.+ let a = run(&mut s, "parameters.add", json!({"name": "ang", "expression": "30 deg"}));+ assert_eq!((a["value"].as_f64(), a["display_value"].as_f64()), (Some(30.0), Some(30.0)), "{a}");+ // Only what is reported is rounded: the stored value keeps full precision — the raw+ // own-unit conversion still says 29.999999999999996.+ let (vals, _) = s.doc.param_values();+ assert_eq!(s.doc.param_display_value(&vals, "ang"), Some(29.999999999999996), "the stored angle keeps its bits");+}++/// #10747: exports carry the numbers a person would read, not float noise. The `value`+/// column keeps the number in the parameter's own unit, as it always did.+#[test]+fn exports_round_reported_numbers() {+ let mut s = Session::default();+ run(&mut s, "parameters.add", json!({"name": "ang", "expression": "30 deg"}));+ run(&mut s, "parameters.add", json!({"name": "w", "expression": "1.2 in"}));+ run(&mut s, "parameters.add", json!({"name": "s", "expression": "0.1 + 0.2"}));+ let csv = run(&mut s, "parameters.export", json!({"format": "csv"}))["text"].as_str().unwrap_or_default().to_string();+ assert!(csv.contains("ang,deg,30 deg,30,,false"), "{csv}");+ assert!(csv.contains("w,mm,1.2 in,30.48,,false"), "{csv}");+ assert!(csv.contains("s,mm,0.1 + 0.2,0.3,,false"), "{csv}");+ let json_text = run(&mut s, "parameters.export", json!({"format": "json"}))["text"].as_str().unwrap_or_default().to_string();+ let rows: Vec<Value> = serde_json::from_str(&json_text).unwrap_or_default();+ let vals: Vec<f64> = rows.iter().filter_map(|r| r["value"].as_f64()).collect();+ assert_eq!(vals, vec![30.0, 30.48, 0.3], "{json_text}");+}diff --git a/crates/ui-egui/src/params_dialog.rs b/crates/ui-egui/src/params_dialog.rsindex 44df7a69fc..1b2439e61a 100644--- a/crates/ui-egui/src/params_dialog.rs+++ b/crates/ui-egui/src/params_dialog.rs@@ -151,7 +151,9 @@ fn rows(app: &mut SolveApp) -> Vec<Row> {Row {expression: s(r, "expression"),unit: s(r, "unit"),- value: r.get("value").and_then(Value::as_f64),+ // The dialog shows the parameter's own unit, so it reads `display_value`+ // (`value` is mm / degrees in every reply, #10747).+ value: r.get("display_value").and_then(Value::as_f64).or_else(|| r.get("value").and_then(Value::as_f64)),error: r.get("error").and_then(Value::as_str).map(str::to_string),comment: s(r, "comment"),favorite: r.get("favorite").and_then(Value::as_bool).unwrap_or(false),diff --git a/crates/ui-egui/src/shortcut_box.rs b/crates/ui-egui/src/shortcut_box.rsindex d2276f0141..b28584ce1d 100644--- a/crates/ui-egui/src/shortcut_box.rs+++ b/crates/ui-egui/src/shortcut_box.rs@@ -257,7 +257,7 @@ fn design_rows(app: &mut SolveApp, query: &str) -> Vec<DesignRow> {.iter().take(64).find_map(|name| values.get(name.as_str()))- .map(|p| p.value.filter(|v| v.is_finite()).map_or_else(|| bounded(&p.expression), |v| format!("{v} {}", p.unit)))+ .map(|p| p.display_value.or(p.value).filter(|v| v.is_finite()).map_or_else(|| bounded(&p.expression), |v| format!("{v} {}", p.unit))).unwrap_or_default();rows.push(DesignRow {label: bounded(&feature.name),@@ -268,7 +268,7 @@ fn design_rows(app: &mut SolveApp, query: &str) -> Vec<DesignRow> {}let icon = solidcraft_engine::find_command("parameters.change").map_or("", |c| c.icon);for p in params.iter().filter(|p| p.source == "user").take(10_000) {- let value = p.value.filter(|v| v.is_finite()).map_or_else(|| bounded(&p.expression), |v| format!("{v} {}", p.unit));+ let value = p.display_value.or(p.value).filter(|v| v.is_finite()).map_or_else(|| bounded(&p.expression), |v| format!("{v} {}", p.unit));rows.push(DesignRow {label: bounded(&p.name),detail: format!("{} · {value}", crate::i18n::tr("search.parameter")),