diff --git a/crates/engine/src/cmd/component.rs b/crates/engine/src/cmd/component.rs
index 3225f6a458..70926ba17d 100644
--- a/crates/engine/src/cmd/component.rs
+++ b/crates/engine/src/cmd/component.rs
@@ -13,12 +13,23 @@ use solidcraft_doc::{Feature, FeatureKind, Mat, Occurrence};
 use super::CommandSpec;
 use crate::params::{bad, bool_, str_, string_list, vec3};
 use crate::schema::component::{
-    EditInPlaceParams, EditInPlaceResult, FinishEditParams, FinishEditResult, MoveFeaturesParams, MoveFeaturesResult, MoveSketchesToPartsParams,
-    MoveSketchesToPartsResult, OccurrenceAlignParams, OccurrenceAlignResult, ReparentItemsParams, ReparentItemsResult,
+    ActivateParams, ActivateResult, ChildEntry, CompactPlacement, ComponentNode, CreateParams, CreateResult, DeleteParams, DeleteResult,
+    EditInPlaceParams, EditInPlaceResult, FinishEditParams, FinishEditResult, FromBodiesParams, FromBodiesResult, ListParams, ListResult,
+    MoveFeaturesParams, MoveFeaturesResult, MoveSketchesToPartsParams, MoveSketchesToPartsResult, NamesOrCount, OccurrenceAlignParams,
+    OccurrenceAlignResult, PlacementEntry, PlacementInfo, PropertiesParams, PropertiesResult, RenameParams, RenameResult, ReparentItemsParams,
+    ReparentItemsResult, UnlockParams, UnlockResult,
 };
 use crate::schema::{TypedContract, output_schema_for};
 use crate::{Result, Session};
 
+const ACTIVATE_CONTRACT: TypedContract<ActivateParams> = TypedContract::new();
+const CREATE_CONTRACT: TypedContract<CreateParams> = TypedContract::new();
+const DELETE_CONTRACT: TypedContract<DeleteParams> = TypedContract::new();
+const FROM_BODIES_CONTRACT: TypedContract<FromBodiesParams> = TypedContract::new();
+const LIST_CONTRACT: TypedContract<ListParams> = TypedContract::new();
+const PROPERTIES_CONTRACT: TypedContract<PropertiesParams> = TypedContract::new();
+const RENAME_CONTRACT: TypedContract<RenameParams> = TypedContract::new();
+const UNLOCK_CONTRACT: TypedContract<UnlockParams> = TypedContract::new();
 const EDIT_IN_PLACE_CONTRACT: TypedContract<EditInPlaceParams> = TypedContract::new();
 const FINISH_EDIT_CONTRACT: TypedContract<FinishEditParams> = TypedContract::new();
 const MOVE_FEATURES_CONTRACT: TypedContract<MoveFeaturesParams> = TypedContract::new();
