Templated actions; places are pickable in the gesture input

action: /shape/{curve.key} fills placeholders from the submitted
responses and must land on a dynamic page (validated). The gesture
widget now treats relay 'place' (kept) and 'echo' (live presence)
frames as pickable options: picking one re-derives the input's key -
that place's decode becomes the ghost under the stroke and the answer
records {key: picked, own_key, selected_from, selected_distance}, the
labelled pair that later ranks places and calibrates the key. Dedupe
by key; an empty state when nothing is kept at the shape.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/content.rs

@@ -136,6 +136,43 @@ impl Question {
     }
 }
 
+/// An alternative's `action` may carry `{field}` / `{field.sub}`
+/// placeholders filled from the submitted responses - `/shape/{curve.key}`
+/// lands on the dynamic page `/shape/[key]` for the key the visitor's
+/// stroke was given. Returns `None` when a placeholder has no value
+/// (or a non-scalar one) in `responses`.
+pub fn template_action(action: &str, responses: &serde_json::Value) -> Option<String> {
+    let mut out = String::new();
+    let mut rest = action;
+    while let Some(start) = rest.find('{') {
+        out.push_str(&rest[..start]);
+        let end = rest[start..].find('}')? + start;
+        let path = &rest[start + 1..end];
+        let mut value = responses;
+        for seg in path.split('.') {
+            value = value.get(seg)?;
+        }
+        let scalar = match value {
+            serde_json::Value::String(s) => s.clone(),
+            serde_json::Value::Number(n) => n.to_string(),
+            serde_json::Value::Bool(b) => b.to_string(),
+            _ => return None,
+        };
+        if scalar.is_empty() {
+            return None;
+        }
+        // A URL segment: keep it to what a segment can carry.
+        let safe: String = scalar
+            .chars()
+            .map(|c| if c.is_ascii_alphanumeric() || "-_.".contains(c) { c } else { '-' })
+            .collect();
+        out.push_str(&safe);
+        rest = &rest[end + 1..];
+    }
+    out.push_str(rest);
+    Some(out)
+}
+
 /// Descriptions are inline markdown: `[text](https://…)` links,
 /// `*emphasis*`, `**strong**`, `` `code` ``. Block structure is
 /// flattened (a description is one paragraph) and raw HTML in the
@@ -1053,6 +1090,26 @@ pub fn validate_questions(
             // A dangling action is a literal dead end: the submit
             // button navigates to "Nothing here".
             if let Some(action) = &alternative.action {
+                if action.contains('{') {
+                    // Placeholders are filled at submit time; the
+                    // shape must land on a dynamic page once filled.
+                    let probe = template_action(action, &serde_json::json!({}));
+                    let filled = {
+                        let mut a = action.clone();
+                        while let (Some(i), Some(j)) = (a.find('{'), a.find('}')) {
+                            a.replace_range(i..=j, "x");
+                        }
+                        a
+                    };
+                    let _ = probe;
+                    match resolve_question(questions, &filled) {
+                        Some(target) if target.is_dynamic() => continue,
+                        _ => anyhow::bail!(
+                            "question {:?} alternative {:?}: templated action {:?} must land on a dynamic page ([name].yaml)",
+                            question.id, alternative.name, action
+                        ),
+                    }
+                }
                 match questions.get(action) {
                     None => anyhow::bail!(
                         "question {:?} alternative {:?}: action {:?} does not match any declared question id",
@@ -1950,4 +2007,16 @@ alternatives:
         assert_eq!(render_inline_markdown("[ok](/shape)"), "<a href=\"/shape\">ok</a>");
         assert_eq!(render_inline_markdown("[mail](mailto:bl@uhhm.no)"), "<a href=\"mailto:bl@uhhm.no\">mail</a>");
     }
+
+    #[test]
+    fn action_templates_from_responses() {
+        let r = serde_json::json!({"curve": {"key": "20aa98", "points": [[0,0]]}, "n": 3});
+        assert_eq!(template_action("/shape/{curve.key}", &r).as_deref(), Some("/shape/20aa98"));
+        assert_eq!(template_action("/x/{n}/y", &r).as_deref(), Some("/x/3/y"));
+        assert_eq!(template_action("/shape", &r).as_deref(), Some("/shape"));
+        assert!(template_action("/shape/{curve.missing}", &r).is_none());
+        assert!(template_action("/shape/{curve.points}", &r).is_none());
+        let odd = serde_json::json!({"k": "a/b c"});
+        assert_eq!(template_action("/p/{k}", &odd).as_deref(), Some("/p/a-b-c"));
+    }
 }