Variables: selecting a data set reports the area type it overflows

dataset.select, dataset.next and dataset.prev rewrite bound type with
the data set's text but replied only {name, applied, skipped}. A long
value could push lines out of a fixed frame and the reply had no
overflow key, while text.setText answers overflow: [id] for the same
text.

The three commands now add overflow: [id...] with the area type and
type on a path whose text they rewrote and that doesn't fit, through
typecmd::with_overflow, as text.setText does. An object that two text
variables rewrite is named once. Type that the data set left alone is
not named, and the key is left out when all of the rewritten text
fits.

Docs: docs/mcp.md, docs/target-app-parity.md.

crates/engine/src/cmd/variablecmds.rs

@@ -430,7 +430,7 @@ fn dataset_list(s: &mut Session, _p: &Value) -> Result<Value> {
 
 fn apply_dataset(s: &mut Session, name: &str) -> Result<Value> {
     const C: &str = "dataset.select";
-    let (applied, skipped) = s.edit("Apply Data Set", |d, sel| {
+    let (applied, skipped, mut typed) = s.edit("Apply Data Set", |d, sel| {
         let ds = d.variables.dataset(name).cloned().ok_or_else(|| bad(C, format!("no dataset named `{name}`")))?;
         // One object may be driven by several variables; walk them in definition order, so two
         // text variables on the same object land the later one's value and both are counted.
@@ -462,6 +462,8 @@ fn apply_dataset(s: &mut Session, name: &str) -> Result<Value> {
         });
         let mut applied = 0usize;
         let mut skipped = 0usize;
+        // Collects the type objects whose text the row rewrote, for the reply's `overflow`.
+        let mut typed = Vec::new();
         for (id, var) in pairs {
             // A binding whose variable is gone, whose value this row doesn't carry, or whose
             // value doesn't fit the variable's kind, is left alone and counted, never
@@ -483,7 +485,10 @@ fn apply_dataset(s: &mut Session, name: &str) -> Result<Value> {
             let done = match (kind, &value) {
                 // The Type tool's own whole-range replace, so a dataset's text is styled and
                 // laid out exactly as typing it would be.
-                (VariableKind::Text, DataValue::Text(text)) => set_plain_text(d, id, text).is_ok(),
+                (VariableKind::Text, DataValue::Text(text)) => set_plain_text(d, id, text).is_ok_and(|()| {
+                    typed.push(id);
+                    true
+                }),
                 (VariableKind::Visibility, DataValue::Visible(show)) => d.node_mut(id).is_some_and(|n| {
                     n.visible = *show;
                     true
@@ -502,9 +507,12 @@ fn apply_dataset(s: &mut Session, name: &str) -> Result<Value> {
         d.variables.active_dataset = Some(name.to_string());
         // Every selected object left hidden or locked, such as one the row hid, is deselected.
         sel.deselect_uneditable(d);
-        Ok((applied, skipped))
+        Ok((applied, skipped, typed))
     })?;
-    Ok(json!({"name": name, "applied": applied, "skipped": skipped}))
+    // Two text variables on one object rewrite it twice; it is named once.
+    typed.sort_unstable();
+    typed.dedup();
+    Ok(super::typecmd::with_overflow(s, &typed, json!({"name": name, "applied": applied, "skipped": skipped})))
 }
 
 fn dataset_select(s: &mut Session, p: &Value) -> Result<Value> {
@@ -912,7 +920,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Select Data Set",
             ["Window", "Variables"],
             None,
-            "{name} apply a dataset in one undo step, deselecting every selected object left hidden or locked (the key object too) → {applied, skipped}",
+            "{name} apply a dataset in one undo step, deselecting every selected object left hidden or locked (the key object too) → {applied, skipped, overflow?: [id…] (area type and type on a path whose text it rewrote and that no longer fits; left out when all fits)}",
             has_doc,
             dataset_select
         ),