@@ -67,14 +78,23 @@ pub static COMMANDS: &[CommandSpec] = &[
     CommandSpec::new("component.show_history", "Show Component History", show_history)
         .icon("eye").doc_only()
         .params("component: id or name; puts a component's features back in the History bar after Hide Component History (#10393)"),
-    CommandSpec::new("component.create", "New Component", new_component)
+    CommandSpec::new("component.create", "New Component", crate::checked!("component.create", new_component))
         .at("SOLID", "ASSEMBLE")
         .icon("component")
+        .contract(&CREATE_CONTRACT)
+        .output(output_schema_for::<CreateResult>)
         .params("name?, parent?: component id or name (default: the active one); parent_path?: exact parent placement; activate?: bool (default true); grounded?: bool (default: true for the design's first part, false otherwise)"),
-    CommandSpec::new("component.from_bodies", "Create Components from Bodies", from_bodies)
+    CommandSpec::new("component.from_bodies", "Create Components from Bodies", crate::checked!("component.from_bodies", from_bodies))
         .icon("component")
+        .contract(&FROM_BODIES_CONTRACT)
+        .output(output_schema_for::<FromBodiesResult>)
         .params("bodies: [names] → one new component per body, named after it"),
-    CommandSpec::new("component.activate", "Activate Component", activate).icon("activate").noundo().params("component: id or name (0 or \"root\" for the design); occurrence?, path?: exact placement used to author shared geometry"),
+    CommandSpec::new("component.activate", "Activate Component", crate::checked!("component.activate", activate))
+        .icon("activate")
+        .noundo()
+        .contract(&ACTIVATE_CONTRACT)
+        .output(output_schema_for::<ActivateResult>)
+        .params("component: id or name (0 or \"root\" for the design); occurrence?, path?: exact placement used to author shared geometry"),
     CommandSpec::new("component.edit_in_place", "Edit in Place", crate::checked!("component.edit_in_place", edit_in_place))
         .icon("edit")
         .noundo()
@@ -99,22 +119,41 @@ pub static COMMANDS: &[CommandSpec] = &[
              fails while the design has unsaved changes (run file.save first) or something is open in it; asked during the agent's \
              turn it finishes once the turn ends (queued: true); elsewhere nothing changes",
         ),
-    CommandSpec::new("component.list", "List Components", list).icon("list").noundo().params(
-        "compact?: bool (counts of bodies, features, sketches and construction planes instead of their names; occurrences leave out \
-         identity transforms; children as occurrence ids); bodies?: bool (with compact: body names, not their count)",
-    ),
-    CommandSpec::new("component.properties", "Component Physical Properties", properties::component)
+    CommandSpec::new("component.list", "List Components", crate::checked!("component.list", list))
+        .icon("list")
+        .noundo()
+        .contract(&LIST_CONTRACT)
+        .output(output_schema_for::<ListResult>)
+        .params(
+            "compact?: bool (counts of bodies, features, sketches and construction planes instead of their names; occurrences leave out \
+             identity transforms; children as occurrence ids); bodies?: bool (with compact: body names, not their count)",
+        ),
+    CommandSpec::new("component.properties", "Component Physical Properties", crate::checked!("component.properties", properties::component))
         .icon("measure").noundo()
+        .contract(&PROPERTIES_CONTRACT)
+        .output(output_schema_for::<PropertiesResult>)
         .params("component?: id or name (default active); descendants?: bool (default true); about?: [x, y, z] (mm). Measures the first placement, or all placements for root, including pending moves; material-aware mass and center of mass in world coordinates; volume, density, mass, center of mass and inertia_g_mm2 (the inertia tensor about the body's center of mass, world axes, from its tessellation) only for closed, consistently oriented bodies; total.open_bodies_skipped counts open bodies excluded from volume/mass totals; total.first_moment_g_mm (mass × center of mass), inertia_g_mm2 about the total center of mass, principal_moments_g_mm2 (smallest first) and principal_axes (unit, right-handed); with about, total.inertia_about {point, inertia_g_mm2}"),
     CommandSpec::new("occurrence.properties", "Occurrence Physical Properties", properties::occurrence)
         .icon("measure").noundo()
         .params("occurrence: id or name; path?: [occurrence ids] (required if nested under multiple instances); descendants?: bool (default true); about?: [x, y, z] (mm). Physical properties of this placement in world coordinates, including pending moves; volume, density, mass, center of mass and inertia_g_mm2 only for closed, consistently oriented bodies; total.open_bodies_skipped counts open bodies excluded from volume/mass totals; total inertia as in component.properties"),
-    CommandSpec::new("component.rename", "Rename Component", rename).icon("rename").params("component, name"),
-    CommandSpec::new("component.delete", "Delete Component", delete).icon("delete").params("component: deletes it, its subcomponents, occurrences and features"),
-    CommandSpec::new("component.unlock", "Unlock Contents", unlock).icon("rigid_group").params(
-        "component: removes the rigid joints that hold its contents together (an imported assembly's rigid group), so its parts \
-         move and take joints one by one → joints (the ids removed)",
-    ),
+    CommandSpec::new("component.rename", "Rename Component", crate::checked!("component.rename", rename))
+        .icon("rename")
+        .contract(&RENAME_CONTRACT)
+        .output(output_schema_for::<RenameResult>)
+        .params("component, name"),
+    CommandSpec::new("component.delete", "Delete Component", crate::checked!("component.delete", delete))
+        .icon("delete")
+        .contract(&DELETE_CONTRACT)
+        .output(output_schema_for::<DeleteResult>)
+        .params("component: deletes it, its subcomponents, occurrences and features"),
+    CommandSpec::new("component.unlock", "Unlock Contents", crate::checked!("component.unlock", unlock))
+        .icon("rigid_group")
+        .contract(&UNLOCK_CONTRACT)
+        .output(output_schema_for::<UnlockResult>)
+        .params(
+            "component: removes the rigid joints that hold its contents together (an imported assembly's rigid group), so its parts \
+             move and take joints one by one → joints (the ids removed)",
+        ),
     CommandSpec::new("component.move_bodies", "Move Bodies to Component", move_bodies).icon("move").params(
         "bodies: [names], component; component_path?: its placement to place them by (default: its only one, else the active \
          one; a component placed more than once gets them in every instance); from_path?: the placement of their component they \
@@ -203,6 +242,11 @@ pub static COMMANDS: &[CommandSpec] = &[
 
 const ALIGN_CONTRACT: TypedContract<OccurrenceAlignParams> = TypedContract::new();
 
+/// A typed reply as the JSON a handler returns.
+pub(super) fn reply<T: serde::Serialize>(value: T) -> Result<Value> {
+    serde_json::to_value(value).map_err(|e| crate::EngineError::Other(e.to_string()))
+}
+
 fn key(v: Option<&Value>) -> Option<String> {
     match v {
         Some(Value::Number(n)) => Some(n.to_string()),
@@ -288,7 +332,14 @@ pub(super) fn new_component(s: &mut Session, p: &Value) -> Result<Value> {
     }
     let name = s.doc.components.iter().find(|c| c.id == id).map(|c| c.name.clone()).unwrap_or_default();
     let occ = s.doc.occurrence_of(id);
-    Ok(json!({"component": id, "name": name, "parent": parent, "occurrence": occ.map(|o| o.id), "grounded": occ.is_some_and(|o| o.grounded)}))
+    reply(CreateResult {
+        component: id,
+        name,
+        parent,
+        occurrence: occ.map(|o| o.id),
+        grounded: occ.is_some_and(|o| o.grounded),
+        param_warnings: Vec::new(),
+    })
 }
 
 fn from_bodies(s: &mut Session, p: &Value) -> Result<Value> {
@@ -334,7 +385,7 @@ fn activate(s: &mut Session, p: &Value) -> Result<Value> {
     s.active_component = id;
     s.active_occurrence_path = path;
     s.revision += 1;
-    Ok(json!({ "active": id }))
+    reply(ActivateResult { active: id, param_warnings: Vec::new() })
 }
 
 fn list(s: &mut Session, p: &Value) -> Result<Value> {
@@ -342,17 +393,20 @@ fn list(s: &mut Session, p: &Value) -> Result<Value> {
     let doc = &s.doc;
     // Compact: what a large assembly needs to be found around in, without every name and matrix.
     let compact = bool_(p, "compact").unwrap_or(false);
-    let names = |v: Vec<&str>| if compact { json!(v.len()) } else { json!(v) };
+    let names = |v: Vec<&str>| if compact { NamesOrCount::Count(v.len()) } else { NamesOrCount::Names(v.into_iter().map(str::to_string).collect()) };
     let body_names = !compact || bool_(p, "bodies").unwrap_or(false);
     let placement = |o: &Occurrence| {
         if !compact {
-            return json!(o);
+            return PlacementEntry::Full(PlacementInfo::from(o));
         }
-        let mut v = json!({"id": o.id, "name": o.name, "parent": o.parent, "grounded": o.grounded});
-        if o.transform.iter().flatten().zip(solidcraft_doc::IDENTITY.iter().flatten()).any(|(a, b)| (a - b).abs() > 1e-12) {
-            v["transform"] = json!(o.transform);
-        }
-        v
+        let moved = o.transform.iter().flatten().zip(solidcraft_doc::IDENTITY.iter().flatten()).any(|(a, b)| (a - b).abs() > 1e-12);
+        PlacementEntry::Compact(CompactPlacement {
+            id: o.id,
+            name: o.name.clone(),
+            parent: o.parent,
+            grounded: o.grounded,
+            transform: moved.then_some(o.transform),
+        })
     };
     // Each component's bodies, features, occurrences and children, grouped once rather than
     // searched for every component (thousands of each in a design with many components).
@@ -376,17 +430,37 @@ fn list(s: &mut Session, p: &Value) -> Result<Value> {
         let sketches = named(|k| matches!(k, FeatureKind::Sketch { .. }));
         let construction = named(|k| matches!(k, FeatureKind::ConstructionPlane { .. }));
         let features = named(|k| !matches!(k, FeatureKind::Sketch { .. } | FeatureKind::ConstructionPlane { .. }));
-        let occurrences: Vec<Value> = occurrences_of.get(&id).into_iter().flatten().map(|o| placement(o)).collect();
-        let children: Vec<Value> = children_of.get(&id).into_iter().flatten().map(|o| if compact { json!(o.id) } else { json!(o) }).collect();
-        let bodies = if body_names { json!(bodies) } else { json!(bodies.len()) };
-        json!({"id": id, "name": name, "parent": parent, "bodies": bodies, "features": names(features), "sketches": names(sketches),
-            "construction": names(construction), "occurrences": occurrences, "children": children})
+        let occurrences: Vec<PlacementEntry> = occurrences_of.get(&id).into_iter().flatten().map(|o| placement(o)).collect();
+        let children: Vec<ChildEntry> = children_of
+            .get(&id)
+            .into_iter()
+            .flatten()
+            .map(|o| if compact { ChildEntry::Id(o.id) } else { ChildEntry::Full(PlacementInfo::from(*o)) })
+            .collect();
+        let bodies =
+            if body_names { NamesOrCount::Names(bodies.into_iter().map(str::to_string).collect()) } else { NamesOrCount::Count(bodies.len()) };
+        ComponentNode {
+            id,
+            name: name.to_string(),
+            parent,
+            bodies,
+            features: names(features),
+            sketches: names(sketches),
+            construction: names(construction),
+            occurrences,
+            children,
+        }
     };
     let mut out = vec![node(0, &doc.name, None)];
     for c in &doc.components {
         out.push(node(c.id, &c.name, Some(c.parent)));
     }
-    Ok(json!({"active": s.active_component, "components": out, "pending_moves": s.pending_moves.keys().collect::<Vec<_>>()}))
+    reply(ListResult {
+        active: s.active_component,
+        components: out,
+        pending_moves: s.pending_moves.keys().copied().collect(),
+        param_warnings: Vec::new(),
+    })
 }
 
 fn rename(s: &mut Session, p: &Value) -> Result<Value> {
@@ -411,7 +485,7 @@ fn rename(s: &mut Session, p: &Value) -> Result<Value> {
         // A sketch projecting a body of one of those placements keeps it.
         super::sketch_project::follow_placed_renames(d, &st, &placed, None);
     }
-    Ok(json!({"component": id, "name": name}))
+    reply(RenameResult { component: id, name: name.to_string(), param_warnings: Vec::new() })
 }
 
 fn delete(s: &mut Session, p: &Value) -> Result<Value> {
@@ -428,7 +502,7 @@ fn delete(s: &mut Session, p: &Value) -> Result<Value> {
     if gone.contains(&s.active_component) {
         s.active_component = 0;
     }
-    Ok(json!({"deleted": gone, "features": removed.features}))
+    reply(DeleteResult { deleted: gone, features: removed.features, param_warnings: Vec::new() })
 }
 
 fn unlock(s: &mut Session, p: &Value) -> Result<Value> {
@@ -448,7 +522,7 @@ fn unlock(s: &mut Session, p: &Value) -> Result<Value> {
     }
     doc.assembly.links.retain(|l| !gone.contains(&l.a) && !gone.contains(&l.b));
     s.visibility.hidden_joints.retain(|h| !gone.contains(h));
-    Ok(json!({"component": id, "joints": gone}))
+    reply(UnlockResult { component: id, joints: gone, param_warnings: Vec::new() })
 }
 
 fn move_bodies(s: &mut Session, p: &Value) -> Result<Value> {
diff --git a/crates/engine/src/cmd/component_properties.rs b/crates/engine/src/cmd/component_properties.rs
index 42fd9bc244..1ae78dca89 100644
--- a/crates/engine/src/cmd/component_properties.rs
+++ b/crates/engine/src/cmd/component_properties.rs
@@ -9,6 +9,7 @@ use solidcraft_geom::Aabb3;
 use solidcraft_geom::inertia::{self, Tensor3};
 
 use crate::params::bad;
+use crate::schema::component::{BodyProperties, BoundingBox, InertiaAbout, PhysicalProperties, PropertiesResult, TotalProperties};
 use crate::{Result, Session};
 
 fn descendants(p: &Value, cmd: &str) -> Result<bool> {
@@ -84,10 +85,8 @@ pub(super) fn component(s: &mut Session, p: &Value) -> Result<Value> {
     } else {
         doc.components.iter().find(|c| c.id == id).map(|c| c.name.clone()).ok_or_else(|| bad(cmd, "no active component"))?
     };
-    let mut out = properties(s, &doc, &path, descendants(p, cmd)?, about(p, cmd)?, cmd)?;
-    out["component"] = json!(id);
-    out["name"] = json!(name);
-    Ok(out)
+    let properties = measure(s, &doc, &path, descendants(p, cmd)?, about(p, cmd)?, cmd)?;
+    super::reply(PropertiesResult { component: id, name, properties, param_warnings: Vec::new() })
 }
 
 pub(super) fn occurrence(s: &mut Session, p: &Value) -> Result<Value> {
@@ -200,7 +199,12 @@ fn measure_placed(body: &solidcraft_doc::ModelBody, transform: Mat) -> Result<Pl
     })
 }
 
+/// [`measure`] as the JSON `occurrence.properties` adds its own keys to.
 fn properties(s: &Session, doc: &Document, selected: &[u64], descendants: bool, about: Option<Vec3>, cmd: &str) -> Result<Value> {
+    super::reply(measure(s, doc, selected, descendants, about, cmd)?)
+}
+
+fn measure(s: &Session, doc: &Document, selected: &[u64], descendants: bool, about: Option<Vec3>, cmd: &str) -> Result<PhysicalProperties> {
     let state = s.model.state();
     let mut bodies = Vec::new();
     let (mut volume, mut area, mut mass) = (0.0, 0.0, 0.0);
@@ -292,13 +296,20 @@ fn properties(s: &Session, doc: &Document, selected: &[u64], descendants: bool,
             faces += measured.faces;
             edges += measured.edges;
             vertices += measured.vertices;
-            bodies.push(json!({"name": body.name, "component": component, "path": path,
-                "material": doc.body_material(&body.name),
-                "closed": closed, "density_g_cm3": closed.then_some(density),
-                "mass_g": closed.then_some(body_mass), "volume_mm3": closed.then_some(measured.volume),
-                "area_mm2": measured.area, "center_of_mass": closed.then_some(measured.centroid),
-                "inertia_g_mm2": body_inertia,
-                "bbox": {"min": measured.bbox.min, "max": measured.bbox.max}}));
+            bodies.push(BodyProperties {
+                name: body.name.to_string(),
+                component,
+                path: path.clone(),
+                material: doc.body_material(&body.name),
+                closed,
+                density_g_cm3: closed.then_some(density),
+                mass_g: closed.then_some(body_mass),
+                volume_mm3: closed.then_some(measured.volume),
+                area_mm2: measured.area,
+                center_of_mass: closed.then_some(measured.centroid),
+                inertia_g_mm2: body_inertia,
+                bbox: BoundingBox { min: measured.bbox.min, max: measured.bbox.max },
+            });
         }
     }
     if let Some(w) = &watch {
@@ -321,19 +332,36 @@ fn properties(s: &Session, doc: &Document, selected: &[u64], descendants: bool,
     });
     let at_centre = at_centre.filter(|i| i.iter().flatten().all(|x| x.is_finite()));
     let principal = at_centre.and_then(|i| inertia::principal(&i, EQUAL_MOMENTS));
-    let bbox = if bodies.is_empty() { Value::Null } else { json!({"min": bounds.min, "max": bounds.max}) };
-    let mut out = json!({"path": selected, "coordinate_frame": "world", "descendants": descendants,
-        "placement_count": placement_count, "body_count": bodies.len(), "bodies": bodies,
-        "total": {"open_bodies_skipped": skipped, "volume_mm3": volume, "area_mm2": area, "mass_g": mass,
-            "center_of_mass": centroid, "first_moment_g_mm": moment, "inertia_g_mm2": at_centre,
-            "principal_moments_g_mm2": principal.map(|(moments, _)| moments), "principal_axes": principal.map(|(_, axes)| axes),
-            "bbox": bbox, "faces": faces, "edges": edges, "vertices": vertices}});
-    if let Some(point) = about {
+    let bbox = (!bodies.is_empty()).then_some(BoundingBox { min: bounds.min, max: bounds.max });
+    let inertia_about = about.map(|point| {
         let shifted =
             centroid.zip(at_centre).map(|(c, i)| inertia::shifted(&i, mass, point - c)).filter(|i| i.iter().flatten().all(|x| x.is_finite()));
-        out["total"]["inertia_about"] = json!({"point": point, "inertia_g_mm2": shifted});
-    }
-    Ok(out)
+        InertiaAbout { point, inertia_g_mm2: shifted }
+    });
+    Ok(PhysicalProperties {
+        path: selected.to_vec(),
+        coordinate_frame: "world".to_string(),
+        descendants,
+        placement_count,
+        body_count: bodies.len(),
+        bodies,
+        total: TotalProperties {
+            open_bodies_skipped: skipped,
+            volume_mm3: volume,
+            area_mm2: area,
+            mass_g: mass,
+            center_of_mass: centroid,
+            first_moment_g_mm: moment,
+            inertia_g_mm2: at_centre,
+            principal_moments_g_mm2: principal.map(|(moments, _)| moments),
+            principal_axes: principal.map(|(_, axes)| axes),
+            bbox,
+            faces,
+            edges,
+            vertices,
+            inertia_about,
+        },
+    })
 }
 
 /// The tessellating work a properties command did on this thread, for tests: placed copies
diff --git a/crates/engine/src/cmd/component_transfer.rs b/crates/engine/src/cmd/component_transfer.rs
index 8d742cd053..e4dc022460 100644
--- a/crates/engine/src/cmd/component_transfer.rs
+++ b/crates/engine/src/cmd/component_transfer.rs
@@ -1,5 +1,6 @@
 //! Atomic timeline ownership changes, preserving the selected world geometry.
 use super::*;
+use crate::schema::component::{BodyComponent, FromBodiesResult};
 use solidcraft_doc::BodyName;
 use std::collections::{BTreeMap, BTreeSet};
 
@@ -128,10 +129,10 @@ pub(super) fn from_bodies(s: &mut Session, p: &Value) -> Result<Value> {
     for (name, component) in bodies.into_iter().zip(targets) {
         let feature = transfer(&mut scratch, &name, component, &frames, cmd)?;
         features.push(feature);
-        made.push(json!({"component":component,"body":name,"feature":feature}));
+        made.push(BodyComponent { component, body: name, feature });
     }
     finish(s, &mut scratch, &features, cmd)?;
-    Ok(json!({"components":made}))
+    super::reply(FromBodiesResult { components: made, param_warnings: Vec::new() })
 }
 
 /// A placement path parameter (`component_path`: the target's placement to place by,
diff --git a/crates/engine/src/schema/component.rs b/crates/engine/src/schema/component.rs
index c84878fea3..28905a778f 100644
--- a/crates/engine/src/schema/component.rs
+++ b/crates/engine/src/schema/component.rs
@@ -1,12 +1,17 @@
 //! Contracts and result types for the commands in `cmd/component.rs`.
 
 use std::borrow::Cow;
+use std::collections::BTreeSet;
 
 use schemars::{JsonSchema, Schema, SchemaGenerator, json_schema};
 use serde::de::Error as _;
 use serde::{Deserialize, Deserializer, Serialize};
 use serde_json::{Value, json};
+use solidcore_record::Vec3;
+use solidcraft_doc::Occurrence;
 
+use super::check::{located, whole};
+use super::component_link::{ComponentRef, component_key, require};
 use super::types::{IdOrName, Point3, PointExpr3, not_blank_pattern, present};
 use crate::params;
 
@@ -473,6 +478,658 @@ pub struct ReparentItemsResult {
     pub param_warnings: Vec<String>,
 }
 
+// ---------------------------------------------------------------------------------------------
+// component.create, from_bodies, activate, list, properties, rename, delete and unlock (#12504).
+//
+// The 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 a component, an occurrence or a body
+// exists stays the handler's to check. A key the handler refuses when it is left out is optional
+// in the type and required in the schema, so that the handler's message, not the check's "is
+// required", is what a caller sees.
+// ---------------------------------------------------------------------------------------------
+
+/// `message`, the handler's, for a value that is not a boolean (`null` included).
+fn flag<'de, D: Deserializer<'de>>(d: D, message: &str) -> Result<Option<bool>, D::Error> {
+    match Value::deserialize(d)? {
+        Value::Bool(b) => Ok(Some(b)),
+        _ => Err(D::Error::custom(whole(message))),
+    }
+}
+
+fn grounded_flag<'de, D: Deserializer<'de>>(d: D) -> Result<Option<bool>, D::Error> {
+    flag(d, "grounded must be true or false")
+}
+
+fn descendants_flag<'de, D: Deserializer<'de>>(d: D) -> Result<Option<bool>, D::Error> {
+    flag(d, "`descendants` must be a boolean")
+}
+
+/// A placement path as `component.create` reads `parent_path`: up to 63 occurrence ids (none
+/// is the design itself).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ParentPath(pub Vec<u64>);
+
+impl<'de> Deserialize<'de> for ParentPath {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        Value::deserialize(d)?
+            .as_array()
+            .filter(|a| a.len() < 64)
+            .and_then(|a| a.iter().map(Value::as_u64).collect::<Option<Vec<_>>>())
+            .map(ParentPath)
+            .ok_or_else(|| D::Error::custom(whole("parent_path must list up to 63 occurrence ids")))
+    }
+}
+
+impl JsonSchema for ParentPath {
+    fn schema_name() -> Cow<'static, str> {
+        "ParentPath".into()
+    }
+    fn json_schema(_: &mut SchemaGenerator) -> Schema {
+        json_schema!({
+            "description": "An exact placement path: up to 63 occurrence ids from the root down; empty for the design itself.",
+            "type": "array",
+            "items": {"type": "integer", "minimum": 0, "maximum": u64::MAX},
+            "maxItems": 63
+        })
+    }
+}
+
+fn parent<'de, D: Deserializer<'de>>(d: D) -> Result<Option<ComponentRef>, D::Error> {
+    component_key(d, "parent")
+}
+
+fn component<'de, D: Deserializer<'de>>(d: D) -> Result<Option<ComponentRef>, D::Error> {
+    component_key(d, "component")
+}
+
+fn component_required(schema: &mut Schema) {
+    require(schema, "component");
+}
+
+/// Make a new component, in the active component unless `parent` says another, and make it the
+/// active one unless `activate` is false. The design's first part is grounded; the others are
+/// not. Bodies are not moved here (`component.move_bodies`, `component.from_bodies`).
+#[derive(Debug, Deserialize, JsonSchema)]
+#[schemars(deny_unknown_fields)]
+pub struct CreateParams {
+    /// The new component's name. Default: a name made from the design's naming.
+    #[serde(default)]
+    pub name: Option<String>,
+    /// The component to put it in, by id or name. Default: the active one.
+    #[serde(default, deserialize_with = "parent", skip_serializing_if = "Option::is_none")]
+    #[schemars(with = "ComponentRef")]
+    pub parent: Option<ComponentRef>,
+    /// The exact placement of the parent to place it by, as occurrence ids from the top of the
+    /// design (up to 63; none is the design itself). It must belong to the parent. Default: the
+    /// active placement when the parent is the active component, else the parent's first.
+    #[serde(default, deserialize_with = "present", skip_serializing_if = "Option::is_none")]
+    #[schemars(with = "ParentPath")]
+    pub parent_path: Option<ParentPath>,
+    /// Make it the active component. Default: `true`.
+    #[serde(default)]
+    pub activate: Option<bool>,
+    /// Ground its placement. Default: `true` for the design's first part, `false` otherwise.
+    #[serde(default, deserialize_with = "grounded_flag", skip_serializing_if = "Option::is_none")]
+    #[schemars(with = "bool")]
+    pub grounded: Option<bool>,
+}
+
+/// What `component.create` returns.
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct CreateResult {
+    /// The new component, by id.
+    pub component: u64,
+    /// Its name.
+    pub name: String,
+    /// The component it is in, by id (0 is the design).
+    pub parent: u64,
+    /// Its placement, by id.
+    pub occurrence: Option<u64>,
+    /// Whether its placement is grounded.
+    pub grounded: 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>,
+}
+
+/// `component.from_bodies`' `bodies`: a list of body names, each once, as `body_names` reads
+/// it. The handler also looks each name up in the design.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct DefinitionBodies(pub Vec<String>);
+
+impl<'de> Deserialize<'de> for DefinitionBodies {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        let names = Value::deserialize(d)?
+            .as_array()
+            .and_then(|a| a.iter().map(|v| v.as_str().map(str::to_string)).collect::<Option<Vec<_>>>())
+            .ok_or_else(|| D::Error::custom(whole("bodies must be an array of body names")))?;
+        if names.is_empty() || names.len() > 1000 || names.iter().collect::<BTreeSet<_>>().len() != names.len() {
+            return Err(D::Error::custom(whole("bodies must list 1..1000 distinct existing definition bodies")));
+        }
+        Ok(DefinitionBodies(names))
+    }
+}
+
+impl JsonSchema for DefinitionBodies {
+    fn schema_name() -> Cow<'static, str> {
+        "DefinitionBodies".into()
+    }
+    fn json_schema(_: &mut SchemaGenerator) -> Schema {
+        json_schema!({
+            "description": "1 to 1000 different body names.",
+            "type": "array",
+            "items": {"type": "string"},
+            "minItems": 1,
+            "maxItems": 1000,
+            "uniqueItems": true
+        })
+    }
+}
+
+fn bodies_required(schema: &mut Schema) {
+    require(schema, "bodies");
+}
+
+/// Make one new component per body, in the active component and named after the body, and move
+/// each body into its component, keeping it where it is in the world. All or nothing, one undo
+/// step; refused while the timeline is rolled back.
+#[derive(Debug, Deserialize, JsonSchema)]
+#[schemars(deny_unknown_fields, transform = bodies_required)]
+pub struct FromBodiesParams {
+    // Optional in the type and required in the schema (`bodies_required`).
+    /// The bodies, by name.
+    #[serde(default, deserialize_with = "present", skip_serializing_if = "Option::is_none")]
+    #[schemars(with = "DefinitionBodies")]
+    pub bodies: Option<DefinitionBodies>,
+}
+
+/// One component `component.from_bodies` made.
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct BodyComponent {
+    /// The new component, by id.
+    pub component: u64,
+    /// The body it holds, by name.
+    pub body: String,
+    /// The Body Transfer feature that moved the body, by id.
+    pub feature: u64,
+}
+
+/// What `component.from_bodies` returns.
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct FromBodiesResult {
+    /// The new components, in the order of `bodies`.
+    pub components: Vec<BodyComponent>,
+    /// 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>,
+}
+
+/// An occurrence by its id (a number) or its name, as `occurrence` reads it.
+#[derive(Clone, Debug, PartialEq)]
+pub struct OccurrenceRef(pub String);
+
+impl<'de> Deserialize<'de> for OccurrenceRef {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        match Value::deserialize(d)? {
+            Value::Number(n) => Ok(OccurrenceRef(n.to_string())),
+            Value::String(s) => Ok(OccurrenceRef(s)),
+            _ => Err(D::Error::custom(whole("`occurrence` must be an id or name"))),
+        }
+    }
+}
+
+impl JsonSchema for OccurrenceRef {
+    fn schema_name() -> Cow<'static, str> {
+        "OccurrenceRef".into()
+    }
+    fn json_schema(_: &mut SchemaGenerator) -> Schema {
+        json_schema!({"description": "An occurrence's id (a number) or its name.", "type": ["number", "string"]})
+    }
+}
+
+fn activate_schema(schema: &mut Schema) {
+    require(schema, "component");
+    schema.insert("dependentRequired".into(), json!({"path": ["occurrence"]}));
+}
+
+/// Make a component the active one: new sketches and features go into it, authored in its
+/// frame. With `occurrence` (and `path`), the placement that shared geometry is authored
+/// through. A change of what is active, not an undo step.
+#[derive(Debug, Deserialize, JsonSchema)]
+#[schemars(deny_unknown_fields, transform = activate_schema)]
+pub struct ActivateKeys {
+    // Optional in the type and required in the schema (`activate_schema`).
+    /// The component to make active, by id or name (0 or `"root"` for the design).
+    #[serde(default, deserialize_with = "component", skip_serializing_if = "Option::is_none")]
+    #[schemars(with = "ComponentRef")]
+    pub component: Option<ComponentRef>,
+    /// The placement the component is authored in, by id or name, for a component placed more
+    /// than once. Needed when `path` is given.
+    #[serde(default, deserialize_with = "present", skip_serializing_if = "Option::is_none")]
+    #[schemars(with = "OccurrenceRef")]
+    pub occurrence: Option<OccurrenceRef>,
+    /// The occurrence's exact placement, as occurrence ids from the top of the design (1 to 64),
+    /// ending in `occurrence`, and a placement of the component. Default: the occurrence's
+    /// first placement.
+    #[serde(default, deserialize_with = "present", skip_serializing_if = "Option::is_none")]
+    #[schemars(with = "OccurrencePath")]
+    pub path: Option<OccurrencePath>,
+}
+
+/// `component.activate`'s parameters: [`ActivateKeys`], with `path` asked to come with
+/// `occurrence`, as the handler asks.
+#[derive(Debug)]
+pub struct ActivateParams(pub ActivateKeys);
+
+impl<'de> Deserialize<'de> for ActivateParams {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        let value = Value::deserialize(d)?;
+        let keys: ActivateKeys = serde_path_to_error::deserialize(&value).map_err(|e| D::Error::custom(located(&e)))?;
+        if keys.path.is_some() && keys.occurrence.is_none() {
+            return Err(D::Error::custom(whole("`occurrence` must be an id or name")));
+        }
+        Ok(ActivateParams(keys))
+    }
+}
+
+impl JsonSchema for ActivateParams {
+    fn schema_name() -> Cow<'static, str> {
+        "ActivateParams".into()
+    }
+    fn json_schema(generator: &mut SchemaGenerator) -> Schema {
+        ActivateKeys::json_schema(generator)
+    }
+}
+
+/// What `component.activate` returns.
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct ActivateResult {
+    /// The active component now, by id.
+    pub active: u64,
+    /// 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>,
+}
+
+/// List the components as a tree: each with its bodies, features, sketches, construction planes,
+/// placements and children, the active component and the pending moves. The design is not
+/// changed.
+#[derive(Debug, Deserialize, JsonSchema)]
+#[schemars(deny_unknown_fields)]
+pub struct ListKeys {
+    /// Counts of bodies, features, sketches and construction planes instead of their names;
+    /// placements leave out identity transforms; children as occurrence ids. Default: `false`.
+    #[serde(default)]
+    pub compact: Option<bool>,
+    /// With `compact`: body names, not their count. Read only with `compact: true`. Default:
+    /// `false`.
+    #[serde(default)]
+    pub bodies: Option<bool>,
+}
+
+/// `component.list`'s parameters: [`ListKeys`], with `bodies` read only when `compact` is true,
+/// as the handler reads it.
+#[derive(Debug)]
+pub struct ListParams(pub ListKeys);
+
+impl<'de> Deserialize<'de> for ListParams {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        let mut value = Value::deserialize(d)?;
+        if let Some(keys) = value.as_object_mut()
+            && keys.get("compact").and_then(Value::as_bool) != Some(true)
+        {
+            keys.remove("bodies");
+        }
+        serde_path_to_error::deserialize(&value).map(ListParams).map_err(|e| D::Error::custom(located(&e)))
+    }
+}
+
+impl JsonSchema for ListParams {
+    fn schema_name() -> Cow<'static, str> {
+        "ListParams".into()
+    }
+    fn json_schema(generator: &mut SchemaGenerator) -> Schema {
+        ListKeys::json_schema(generator)
+    }
+}
+
+/// A placement as `component.list` shows it, in full.
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct PlacementInfo {
+    /// The occurrence, by id.
+    pub id: u64,
+    /// The component it places, by id.
+    pub component: u64,
+    /// The component it sits in, by id (0 is the design).
+    pub parent: u64,
+    pub name: String,
+    /// Its placement in its parent, as a 4×4 matrix.
+    pub transform: [[f64; 4]; 4],
+    /// Whether it is grounded.
+    pub grounded: bool,
+}
+
+impl From<&Occurrence> for PlacementInfo {
+    fn from(o: &Occurrence) -> Self {
+        PlacementInfo { id: o.id, component: o.component, parent: o.parent, name: o.name.clone(), transform: o.transform, grounded: o.grounded }
+    }
+}
+
+/// A placement as `compact` `component.list` shows it.
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct CompactPlacement {
+    /// The occurrence, by id.
+    pub id: u64,
+    pub name: String,
+    /// The component it sits in, by id (0 is the design).
+    pub parent: u64,
+    /// Whether it is grounded.
+    pub grounded: bool,
+    /// Its placement in its parent, as a 4×4 matrix; left out when it is the identity.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub transform: Option<[[f64; 4]; 4]>,
+}
+
+/// A placement in a component's `occurrences`: in full, or compact.
+#[derive(Debug, Serialize, JsonSchema)]
+#[serde(untagged)]
+pub enum PlacementEntry {
+    Full(PlacementInfo),
+    Compact(CompactPlacement),
+}
+
+/// A placement in a component's `children`: in full, or with `compact` its id.
+#[derive(Debug, Serialize, JsonSchema)]
+#[serde(untagged)]
+pub enum ChildEntry {
+    Full(PlacementInfo),
+    Id(u64),
+}
+
+/// Names, or with `compact` how many there are.
+#[derive(Debug, Serialize, JsonSchema)]
+#[serde(untagged)]
+pub enum NamesOrCount {
+    Names(Vec<String>),
+    Count(usize),
+}
+
+/// One component of `component.list`; the design itself is the first, with id 0.
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct ComponentNode {
+    /// The component, by id (0 is the design).
+    pub id: u64,
+    pub name: String,
+    /// The component it is in; null for the design.
+    pub parent: Option<u64>,
+    /// Its bodies by name; with `compact` their count unless `bodies` is true.
+    pub bodies: NamesOrCount,
+    /// Its features other than sketches and construction planes, by name; with `compact` their count.
+    pub features: NamesOrCount,
+    /// Its sketches, by name; with `compact` their count.
+    pub sketches: NamesOrCount,
+    /// Its construction planes, by name; with `compact` their count.
+    pub construction: NamesOrCount,
+    /// Where it is placed.
+    pub occurrences: Vec<PlacementEntry>,
+    /// The placements it holds.
+    pub children: Vec<ChildEntry>,
+}
+
+/// What `component.list` returns.
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct ListResult {
+    /// The active component, by id.
+    pub active: u64,
+    /// The design and its components.
+    pub components: Vec<ComponentNode>,
+    /// The occurrences with a move not captured yet, by id.
+    pub pending_moves: Vec<u64>,
+    /// 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>,
+}
+
+/// `about`, a point in mm or `null`, with the handler's message for anything else.
+fn about<'de, D: Deserializer<'de>>(d: D) -> Result<Option<Point3>, D::Error> {
+    match Value::deserialize(d)? {
+        Value::Null => Ok(None),
+        v => params::vec3(&v).map(|p| Some(Point3(p))).ok_or_else(|| D::Error::custom(whole("`about` must be a point [x, y, z] in mm"))),
+    }
+}
+
+/// Measure a component where its first placement puts it (every placement for the design):
+/// material-aware mass and centre of mass in world coordinates, volume, density, and inertia
+/// for closed, consistently oriented bodies, with totals and principal moments. Pending moves
+/// are included. The design is not changed.
+#[derive(Debug, Deserialize, JsonSchema)]
+#[schemars(deny_unknown_fields)]
+pub struct PropertiesParams {
+    /// The component, by id or name. Default: the active component.
+    #[serde(default, deserialize_with = "component", skip_serializing_if = "Option::is_none")]
+    #[schemars(with = "ComponentRef")]
+    pub component: Option<ComponentRef>,
+    /// Include the components and placements inside it. Default: `true`.
+    #[serde(default, deserialize_with = "descendants_flag", skip_serializing_if = "Option::is_none")]
+    #[schemars(with = "bool")]
+    pub descendants: Option<bool>,
+    /// A point in mm, also given the total inertia about it (`total.inertia_about`).
+    #[serde(default, deserialize_with = "about", skip_serializing_if = "Option::is_none")]
+    #[schemars(with = "Option<Point3>")]
+    pub about: Option<Point3>,
+}
+
+/// A body's box, in world coordinates (mm).
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct BoundingBox {
+    #[schemars(with = "[f64; 3]")]
+    pub min: Vec3,
+    #[schemars(with = "[f64; 3]")]
+    pub max: Vec3,
+}
+
+/// One body's measurements at one placement. Volume, density, mass, centre of mass and inertia
+/// are null for a body that is not closed.
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct BodyProperties {
+    pub name: String,
+    /// The component it belongs to, by id.
+    pub component: u64,
+    /// The placement it is measured at, as occurrence ids from the top.
+    pub path: Vec<u64>,
+    /// Its material's name.
+    pub material: String,
+    /// Whether it is closed and consistently oriented.
+    pub closed: bool,
+    pub density_g_cm3: Option<f64>,
+    pub mass_g: Option<f64>,
+    pub volume_mm3: Option<f64>,
+    pub area_mm2: f64,
+    /// Its centre of mass, in world coordinates (mm).
+    #[schemars(with = "Option<[f64; 3]>")]
+    pub center_of_mass: Option<Vec3>,
+    /// The inertia tensor about its centre of mass, in world axes (g·mm²).
+    pub inertia_g_mm2: Option<[[f64; 3]; 3]>,
+    pub bbox: BoundingBox,
+}
+
+/// The inertia about the point `about` asked for.
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct InertiaAbout {
+    /// The point, in mm.
+    #[schemars(with = "[f64; 3]")]
+    pub point: Vec3,
+    /// The total inertia tensor about it (g·mm²); null when it is not known.
+    pub inertia_g_mm2: Option<[[f64; 3]; 3]>,
+}
+
+/// The totals of a physical-properties measurement, over the closed bodies unless said.
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct TotalProperties {
+    /// How many open bodies are left out of the volume and mass totals.
+    pub open_bodies_skipped: usize,
+    pub volume_mm3: f64,
+    /// The area of all bodies, closed or not.
+    pub area_mm2: f64,
+    pub mass_g: f64,
+    /// The centre of mass (mm); null when the mass is zero.
+    #[schemars(with = "Option<[f64; 3]>")]
+    pub center_of_mass: Option<Vec3>,
+    /// Mass times centre of mass (g·mm).
+    #[schemars(with = "[f64; 3]")]
+    pub first_moment_g_mm: Vec3,
+    /// The inertia tensor about the centre of mass, in world axes (g·mm²); null when it is not known.
+    pub inertia_g_mm2: Option<[[f64; 3]; 3]>,
+    /// The principal moments, smallest first (g·mm²).
+    pub principal_moments_g_mm2: Option<[f64; 3]>,
+    /// The principal axes: unit vectors, right-handed.
+    #[schemars(with = "Option<[[f64; 3]; 3]>")]
+    pub principal_axes: Option<[Vec3; 3]>,
+    /// The box around all bodies; null when there are none.
+    pub bbox: Option<BoundingBox>,
+    pub faces: usize,
+    pub edges: usize,
+    pub vertices: usize,
+    /// With `about`: the inertia about that point.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub inertia_about: Option<InertiaAbout>,
+}
+
+/// Physical properties of a placement and what it holds, in world coordinates.
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct PhysicalProperties {
+    /// The placement measured, as occurrence ids from the top; empty for the design.
+    pub path: Vec<u64>,
+    /// Always `world`.
+    pub coordinate_frame: String,
+    /// Whether what is inside the placement is included.
+    pub descendants: bool,
+    pub placement_count: usize,
+    pub body_count: usize,
+    pub bodies: Vec<BodyProperties>,
+    pub total: TotalProperties,
+}
+
+/// What `component.properties` returns.
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct PropertiesResult {
+    /// The component, by id.
+    pub component: u64,
+    pub name: String,
+    #[serde(flatten)]
+    pub properties: PhysicalProperties,
+    /// 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>,
+}
+
+/// The new name `component.rename` reads: text of 1 to 128 bytes once trimmed.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ComponentName(pub String);
+
+impl<'de> Deserialize<'de> for ComponentName {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        match Value::deserialize(d)? {
+            Value::String(s) if !s.trim().is_empty() && s.trim().len() <= 128 => Ok(ComponentName(s)),
+            _ => Err(D::Error::custom(whole("`name` must be 1…128 characters"))),
+        }
+    }
+}
+
+impl JsonSchema for ComponentName {
+    fn schema_name() -> Cow<'static, str> {
+        "ComponentName".into()
+    }
+    fn json_schema(_: &mut SchemaGenerator) -> Schema {
+        json_schema!({
+            "description": "Text with something in it; once surrounding blanks are cut, at most 128 bytes.",
+            "type": "string",
+            "pattern": not_blank_pattern()
+        })
+    }
+}
+
+fn rename_schema(schema: &mut Schema) {
+    require(schema, "component");
+    require(schema, "name");
+}
+
+/// Rename a component, or the design itself (id 0). Placements still named after it follow.
+#[derive(Debug, Deserialize, JsonSchema)]
+#[schemars(deny_unknown_fields, transform = rename_schema)]
+pub struct RenameParams {
+    // Optional in the type and required in the schema (`rename_schema`).
+    /// The component, by id or name (0 or `"root"` for the design).
+    #[serde(default, deserialize_with = "component", skip_serializing_if = "Option::is_none")]
+    #[schemars(with = "ComponentRef")]
+    pub component: Option<ComponentRef>,
+    /// The new name.
+    #[serde(default, deserialize_with = "present", skip_serializing_if = "Option::is_none")]
+    #[schemars(with = "ComponentName")]
+    pub name: Option<ComponentName>,
+}
+
+/// What `component.rename` returns.
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct RenameResult {
+    /// The component, by id.
+    pub component: u64,
+    /// Its name now, trimmed.
+    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>,
+}
+
+/// Delete a component with its subcomponents, placements and features. Refused for the design
+/// itself, and for a tree that supplies a body transfer recorded outside it.
+#[derive(Debug, Deserialize, JsonSchema)]
+#[schemars(deny_unknown_fields, transform = component_required)]
+pub struct DeleteParams {
+    // Optional in the type and required in the schema (`component_required`).
+    /// The component, by id or name.
+    #[serde(default, deserialize_with = "component", skip_serializing_if = "Option::is_none")]
+    #[schemars(with = "ComponentRef")]
+    pub component: Option<ComponentRef>,
+}
+
+/// What `component.delete` returns.
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct DeleteResult {
+    /// The components removed, by id: it and everything inside it.
+    pub deleted: Vec<u64>,
+    /// The features that were inside them, by id.
+    pub features: Vec<u64>,
+    /// 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>,
+}
+
+/// Remove the rigid joints that hold a component's contents together (an imported assembly's
+/// rigid group), so its parts move and take joints one by one. Refused for the design and when
+/// nothing holds the contents together.
+#[derive(Debug, Deserialize, JsonSchema)]
+#[schemars(deny_unknown_fields, transform = component_required)]
+pub struct UnlockParams {
+    // Optional in the type and required in the schema (`component_required`).
+    /// The component, by id or name.
+    #[serde(default, deserialize_with = "component", skip_serializing_if = "Option::is_none")]
+    #[schemars(with = "ComponentRef")]
+    pub component: Option<ComponentRef>,
+}
+
+/// What `component.unlock` returns.
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct UnlockResult {
+    /// The component, by id.
+    pub component: u64,
+    /// The joints removed, by id.
+    pub joints: Vec<u64>,
+    /// 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>,
+}
+
 #[cfg(test)]
 #[path = "component_tests.rs"]
 mod tests;
