SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Agents and scripts: the contact commands describe their exact parameters and reply (#11949) (#11950)
austin62jake4678a048271b
diff --git a/crates/engine/src/cmd/motion.rs b/crates/engine/src/cmd/motion.rsindex fdafc4a212..44cf43dc2b 100644--- a/crates/engine/src/cmd/motion.rs+++ b/crates/engine/src/cmd/motion.rs@@ -14,7 +14,10 @@ use solidcraft_kernel::Body;use super::CommandSpec;use super::joints::{cannot_move, effective_values, joint_id, occurrence_id, place_holding, value};use crate::params::{bad, bool_, str_, vec3};-use crate::schema::motion::{FindLimitsParams, FindLimitsResult};+use crate::schema::motion::{+ ContactCheck, ContactCollision, ContactCreateParams, ContactEditParams, ContactEnableParams, ContactNoParams, ContactSetChange,+ ContactSetCreated, ContactSetEdited, ContactSetInfo, ContactSets, ContactSwitch, FindLimitsParams, FindLimitsResult,+};use crate::schema::{TypedContract, output_schema_for};use crate::{EngineError, Result, Session};@@ -39,26 +42,55 @@ macro_rules! trace_doc {};}+const CONTACT_ENABLE_CONTRACT: TypedContract<ContactEnableParams> = TypedContract::new();+const CONTACT_NONE_CONTRACT: TypedContract<ContactNoParams> = TypedContract::new();+const CONTACT_CREATE_CONTRACT: TypedContract<ContactCreateParams> = TypedContract::new();+const CONTACT_EDIT_CONTRACT: TypedContract<ContactEditParams> = TypedContract::new();+pub static COMMANDS: &[CommandSpec] = &[- CommandSpec::new("contact.enable_sets", "Enable Contact Sets", enable_sets).at("SOLID", "ASSEMBLE").icon("contact_sets").params(- "enabled?: bool (default true) — driving joints and motion studies stop where bodies in one contact set would pass through each other",- ),- CommandSpec::new("contact.enable_all", "Enable All Contact", enable_all)+ CommandSpec::new("contact.enable_sets", "Enable Contact Sets", crate::checked!("contact.enable_sets", enable_sets))+ .at("SOLID", "ASSEMBLE")+ .icon("contact_sets")+ .contract(&CONTACT_ENABLE_CONTRACT)+ .output(output_schema_for::<ContactSwitch>)+ .params(+ "enabled?: bool (default true) — driving joints and motion studies stop where bodies in one contact set would pass through each other",+ ),+ CommandSpec::new("contact.enable_all", "Enable All Contact", crate::checked!("contact.enable_all", enable_all)).at("SOLID", "ASSEMBLE").icon("contact_all")+ .contract(&CONTACT_NONE_CONTRACT)+ .output(output_schema_for::<ContactSwitch>).params("every occurrence takes part in contact (one set of all)"),- CommandSpec::new("contact.disable_all", "Disable Contact", disable_all).at("SOLID", "ASSEMBLE").icon("contact_off").params("contact off"),- CommandSpec::new("contact.create", "New Contact Set", new_set)+ CommandSpec::new("contact.disable_all", "Disable Contact", crate::checked!("contact.disable_all", disable_all))+ .at("SOLID", "ASSEMBLE")+ .icon("contact_off")+ .contract(&CONTACT_NONE_CONTRACT)+ .output(output_schema_for::<ContactSwitch>)+ .params("contact off"),+ CommandSpec::new("contact.create", "New Contact Set", crate::checked!("contact.create", new_set)).at("SOLID", "ASSEMBLE").icon("contact_new")+ .contract(&CONTACT_CREATE_CONTRACT)+ .output(output_schema_for::<ContactSetCreated>).params("occurrences: [ids or names] (two or more); name?"),- CommandSpec::new("contact.edit", "Edit Contact Set", edit_set)+ CommandSpec::new("contact.edit", "Edit Contact Set", crate::checked!("contact.edit", edit_set)).icon("edit")+ .contract(&CONTACT_EDIT_CONTRACT)+ .output(output_schema_for::<ContactSetEdited>).params("set: id|name; occurrences?; name?; suppressed?: bool; delete?: bool"),- CommandSpec::new("contact.list", "List Contact Sets", list_sets).icon("list").noundo().doc_only().params("→ sets, enabled, all"),- CommandSpec::new("contact.check", "Check Contact", check)+ CommandSpec::new("contact.list", "List Contact Sets", crate::checked!("contact.list", list_sets))+ .icon("list")+ .noundo()+ .doc_only()+ .contract(&CONTACT_NONE_CONTRACT)+ .output(output_schema_for::<ContactSets>)+ .params("→ sets, enabled, all"),+ CommandSpec::new("contact.check", "Check Contact", crate::checked!("contact.check", check)).icon("interference").noundo()+ .contract(&CONTACT_NONE_CONTRACT)+ .output(output_schema_for::<ContactCheck>).params("→ pairs in contact sets that pass through each other now"),CommandSpec::new("motion.study", "Motion Study", study).at("SOLID", "ASSEMBLE").icon("play").params("name?; study? (edit an existing one); steps? (timeline length, default 100); keys: [{joint, index?, points: [[step, value], …]}] \@@ -525,24 +557,30 @@ pub fn drive_joint_index(s: &mut Session, id: u64, q: Vec<f64>, index: usize) ->Ok(drive_with_contact(s, &[(id, q)], &[(id, index)].into_iter().collect())?.0)}+/// A contact command's reply as JSON: they build their replies from the types their output+/// schemas describe, so the two can't drift apart.+fn contact_reply(cmd: &str, reply: impl serde::Serialize) -> Result<Value> {+ serde_json::to_value(reply).map_err(|e| bad(cmd, e.to_string()))+}+fn enable_sets(s: &mut Session, p: &Value) -> Result<Value> {- let on = bool_(p, "enabled").unwrap_or(true);- s.doc_mut().assembly.contact_enabled = on;- Ok(json!({"enabled": on}))+ let enabled = bool_(p, "enabled").unwrap_or(true);+ s.doc_mut().assembly.contact_enabled = enabled;+ contact_reply("contact.enable_sets", ContactSwitch { enabled, all: None, param_warnings: Vec::new() })}fn enable_all(s: &mut Session, _p: &Value) -> Result<Value> {let a = &mut s.doc_mut().assembly;a.contact_enabled = true;a.contact_all = true;- Ok(json!({"enabled": true, "all": true}))+ contact_reply("contact.enable_all", ContactSwitch { enabled: true, all: Some(true), param_warnings: Vec::new() })}fn disable_all(s: &mut Session, _p: &Value) -> Result<Value> {let a = &mut s.doc_mut().assembly;a.contact_enabled = false;a.contact_all = false;- Ok(json!({"enabled": false}))+ contact_reply("contact.disable_all", ContactSwitch { enabled: false, all: None, param_warnings: Vec::new() })}fn new_set(s: &mut Session, p: &Value) -> Result<Value> {@@ -560,7 +598,7 @@ fn new_set(s: &mut Session, p: &Value) -> Result<Value> {let a = &mut s.doc_mut().assembly;a.contact_sets.push(ContactSet { id, name: name.clone(), occurrences: occ, suppressed: false });a.contact_enabled = true;- Ok(json!({"set": id, "name": name}))+ contact_reply(cmd, ContactSetCreated { set: id, name, param_warnings: Vec::new() })}fn set_index(s: &Session, p: &Value, cmd: &str) -> Result<usize> {@@ -582,7 +620,7 @@ fn edit_set(s: &mut Session, p: &Value) -> Result<Value> {let i = set_index(s, p, cmd)?;if bool_(p, "delete").unwrap_or(false) {s.doc_mut().assembly.contact_sets.remove(i);- return Ok(json!({"deleted": true}));+ return contact_reply(cmd, ContactSetEdited { change: ContactSetChange::Deleted { deleted: true }, param_warnings: Vec::new() });}let occ = if p.get("occurrences").is_some() { Some(occurrences(s, p, cmd)?) } else { None };if occ.as_ref().is_some_and(|o| o.len() < 2) {@@ -598,17 +636,19 @@ fn edit_set(s: &mut Session, p: &Value) -> Result<Value> {if let Some(x) = bool_(p, "suppressed") {c.suppressed = x;}- Ok(json!({"set": c.id}))+ let set = c.id;+ contact_reply(cmd, ContactSetEdited { change: ContactSetChange::Changed { set }, param_warnings: Vec::new() })}fn list_sets(s: &mut Session, _p: &Value) -> Result<Value> {let a = &s.doc.assembly;- Ok(json!({"enabled": a.contact_enabled, "all": a.contact_all, "sets": a.contact_sets}))+ let sets = a.contact_sets.iter().map(ContactSetInfo::from).collect();+ contact_reply("contact.list", ContactSets { enabled: a.contact_enabled, all: a.contact_all, sets, param_warnings: Vec::new() })}fn check(s: &mut Session, _p: &Value) -> Result<Value> {- let c = collisions(s);- Ok(json!({"collisions": c.iter().map(|(a, b, d)| json!({"a": a, "b": b, "depth_mm": d})).collect::<Vec<_>>()}))+ let collisions = collisions(s).into_iter().map(|(a, b, depth_mm)| ContactCollision { a, b, depth_mm }).collect();+ contact_reply("contact.check", ContactCheck { collisions, param_warnings: Vec::new() })}// ---- Motion studies ----diff --git a/crates/engine/src/schema/motion.rs b/crates/engine/src/schema/motion.rsindex 87ad201868..f65e042ebb 100644--- a/crates/engine/src/schema/motion.rs+++ b/crates/engine/src/schema/motion.rs@@ -7,6 +7,8 @@ use serde::de::Error as _;use serde::{Deserialize, Deserializer, Serialize};use serde_json::Value;+use super::check::whole;+/// Find where each value of a joint can go before the parts it moves touch another body. The/// design is not changed.#[derive(Debug, Deserialize, JsonSchema)]@@ -161,6 +163,244 @@ pub struct FindLimitsResult {pub param_warnings: Vec<String>,}+// ---- Contact (#11949) ----+//+// The contact handlers read their parameters from the raw JSON, so each key here reads as its+// handler reads it and fails with the handler's message. Whether the occurrences and the set+// exist stays the handler's to check.++/// The most occurrences a contact set's list may name, as `cmd/motion.rs`'s `MAX_ITEMS`.+const MAX_OCCURRENCES: usize = 10_000;++/// Turn contact sets on or off: while on, driving a joint or playing a motion study stops where+/// bodies in one contact set would pass through each other. One undo step.+#[derive(Debug, Deserialize, JsonSchema)]+#[schemars(deny_unknown_fields)]+pub struct ContactEnableParams {+ /// Whether contact sets are on. Default: true.+ #[serde(default)]+ pub enabled: Option<bool>,+}++/// No parameters: `contact.enable_all` (every occurrence takes part in contact, as one set),+/// `contact.disable_all` (contact off), `contact.list` and `contact.check` (read only).+#[derive(Debug, Deserialize, JsonSchema)]+#[schemars(deny_unknown_fields)]+pub struct ContactNoParams {}++/// Make a contact set: occurrences whose bodies may touch but not pass through each other while+/// joints move. Contact sets are turned on. One undo step.+#[derive(Debug, Deserialize, JsonSchema)]+#[schemars(deny_unknown_fields, transform = occurrences_required)]+pub struct ContactCreateParams {+ // Optional in the type and required in the schema (`occurrences_required`): left out, the+ // handler refuses it with its own message, not the check's "is required".+ #[serde(default, deserialize_with = "some_occurrences", skip_serializing_if = "Option::is_none")]+ #[schemars(with = "OccurrenceKeys")]+ pub occurrences: Option<OccurrenceKeys>,+ /// The set's name. Default: "Contact Set" and the first number no set's name has.+ #[serde(default)]+ pub name: Option<String>,+}++/// Change a contact set: its occurrences, its name, or whether it's suppressed; or delete it. One+/// undo step.+#[derive(Debug, Deserialize, JsonSchema)]+#[schemars(deny_unknown_fields, transform = set_required)]+pub struct ContactEditParams {+ // Required in the schema (`set_required`), optional in the type, as `occurrences` above.+ #[serde(default, deserialize_with = "contact_set", skip_serializing_if = "Option::is_none")]+ #[schemars(schema_with = "contact_set_schema")]+ pub set: Option<Value>,+ /// The set's new occurrences, replacing them all.+ #[serde(default, deserialize_with = "some_occurrences", skip_serializing_if = "Option::is_none")]+ #[schemars(with = "OccurrenceKeys")]+ pub occurrences: Option<OccurrenceKeys>,+ /// The set's new name; blank text keeps the name.+ #[serde(default)]+ pub name: Option<String>,+ /// Suppress the set (it stops nothing) or not.+ #[serde(default)]+ pub suppressed: Option<bool>,+ /// Delete the set instead; the other keys are then not used. Default: false.+ #[serde(default)]+ pub delete: Option<bool>,+}++/// A contact set's occurrences, as `cmd/motion.rs`'s `occurrences` reads them: a list of ids or+/// names, with its messages. An occurrence named twice counts once.+#[derive(Clone, Debug, PartialEq)]+pub struct OccurrenceKeys(pub Vec<Value>);++impl<'de> Deserialize<'de> for OccurrenceKeys {+ fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {+ match Value::deserialize(d)? {+ Value::Array(list) if list.len() > MAX_OCCURRENCES => Err(D::Error::custom(whole("too many occurrences"))),+ Value::Array(list) if list.iter().all(|v| v.is_number() || v.is_string()) => Ok(OccurrenceKeys(list)),+ Value::Array(_) => Err(D::Error::custom(whole("an occurrence must be an id or a name"))),+ _ => Err(D::Error::custom(whole("`occurrences` must list occurrences"))),+ }+ }+}++impl JsonSchema for OccurrenceKeys {+ fn schema_name() -> Cow<'static, str> {+ "OccurrenceKeys".into()+ }+ fn json_schema(_: &mut SchemaGenerator) -> Schema {+ json_schema!({+ "description": "Two or more occurrences, each by id (a number) or name; not the root.",+ "type": "array",+ "items": {"type": ["number", "string"]},+ "minItems": 2,+ "maxItems": MAX_OCCURRENCES+ })+ }+}++/// `occurrences`: given, `null` included, it must be [`OccurrenceKeys`], as the handlers read it+/// whenever the key is there.+fn some_occurrences<'de, D: Deserializer<'de>>(d: D) -> Result<Option<OccurrenceKeys>, D::Error> {+ OccurrenceKeys::deserialize(d).map(Some)+}++/// `set`: an id or a name, with the handler's message for anything else, `null` included.+fn contact_set<'de, D: Deserializer<'de>>(d: D) -> Result<Option<Value>, D::Error> {+ match Value::deserialize(d)? {+ v @ (Value::Number(_) | Value::String(_)) => Ok(Some(v)),+ _ => Err(D::Error::custom(whole("`set` must be an id or a name"))),+ }+}++fn contact_set_schema(_: &mut SchemaGenerator) -> Schema {+ json_schema!({"description": "The contact set, by id (a number) or name.", "type": ["number", "string"]})+}++/// Adds `key` to the schema's `required` list: for a key the type has optional so that the+/// handler, not the check, refuses it when it's left out.+fn require(schema: &mut Schema, key: &str) {+ match schema.get_mut("required") {+ Some(Value::Array(required)) => {+ if !required.iter().any(|k| k == key) {+ required.push(key.into());+ }+ }+ _ => {+ schema.insert("required".into(), Value::Array(vec![key.into()]));+ }+ }+}++fn occurrences_required(schema: &mut Schema) {+ require(schema, "occurrences");+}++fn set_required(schema: &mut Schema) {+ require(schema, "set");+}++/// What `contact.enable_sets`, `contact.enable_all` and `contact.disable_all` return.+#[derive(Debug, Serialize, JsonSchema)]+pub struct ContactSwitch {+ /// Whether contact is on.+ pub enabled: bool,+ /// From `contact.enable_all`: always true, every occurrence takes part.+ #[serde(skip_serializing_if = "Option::is_none")]+ pub all: Option<bool>,+ /// In the warn parameter-check mode: what the call's parameters got wrong.+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ pub param_warnings: Vec<String>,+}++/// What `contact.create` returns.+#[derive(Debug, Serialize, JsonSchema)]+pub struct ContactSetCreated {+ /// The new set's id.+ pub set: u64,+ pub name: String,+ /// In the warn parameter-check mode: what the call's parameters got wrong.+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ pub param_warnings: Vec<String>,+}++/// What `contact.edit` returns.+#[derive(Debug, Serialize, JsonSchema)]+pub struct ContactSetEdited {+ #[serde(flatten)]+ pub change: ContactSetChange,+ /// In the warn parameter-check mode: what the call's parameters got wrong.+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ pub param_warnings: Vec<String>,+}++/// What an edit did to the set.+#[derive(Debug, Serialize, JsonSchema)]+#[serde(untagged)]+pub enum ContactSetChange {+ /// The set was deleted.+ Deleted {+ /// Always true.+ deleted: bool,+ },+ /// The set was changed.+ Changed {+ /// The set's id.+ set: u64,+ },+}++/// What `contact.list` returns.+#[derive(Debug, Serialize, JsonSchema)]+pub struct ContactSets {+ /// Whether contact is on.+ pub enabled: bool,+ /// Whether every occurrence takes part, as one set, instead of `sets`.+ pub all: bool,+ pub sets: Vec<ContactSetInfo>,+ /// In the warn parameter-check mode: what the call's parameters got wrong.+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ pub param_warnings: Vec<String>,+}++/// A contact set, as the design saves it.+#[derive(Debug, Serialize, JsonSchema)]+pub struct ContactSetInfo {+ pub id: u64,+ pub name: String,+ /// Its occurrences' ids.+ pub occurrences: Vec<u64>,+ /// Present, and true, when the set is suppressed.+ #[serde(default, skip_serializing_if = "std::ops::Not::not")]+ pub suppressed: bool,+}++impl From<&solidcraft_doc::motion::ContactSet> for ContactSetInfo {+ fn from(set: &solidcraft_doc::motion::ContactSet) -> Self {+ ContactSetInfo { id: set.id, name: set.name.clone(), occurrences: set.occurrences.clone(), suppressed: set.suppressed }+ }+}++/// What `contact.check` returns.+#[derive(Debug, Serialize, JsonSchema)]+pub struct ContactCheck {+ /// The pairs of occurrences in one contact set whose bodies pass through each other now;+ /// none while contact is off.+ pub collisions: Vec<ContactCollision>,+ /// In the warn parameter-check mode: what the call's parameters got wrong.+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ pub param_warnings: Vec<String>,+}++/// Two occurrences whose bodies pass through each other.+#[derive(Debug, Serialize, JsonSchema)]+pub struct ContactCollision {+ /// The occurrences' names.+ pub a: String,+ pub b: String,+ /// How deep (mm).+ pub depth_mm: f64,+}+#[cfg(test)]#[path = "motion_tests.rs"]mod tests;diff --git a/crates/engine/src/schema/motion_tests.rs b/crates/engine/src/schema/motion_tests.rsindex e7135a8bcb..6f773263d2 100644--- a/crates/engine/src/schema/motion_tests.rs+++ b/crates/engine/src/schema/motion_tests.rs@@ -1,6 +1,9 @@use serde_json::{Value, json};-use super::{FindLimitsParams, FindLimitsResult};+use super::{+ ContactCheck, ContactCreateParams, ContactEditParams, ContactEnableParams, ContactNoParams, ContactSetCreated, ContactSetEdited, ContactSets,+ ContactSwitch, FindLimitsParams, FindLimitsResult,+};use crate::Session;use crate::schema::tests::{assert_keys, assert_strict_keeps_todays_errors, conforms};use crate::schema::{ParamCheck, input_schema_for, output_schema_for};@@ -8,17 +11,105 @@ use crate::schema::{ParamCheck, input_schema_for, output_schema_for};#[test]fn schemas_and_the_key_check_agree() {assert_keys(input_schema_for::<FindLimitsParams>(), &["against", "contact_sets", "index", "joint", "occurrences", "refine", "step"]);+ assert_keys(input_schema_for::<ContactEnableParams>(), &["enabled"]);+ assert_keys(input_schema_for::<ContactNoParams>(), &[]);+ assert_keys(input_schema_for::<ContactCreateParams>(), &["name", "occurrences"]);+ assert_keys(input_schema_for::<ContactEditParams>(), &["delete", "name", "occurrences", "set", "suppressed"]);}#[test]fn strict_keeps_todays_errors() {+ let many = vec!["A"; 10_001];assert_strict_keeps_todays_errors(&[("joint.find_limits", json!({"joint": true})),("joint.find_limits", json!({"joint": null})),("joint.find_limits", json!({"joint": "Hinge"})),+ ("contact.create", json!({})),+ ("contact.create", json!({"occurrences": null})),+ ("contact.create", json!({"occurrences": "Door"})),+ ("contact.create", json!({"occurrences": many})),+ ("contact.create", json!({"occurrences": [true, "Door"]})),+ ("contact.create", json!({"occurrences": ["Nope", "Door"]})),+ ("contact.create", json!({"occurrences": ["root", "Door"]})),+ ("contact.create", json!({"occurrences": [7]})),+ ("contact.edit", json!({})),+ ("contact.edit", json!({"set": true})),+ ("contact.edit", json!({"set": null})),+ ("contact.edit", json!({"set": "Nope", "delete": true})),]);}+/// The contact contracts say what their handlers need: `occurrences` and `set` are required in+/// the schemas, though the types leave them to the handlers' messages, and a list names two or+/// more occurrences.+#[test]+fn the_contact_schemas_take_what_the_handlers_read() {+ let create = input_schema_for::<ContactCreateParams>();+ let create = create.as_value();+ for (p, takes) in [+ (json!({"occurrences": ["Door", 7], "name": "Swing"}), true),+ (json!({"occurrences": ["Door"]}), false),+ (json!({"occurrences": [true, "Door"]}), false),+ (json!({"name": "Swing"}), false),+ ] {+ assert_eq!(conforms(create, create, &p), takes, "{p}");+ }+ let edit = input_schema_for::<ContactEditParams>();+ let edit = edit.as_value();+ for (p, takes) in [(json!({"set": 3, "suppressed": true}), true), (json!({"set": null}), false), (json!({"delete": true}), false)] {+ assert_eq!(conforms(edit, edit, &p), takes, "{p}");+ }+}++/// #11949: every contact command replies as its output schema says, in Warn without warnings:+/// sets made, listed, changed, suppressed and deleted, contact switched on and off, and a check+/// that finds two parts passing through each other. A misspelt key gets `param_warnings` in Warn,+/// since the handlers ignore unknown keys, and strict refuses it.+#[test]+fn contact_commands_reply_with_their_schemas() {+ let mut s = door();+ // A part through the door, so a check finds them.+ for (id, p) in [+ ("component.activate", json!({"component": "root"})),+ ("component.create", json!({"name": "Clash", "grounded": false})),+ ("solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [10, -3, 0]})),+ ] {+ s.execute(id, &p).unwrap_or_else(|e| panic!("{id}: {e}"));+ }+ s.param_check = ParamCheck::Warn;+ let mut run = |id: &str, p: Value, schema: schemars::Schema| {+ let r = s.execute(id, &p).unwrap_or_else(|e| panic!("{id} {p}: {e}"));+ let schema = schema.as_value();+ assert!(conforms(schema, schema, &r), "{r} doesn't match {schema}");+ assert!(r.get("param_warnings").is_none(), "{r}");+ r+ };+ run("contact.list", json!({}), output_schema_for::<ContactSets>());+ let r = run("contact.create", json!({"occurrences": ["Door", "Clash"], "name": "Swing"}), output_schema_for::<ContactSetCreated>());+ assert_eq!(r["name"], "Swing", "{r}");+ let other = run("contact.create", json!({"occurrences": ["Door", "Slide", "Door"]}), output_schema_for::<ContactSetCreated>());+ let r = run("contact.check", json!({}), output_schema_for::<ContactCheck>());+ assert!(r["collisions"].as_array().is_some_and(|c| !c.is_empty()), "{r}");+ run(+ "contact.edit",+ json!({"set": "Swing", "suppressed": true, "occurrences": ["Door", "Clash", "Block"], "name": "Swing 2"}),+ output_schema_for::<ContactSetEdited>(),+ );+ let r = run("contact.list", json!({}), output_schema_for::<ContactSets>());+ assert!(r["sets"][0]["suppressed"] == true && r["sets"][1].get("suppressed").is_none(), "{r}");+ let r = run("contact.edit", json!({"set": other["set"], "delete": true}), output_schema_for::<ContactSetEdited>());+ assert_eq!(r["deleted"], true, "{r}");+ for (id, p) in [("contact.enable_sets", json!({"enabled": false})), ("contact.enable_all", json!({})), ("contact.disable_all", json!({}))] {+ run(id, p, output_schema_for::<ContactSwitch>());+ }+ let p = json!({"enable": false});+ let r = s.execute("contact.enable_sets", &p).unwrap_or_else(|e| panic!("{p}: {e}"));+ assert!(r["param_warnings"].to_string().contains("enable"), "{r}");+ s.param_check = ParamCheck::Strict;+ let error = s.execute("contact.enable_sets", &p).err().map(|e| e.to_string()).unwrap_or_default();+ assert!(error.contains("`enable`"), "{error}");+}+/// A 100 × 4 × 50 door hinged about Z at the origin, a block in its way and a slider beside it.fn door() -> Session {let mut s = Session::default();diff --git a/crates/engine/src/schema/unconverted.txt b/crates/engine/src/schema/unconverted.txtindex 7273a6e746..7a6b5011d3 100644--- a/crates/engine/src/schema/unconverted.txt+++ b/crates/engine/src/schema/unconverted.txt@@ -39,13 +39,6 @@ component.replace_with_linkcomponent.revert_positioncomponent.unlockcomponent.update_links-contact.check-contact.create-contact.disable_all-contact.edit-contact.enable_all-contact.enable_sets-contact.listdoc.opendoc.recoverdoc.recovery_discard