diff --git a/crates/engine/src/schema/component_link.rs b/crates/engine/src/schema/component_link.rs
index 724856d41f..6aa290fc97 100644
--- a/crates/engine/src/schema/component_link.rs
+++ b/crates/engine/src/schema/component_link.rs
@@ -52,7 +52,7 @@ impl JsonSchema for ComponentRef {
 
 /// `key`, a component's id or name, with the handler's message for anything else, `null`
 /// included.
-fn component_key<'de, D: Deserializer<'de>>(d: D, key: &str) -> Result<Option<ComponentRef>, D::Error> {
+pub(super) fn component_key<'de, D: Deserializer<'de>>(d: D, key: &str) -> Result<Option<ComponentRef>, D::Error> {
     match Value::deserialize(d)? {
         Value::Number(n) => Ok(Some(ComponentRef(n.to_string()))),
         Value::String(s) => Ok(Some(ComponentRef(s))),
@@ -95,7 +95,7 @@ fn path_schema(_: &mut SchemaGenerator) -> Schema {
 
 /// 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) {
+pub(super) fn require(schema: &mut Schema, key: &str) {
     match schema.get_mut("required") {
         Some(Value::Array(required)) => {
             if !required.iter().any(|k| k == key) {
diff --git a/crates/engine/src/schema/component_tests.rs b/crates/engine/src/schema/component_tests.rs
index c03d84f302..9ec8eb131b 100644
--- a/crates/engine/src/schema/component_tests.rs
+++ b/crates/engine/src/schema/component_tests.rs
@@ -4,11 +4,12 @@ use std::sync::Arc;
 use serde_json::{Value, json};
 
 use super::{
-    EditInPlaceParams, FinishEditParams, MoveFeaturesParams, MoveSketchesToPartsParams, OccurrenceAlignParams, OccurrenceAlignResult,
-    ReparentItemsParams,
+    ActivateParams, ActivateResult, CreateParams, CreateResult, DeleteParams, DeleteResult, EditInPlaceParams, FinishEditParams, FromBodiesParams,
+    FromBodiesResult, ListParams, ListResult, MoveFeaturesParams, MoveSketchesToPartsParams, OccurrenceAlignParams, OccurrenceAlignResult,
+    PropertiesParams, PropertiesResult, RenameParams, RenameResult, ReparentItemsParams, UnlockParams, UnlockResult,
 };
 use crate::Session;
-use crate::schema::tests::{assert_keys, conforms};
+use crate::schema::tests::{assert_keys, assert_strict_keeps_todays_errors, conforms};
 use crate::schema::{ParamCheck, input_schema_for, output_schema_for};
 
 #[test]
@@ -36,6 +37,340 @@ fn schemas_and_the_key_check_agree() {
     assert_keys(input_schema_for::<MoveFeaturesParams>(), &["component", "features"]);
     assert_keys(input_schema_for::<MoveSketchesToPartsParams>(), &["sketches"]);
     assert_keys(input_schema_for::<ReparentItemsParams>(), &["bodies", "component", "component_path", "features", "occurrences"]);
+    assert_keys(input_schema_for::<CreateParams>(), &["activate", "grounded", "name", "parent", "parent_path"]);
+    assert_keys(input_schema_for::<FromBodiesParams>(), &["bodies"]);
+    assert_keys(input_schema_for::<ActivateParams>(), &["component", "occurrence", "path"]);
+    assert_keys(input_schema_for::<ListParams>(), &["bodies", "compact"]);
+    assert_keys(input_schema_for::<PropertiesParams>(), &["about", "component", "descendants"]);
+    assert_keys(input_schema_for::<RenameParams>(), &["component", "name"]);
+    assert_keys(input_schema_for::<DeleteParams>(), &["component"]);
+    assert_keys(input_schema_for::<UnlockParams>(), &["component"]);
+}
+
+/// The calls these commands already refuse (the handlers' own messages), refused alike in strict.
+/// An unknown key to `component.create` is left out: its handler lists the accepted parameters,
+/// where strict gives the check's `unknown key` with a suggestion (refused either way).
+#[test]
+fn strict_keeps_todays_errors() {
+    assert_strict_keeps_todays_errors(&[
+        ("component.create", json!({"parent": null})),
+        ("component.create", json!({"parent": true})),
+        ("component.create", json!({"parent": [1]})),
+        ("component.create", json!({"parent": "Nope"})),
+        ("component.create", json!({"parent_path": "1"})),
+        ("component.create", json!({"parent_path": null})),
+        ("component.create", json!({"parent_path": [1, "a"]})),
+        ("component.create", json!({"parent_path": vec![1; 64]})),
+        ("component.create", json!({"grounded": "yes"})),
+        ("component.create", json!({"grounded": null})),
+        ("component.from_bodies", json!({})),
+        ("component.from_bodies", json!({"bodies": null})),
+        ("component.from_bodies", json!({"bodies": "Box"})),
+        ("component.from_bodies", json!({"bodies": [1]})),
+        ("component.from_bodies", json!({"bodies": []})),
+        ("component.from_bodies", json!({"bodies": ["A", "A"]})),
+        ("component.from_bodies", json!({"bodies": vec!["A"; 1001]})),
+        ("component.from_bodies", json!({"bodies": ["Nope"]})),
+        ("component.activate", json!({})),
+        ("component.activate", json!({"component": null})),
+        ("component.activate", json!({"component": [1]})),
+        ("component.activate", json!({"component": "Nope"})),
+        ("component.activate", json!({"component": 0, "path": [1]})),
+        ("component.activate", json!({"component": 0, "occurrence": null})),
+        ("component.activate", json!({"component": 0, "occurrence": true})),
+        ("component.properties", json!({"component": null})),
+        ("component.properties", json!({"component": true})),
+        ("component.properties", json!({"descendants": "yes"})),
+        ("component.properties", json!({"descendants": null})),
+        ("component.properties", json!({"about": [1, 2]})),
+        ("component.properties", json!({"about": "origin"})),
+        ("component.properties", json!({"about": [1, 2, 1e9]})),
+        ("component.rename", json!({})),
+        ("component.rename", json!({"component": 0})),
+        ("component.rename", json!({"name": "A"})),
+        ("component.rename", json!({"component": null, "name": "A"})),
+        ("component.rename", json!({"component": 0, "name": ""})),
+        ("component.rename", json!({"component": 0, "name": " \t "})),
+        ("component.rename", json!({"component": 0, "name": 5})),
+        ("component.rename", json!({"component": 0, "name": null})),
+        ("component.rename", json!({"component": 0, "name": "x".repeat(129)})),
+        ("component.delete", json!({})),
+        ("component.delete", json!({"component": false})),
+        ("component.delete", json!({"component": 0})),
+        ("component.unlock", json!({})),
+        ("component.unlock", json!({"component": [0]})),
+        ("component.unlock", json!({"component": 0})),
+    ]);
+}
+
+/// A name of 128 bytes is taken once trimmed, and one of 129 is not, as the handler counts.
+#[test]
+fn a_name_is_counted_as_the_handler_counts_it() {
+    let issues = |p: Value| crate::schema::issues("component.rename", &p).len();
+    assert_eq!(issues(json!({"component": 0, "name": format!("  {}  ", "x".repeat(128))})), 0);
+    assert_eq!(issues(json!({"component": 0, "name": "x".repeat(129)})), 1);
+    // 64 two-byte characters are 128 bytes.
+    assert_eq!(issues(json!({"component": 0, "name": "é".repeat(64)})), 0);
+    assert_eq!(issues(json!({"component": 0, "name": "é".repeat(65)})), 1);
+}
+
+/// The contracts say what the handlers need: a key a handler refuses without is required in the
+/// schema, though the type leaves it to the handler's message.
+#[test]
+fn the_schemas_take_what_the_handlers_read() {
+    let takes = |schema: schemars::Schema, cases: &[(Value, bool)]| {
+        let schema = schema.as_value();
+        for (p, takes) in cases {
+            assert_eq!(conforms(schema, schema, p), *takes, "{p}");
+        }
+    };
+    takes(
+        input_schema_for::<CreateParams>(),
+        &[
+            (json!({}), true),
+            (json!({"name": "Arm", "parent": "Frame", "parent_path": [1, 2], "activate": false, "grounded": true}), true),
+            (json!({"parent": 3, "parent_path": []}), true),
+            (json!({"parent": true}), false),
+            (json!({"parent_path": vec![1; 64]}), false),
+            (json!({"grounded": "yes"}), false),
+            (json!({"bodies": ["A"]}), false),
+        ],
+    );
+    takes(
+        input_schema_for::<FromBodiesParams>(),
+        &[
+            (json!({"bodies": ["A", "B"]}), true),
+            (json!({}), false),
+            (json!({"bodies": []}), false),
+            (json!({"bodies": ["A", "A"]}), false),
+            (json!({"bodies": "A"}), false),
+        ],
+    );
+    takes(
+        input_schema_for::<ActivateParams>(),
+        &[
+            (json!({"component": 0}), true),
+            (json!({"component": "root"}), true),
+            (json!({"component": "Arm", "occurrence": "Arm:2", "path": [1, 2]}), true),
+            (json!({"component": "Arm", "occurrence": 2}), true),
+            (json!({}), false),
+            (json!({"component": true}), false),
+            (json!({"component": 1, "occurrence": true}), false),
+            (json!({"component": 1, "path": []}), false),
+        ],
+    );
+    takes(
+        input_schema_for::<ListParams>(),
+        &[(json!({}), true), (json!({"compact": true, "bodies": true}), true), (json!({"compact": "yes"}), false)],
+    );
+    takes(
+        input_schema_for::<PropertiesParams>(),
+        &[
+            (json!({}), true),
+            (json!({"component": "Arm", "descendants": false, "about": [1, 2, 3]}), true),
+            (json!({"about": {"x": 1, "y": 2, "z": 3}}), true),
+            (json!({"about": [1, 2]}), false),
+            (json!({"descendants": 1}), false),
+        ],
+    );
+    takes(
+        input_schema_for::<RenameParams>(),
+        &[(json!({"component": "Arm", "name": "Bar"}), true), (json!({"component": "Arm"}), false), (json!({"name": "Bar"}), false)],
+    );
+    // `conforms` doesn't read patterns: pin the text that keeps blank names out.
+    let rename = input_schema_for::<RenameParams>();
+    assert_eq!(rename.as_value()["$defs"]["ComponentName"]["pattern"], crate::schema::types::not_blank_pattern());
+    takes(input_schema_for::<DeleteParams>(), &[(json!({"component": 2}), true), (json!({}), false)]);
+    takes(input_schema_for::<UnlockParams>(), &[(json!({"component": "rig"}), true), (json!({}), false)]);
+}
+
+/// Keys the handlers read only in some cases are read only in those cases: `bodies` of
+/// `component.list` with `compact`, `path` of `component.activate` with `occurrence`. And the
+/// warnings say what is wrong with a key.
+#[test]
+fn the_check_reads_keys_as_the_handlers_do() {
+    let issues = |id: &str, p: Value| crate::schema::issues(id, &p).into_iter().map(|i| i.message).collect::<Vec<_>>();
+    let none = Vec::<String>::new();
+    assert_eq!(issues("component.list", json!({"bodies": "x"})), none);
+    assert_eq!(issues("component.list", json!({"compact": false, "bodies": 3})), none);
+    assert_eq!(issues("component.list", json!({"compact": true, "bodies": true})), none);
+    assert_eq!(issues("component.list", json!({"compact": true, "bodies": "x"})).len(), 1);
+    assert_eq!(issues("component.list", json!({"compact": "x"})).len(), 1);
+    assert_eq!(issues("component.list", json!({"compat": true})), ["unknown key `compat`; did you mean `compact`?"]);
+    assert_eq!(issues("component.activate", json!({"component": 1, "occurrence": 2})), none);
+    assert_eq!(issues("component.activate", json!({"component": 1, "occurrence": 2, "path": [1, 2]})), none);
+    assert_eq!(issues("component.activate", json!({"component": 1, "path": [2]})), ["`occurrence` must be an id or name"]);
+    assert_eq!(issues("component.activate", json!({"component": 1, "occurrence": 2, "path": []})), ["`path` must list 1..64 occurrence ids"]);
+    assert_eq!(issues("component.activate", json!({"component": 1, "occurrence": null})), ["`occurrence` must be an id or name"]);
+    assert_eq!(issues("component.create", json!({"parent": true})), ["`parent` must be a component id or name"]);
+    assert_eq!(issues("component.create", json!({"parent_path": [1, null]})), ["parent_path must list up to 63 occurrence ids"]);
+    assert_eq!(issues("component.create", json!({"grounded": 1})), ["grounded must be true or false"]);
+    assert_eq!(issues("component.create", json!({"parent_path": vec![1; 63]})), none);
+    assert_eq!(issues("component.create", json!({"parent_path": vec![1; 64]})), ["parent_path must list up to 63 occurrence ids"]);
+    assert_eq!(issues("component.create", json!({"activate": "no"})).len(), 1);
+    assert_eq!(issues("component.from_bodies", json!({"bodies": [1]})), ["bodies must be an array of body names"]);
+    assert_eq!(issues("component.from_bodies", json!({"bodies": ["a", "a"]})), ["bodies must list 1..1000 distinct existing definition bodies"]);
+    assert_eq!(issues("component.properties", json!({"about": [1]})), ["`about` must be a point [x, y, z] in mm"]);
+    assert_eq!(issues("component.properties", json!({"about": null})), none);
+    assert_eq!(issues("component.properties", json!({"descendants": null})), ["`descendants` must be a boolean"]);
+    assert_eq!(issues("component.properties", json!({"component": null})), ["`component` must be a component id or name"]);
+    assert_eq!(issues("component.rename", json!({"component": 0, "name": ""})), ["`name` must be 1…128 characters"]);
+}
+
+fn matches(schema: schemars::Schema, id: &str, reply: &Value) {
+    let schema = schema.as_value();
+    assert!(conforms(schema, schema, reply), "{id}: {reply} doesn't match {schema}");
+    assert!(reply.get("param_warnings").is_none(), "{id}: {reply}");
+}
+
+/// A glTF file whose node `rig` holds a `Part` (one cube): imported, it is a component held
+/// together by a rigid group that `component.unlock` releases.
+fn rig_file(name: &str) -> String {
+    let side = 0.01f32;
+    let points: Vec<[f32; 3]> = (0..8).map(|i| [(i & 1) as f32 * side, ((i >> 1) & 1) as f32 * side, ((i >> 2) & 1) as f32 * side]).collect();
+    let tris: [u16; 36] = [0, 2, 1, 1, 2, 3, 4, 5, 6, 5, 7, 6, 0, 1, 4, 1, 5, 4, 2, 6, 3, 3, 6, 7, 0, 4, 2, 2, 4, 6, 1, 3, 5, 3, 7, 5];
+    let mut bin: Vec<u8> = points.iter().flatten().flat_map(|v| v.to_le_bytes()).collect();
+    bin.extend(tris.iter().flat_map(|v| v.to_le_bytes()));
+    let doc = json!({
+        "asset": {"version": "2.0"},
+        "scene": 0,
+        "scenes": [{"nodes": [0]}],
+        "nodes": [{"name": "Base", "mesh": 0, "children": [1]}, {"name": "Arm", "mesh": 1, "translation": [0.0, 0.05, 0.0]}],
+        "meshes": [{"name": "Block", "primitives": [{"attributes": {"POSITION": 0}, "indices": 1}]},
+                   {"name": "Peg", "primitives": [{"attributes": {"POSITION": 0}, "indices": 1}]}],
+        "accessors": [
+            {"bufferView": 0, "componentType": 5126, "count": 8, "type": "VEC3", "min": [0.0, 0.0, 0.0], "max": [side, side, side]},
+            {"bufferView": 1, "componentType": 5123, "count": 36, "type": "SCALAR"},
+        ],
+        "bufferViews": [{"buffer": 0, "byteOffset": 0, "byteLength": 96}, {"buffer": 0, "byteOffset": 96, "byteLength": 72}],
+        "buffers": [{"byteLength": bin.len()}],
+    });
+    let path = std::env::temp_dir().join(format!("solidcraft-component-schema-{}-{name}.glb", std::process::id()));
+    std::fs::write(&path, solidcraft_io::glb_container(doc.to_string().as_bytes(), &bin)).unwrap_or_else(|e| panic!("{e}"));
+    path.to_string_lossy().to_string()
+}
+
+/// Every command, in each form it takes, in Warn: the real reply matches its output schema and
+/// carries no `param_warnings` (Warn runs a call the contract refuses anyway, so the replies
+/// are also checked for warnings), and a key spelt wrongly on purpose is reported.
+#[test]
+fn replies_match_the_output_schemas_of_the_component_commands() {
+    let mut s = Session { param_check: ParamCheck::Warn, ..Session::default() };
+    let mut run = |id: &str, p: Value| s.execute(id, &p).unwrap_or_else(|e| panic!("{id} {p}: {e}"));
+
+    let arm = run("component.create", json!({"name": "Arm"}));
+    assert_eq!(arm["name"], "Arm");
+    assert_eq!(arm["grounded"], true, "the design's first part is grounded: {arm}");
+    matches(output_schema_for::<CreateResult>(), "component.create", &arm);
+    run("solid.box", json!({"length": 10, "width": 10, "height": 10, "body_name": "ArmBox"}));
+    let hand = run("component.create", json!({"name": "Hand", "parent": "Arm", "activate": false, "grounded": false}));
+    assert!(hand["parent"] == arm["component"] && hand["grounded"] == false, "{hand}");
+    matches(output_schema_for::<CreateResult>(), "component.create", &hand);
+    let at = run("component.create", json!({"name": "Thumb", "parent": hand["parent"], "parent_path": [arm["occurrence"]]}));
+    matches(output_schema_for::<CreateResult>(), "component.create", &at);
+    let top = run("component.create", json!({"name": "Top", "parent": 0, "parent_path": []}));
+    matches(output_schema_for::<CreateResult>(), "component.create", &top);
+
+    let active = run("component.activate", json!({"component": "root"}));
+    assert_eq!(active["active"], 0);
+    matches(output_schema_for::<ActivateResult>(), "component.activate", &active);
+    let active = run("component.activate", json!({"component": arm["component"]}));
+    matches(output_schema_for::<ActivateResult>(), "component.activate", &active);
+    let active = run("component.activate", json!({"component": "Arm", "occurrence": arm["occurrence"], "path": [arm["occurrence"]]}));
+    assert_eq!(active["active"], arm["component"], "{active}");
+    matches(output_schema_for::<ActivateResult>(), "component.activate", &active);
+
+    run("solid.box", json!({"length": 5, "width": 5, "height": 5, "body_name": "RootBox"}));
+    run("solid.box", json!({"length": 6, "width": 6, "height": 6, "body_name": "RootBox2", "operation": "new"}));
+    let made = run("component.from_bodies", json!({"bodies": ["RootBox", "RootBox2"]}));
+    assert_eq!(made["components"].as_array().map(Vec::len), Some(2), "{made}");
+    matches(output_schema_for::<FromBodiesResult>(), "component.from_bodies", &made);
+
+    for p in [
+        json!({}),
+        json!({"compact": true}),
+        json!({"compact": true, "bodies": true}),
+        json!({"compact": false, "bodies": "ignored"}),
+        json!({"bodies": true}),
+    ] {
+        let listed = run("component.list", p.clone());
+        matches(output_schema_for::<ListResult>(), "component.list", &listed);
+        assert!(listed["components"].as_array().is_some_and(|c| c.len() >= 5), "{p}: {listed}");
+    }
+    let moved = run("occurrence.move", json!({"occurrence": hand["occurrence"], "translate": [5, 0, 0], "capture": false, "move_grounded": true}));
+    assert_eq!(moved["pending"], true, "{moved}");
+    run("occurrence.move", json!({"occurrence": top["occurrence"], "translate": [0, 7, 0], "move_grounded": true}));
+    let listed = run("component.list", json!({"compact": true}));
+    assert!(listed["pending_moves"].as_array().is_some_and(|m| !m.is_empty()), "{listed}");
+    // Compact placements carry `transform` only when it is not the identity.
+    let placements: Vec<&Value> =
+        listed["components"].as_array().into_iter().flatten().flat_map(|c| c["occurrences"].as_array().into_iter().flatten()).collect();
+    assert!(placements.iter().any(|o| o.get("transform").is_some()) && placements.iter().any(|o| o.get("transform").is_none()), "{listed}");
+    matches(output_schema_for::<ListResult>(), "component.list", &listed);
+
+    for p in [
+        json!({}),
+        json!({"component": "Arm"}),
+        json!({"component": 0, "descendants": false}),
+        json!({"component": "root", "about": [10, 0, 0]}),
+        json!({"about": {"x": 1, "y": 2, "z": 3}, "descendants": true}),
+        json!({"about": null}),
+        json!({"component": "Top"}),
+    ] {
+        let measured = run("component.properties", p.clone());
+        matches(output_schema_for::<PropertiesResult>(), "component.properties", &measured);
+        assert_eq!(measured["coordinate_frame"], "world", "{p}");
+        assert_eq!(measured["total"].get("inertia_about").is_some(), p.get("about").is_some_and(|a| !a.is_null()), "{p}: {measured}");
+    }
+    let measured = run("component.properties", json!({"component": 0}));
+    assert!(measured["body_count"].as_u64().is_some_and(|n| n >= 3) && measured["total"]["bbox"].is_object(), "{measured}");
+    let empty = run("component.properties", json!({"component": "Top"}));
+    assert!(empty["total"]["bbox"].is_null() && empty["total"]["center_of_mass"].is_null(), "{empty}");
+
+    let renamed = run("component.rename", json!({"component": "Hand", "name": "  Palm "}));
+    assert_eq!(renamed["name"], "Palm");
+    matches(output_schema_for::<RenameResult>(), "component.rename", &renamed);
+    let renamed = run("component.rename", json!({"component": 0, "name": "Whole"}));
+    matches(output_schema_for::<RenameResult>(), "component.rename", &renamed);
+
+    let deleted = run("component.delete", json!({"component": "Arm"}));
+    assert!(deleted["deleted"].as_array().is_some_and(|d| d.len() >= 3), "{deleted}");
+    matches(output_schema_for::<DeleteResult>(), "component.delete", &deleted);
+
+    // Unlock: a glTF node tree is held together by a rigid group.
+    let inserted = run("file.insert_mesh", json!({"path": rig_file("rig"), "up": "z"}));
+    let rig = inserted["component"].clone();
+    let unlocked = run("component.unlock", json!({"component": rig}));
+    assert!(unlocked["joints"].as_array().is_some_and(|j| !j.is_empty()), "{unlocked}");
+    matches(output_schema_for::<UnlockResult>(), "component.unlock", &unlocked);
+
+    // Misspelt keys still run in Warn, say so, and the reply still matches.
+    let cases: [(&str, Value, &str, schemars::Schema); 3] = [
+        ("component.list", json!({"compat": true}), "compat", output_schema_for::<ListResult>()),
+        ("component.properties", json!({"descendents": false}), "descendents", output_schema_for::<PropertiesResult>()),
+        ("component.rename", json!({"component": 0, "nmae": "x", "name": "Again"}), "nmae", output_schema_for::<RenameResult>()),
+    ];
+    for (id, p, key, schema) in cases {
+        let warned = run(id, p);
+        let warnings = warned["param_warnings"].as_array().cloned().unwrap_or_default();
+        assert!(warnings.len() == 1 && warnings[0].as_str().is_some_and(|w| w.contains(key)), "{id}: {warned}");
+        assert!(conforms(schema.as_value(), schema.as_value(), &warned), "{id}: {warned}");
+    }
+}
+
+/// An unknown key is refused by `component.create` as before (its own message lists the
+/// accepted parameters), at every check level but strict, where the check names the key first.
+#[test]
+fn create_refuses_an_unknown_key_as_before() {
+    for level in ParamCheck::ALL {
+        let mut s = Session { param_check: level, ..Session::default() };
+        let e = s.execute("component.create", &json!({"nme": "A"})).unwrap_err().to_string();
+        assert!(e.contains("unknown parameter `nme`") ^ (level == ParamCheck::Strict), "{level:?}: {e}");
+        assert!(e.contains("nme"), "{e}");
+    }
+    let mut s = Session::default();
+    let e = s.execute("component.create", &json!({"bodies": ["A"]})).unwrap_err().to_string();
+    assert!(e.contains("use component.move_bodies or component.from_bodies"), "{e}");
 }
 
 #[test]
diff --git a/crates/engine/src/schema/unconverted.txt b/crates/engine/src/schema/unconverted.txt
index 375d3c8abf..cdd7e2aefb 100644
--- a/crates/engine/src/schema/unconverted.txt
+++ b/crates/engine/src/schema/unconverted.txt
@@ -2,19 +2,11 @@
 # (coverage_tests.rs). This list only shrinks: when you give a command its contract and output
 # type, remove its line. Never add one: a new command comes with both schemas. Sorted, one id
 # per line.
-component.activate
 component.capture_position
-component.create
-component.delete
-component.from_bodies
-component.list
 component.move_bodies
 component.move_sketches
 component.paste_new
-component.properties
-component.rename
 component.revert_position
-component.unlock
 doc.open
 doc.recover
 doc.recovery_discard