@almadar/std 17.0.2 → 17.1.0

package/behaviors/lolo/codec/atoms/std-lolo-rust.lolo

@@ -29,7 +29,7 @@ orbital LoloRustOrbital {
       indexedVars: "({{index}}, {{item}})"
       unsupportedForm: "_unsupported(&{{op}})"
       unsupportedWarn: "no {{language}} template for operator {{op}}"
-      helpers: { "/": ["fn _div(a: f64, b: f64) -> Option<f64> { if b == 0.0 { None } else { Some(a / b) } }"], "%": ["fn _mod(a: f64, b: f64) -> Option<f64> { if b == 0.0 { None } else { Some(a % b) } }"], "math/mod": ["fn _mod(a: f64, b: f64) -> Option<f64> { if b == 0.0 { None } else { Some(a % b) } }"], "default": ["trait _OrDefault<T> { fn _or_default(self, d: T) -> T; }\nimpl<T> _OrDefault<T> for Option<T> { fn _or_default(self, d: T) -> T { self.unwrap_or(d) } }\nimpl<T> _OrDefault<T> for T { fn _or_default(self, _d: T) -> T { self } }\nfn _default<T, V: _OrDefault<T>>(v: V, d: T) -> T { v._or_default(d) }"], "str/concat": ["fn _num_text(x: f64) -> String {\n    if x.is_nan() { return \"NaN\".to_string(); }\n    if x.is_infinite() { return (if x > 0.0 { \"Infinity\" } else { \"-Infinity\" }).to_string(); }\n    if x == 0.0 { return \"0\".to_string(); }\n    let a = x.abs();\n    if a >= 1e21 || a < 1e-6 {\n        let s = format!(\"{:e}\", x);\n        return match s.split_once('e') {\n            Some((m, e)) => if e.starts_with('-') { format!(\"{}e{}\", m, e) } else { format!(\"{}e+{}\", m, e) },\n            None => s,\n        };\n    }\n    format!(\"{}\", x)\n}", "trait _Text { fn _text(&self) -> String; }\nimpl _Text for String { fn _text(&self) -> String { self.clone() } }\nimpl _Text for bool { fn _text(&self) -> String { (if *self { \"true\" } else { \"false\" }).to_string() } }\nimpl _Text for f64 { fn _text(&self) -> String { _num_text(*self) } }", "macro_rules! _concat {\n    ($($x:expr),+ $(,)?) => {{\n        let mut s_ = String::new();\n        $( s_.push_str(&_Text::_text(&$x)); )+\n        s_\n    }};\n}"], "str/join": ["fn _num_text(x: f64) -> String {\n    if x.is_nan() { return \"NaN\".to_string(); }\n    if x.is_infinite() { return (if x > 0.0 { \"Infinity\" } else { \"-Infinity\" }).to_string(); }\n    if x == 0.0 { return \"0\".to_string(); }\n    let a = x.abs();\n    if a >= 1e21 || a < 1e-6 {\n        let s = format!(\"{:e}\", x);\n        return match s.split_once('e') {\n            Some((m, e)) => if e.starts_with('-') { format!(\"{}e{}\", m, e) } else { format!(\"{}e+{}\", m, e) },\n            None => s,\n        };\n    }\n    format!(\"{}\", x)\n}", "trait _Text { fn _text(&self) -> String; }\nimpl _Text for String { fn _text(&self) -> String { self.clone() } }\nimpl _Text for bool { fn _text(&self) -> String { (if *self { \"true\" } else { \"false\" }).to_string() } }\nimpl _Text for f64 { fn _text(&self) -> String { _num_text(*self) } }", "fn _join<T: _Text>(a: &[T], d: &str) -> String { a.iter().map(|x| x._text()).collect::<Vec<_>>().join(d) }"], "str/split": ["fn _split(s: &str, d: &str) -> Vec<String> {\n    if d.is_empty() { s.chars().map(|c| c.to_string()).collect() } else { s.split(d).map(|p| p.to_string()).collect() }\n}"], "str/slice": ["fn _whole(x: f64) -> i64 {\n    if !x.is_finite() || x != x.trunc() { panic!(\"expected a whole number, got {}\", x); }\n    x as i64\n}", "fn _str_slice(s: &str, a: f64, b: Option<f64>) -> String {\n    let c: Vec<char> = s.chars().collect();\n    let n = c.len() as i64;\n    let norm = |i: i64| -> i64 { if i < 0 { (n + i).max(0) } else { i.min(n) } };\n    let st = norm(_whole(a));\n    let en = match b { Some(v) => norm(_whole(v)), None => n };\n    if en <= st { String::new() } else { c[st as usize..en as usize].iter().collect() }\n}"], "str/padStart": ["fn _whole(x: f64) -> i64 {\n    if !x.is_finite() || x != x.trunc() { panic!(\"expected a whole number, got {}\", x); }\n    x as i64\n}", "fn _pad_start(s: &str, n: f64, p: &str) -> String {\n    if p.chars().count() != 1 { panic!(\"expected a single padding character, got {:?}\", p); }\n    let w = _whole(n);\n    let len = s.chars().count() as i64;\n    if w <= len { return s.to_string(); }\n    let pad: String = std::iter::repeat(p).take((w - len) as usize).collect();\n    format!(\"{}{}\", pad, s)\n}"], "str/padEnd": ["fn _whole(x: f64) -> i64 {\n    if !x.is_finite() || x != x.trunc() { panic!(\"expected a whole number, got {}\", x); }\n    x as i64\n}", "fn _pad_end(s: &str, n: f64, p: &str) -> String {\n    if p.chars().count() != 1 { panic!(\"expected a single padding character, got {:?}\", p); }\n    let w = _whole(n);\n    let len = s.chars().count() as i64;\n    if w <= len { return s.to_string(); }\n    let pad: String = std::iter::repeat(p).take((w - len) as usize).collect();\n    format!(\"{}{}\", s, pad)\n}"], "str/truncate": ["fn _whole(x: f64) -> i64 {\n    if !x.is_finite() || x != x.trunc() { panic!(\"expected a whole number, got {}\", x); }\n    x as i64\n}", "fn _truncate(s: &str, n: f64, suffix: &str) -> String {\n    let w = _whole(n);\n    if (s.chars().count() as i64) <= w { return s.to_string(); }\n    let head: String = s.chars().take(w.max(0) as usize).collect();\n    format!(\"{}{}\", head, suffix)\n}"], "str/repeat": ["fn _count(x: f64) -> usize {\n    if !x.is_finite() || x != x.trunc() || x < 0.0 { panic!(\"count is not a whole number from 0\"); }\n    x as usize\n}", "fn _repeat(s: &str, n: f64) -> String { s.repeat(_count(n)) }"], "str/capitalize": ["fn _capitalize(s: &str) -> String {\n    let mut c = s.chars();\n    match c.next() {\n        Some(f) => f.to_uppercase().collect::<String>() + &c.as_str().to_lowercase(),\n        None => String::new(),\n    }\n}"], "str/to-int": ["fn _to_int(s: &str) -> Option<f64> { s.parse::<i64>().ok().map(|v| v as f64) }"], "array/sum": ["fn _sum(a: &[f64]) -> f64 { a.iter().fold(0.0_f64, |s, x| s + x) }"], "array/avg": ["fn _avg(a: &[f64]) -> Option<f64> { if a.is_empty() { None } else { Some(a.iter().fold(0.0_f64, |s, x| s + x) / a.len() as f64) } }"], "array/max": ["fn _amax(a: &[f64]) -> Option<f64> { a.iter().cloned().fold(None, |m, x| Some(match m { Some(y) => if x > y { x } else { y }, None => x })) }"], "array/min": ["fn _amin(a: &[f64]) -> Option<f64> { a.iter().cloned().fold(None, |m, x| Some(match m { Some(y) => if x < y { x } else { y }, None => x })) }"], "array/first": ["fn _first<T: Clone>(a: &[T]) -> Option<T> { a.first().cloned() }"], "array/last": ["fn _last<T: Clone>(a: &[T]) -> Option<T> { a.last().cloned() }"], "array/nth": ["fn _nth<T: Clone>(a: &[T], i: f64) -> Option<T> {\n    if !i.is_finite() || i != i.trunc() || i < 0.0 { panic!(\"nth: index {} is not a whole number from 0\", i); }\n    a.get(i as usize).cloned()\n}"], "array/range": ["fn _range(a: f64, b: f64, step: f64) -> Vec<f64> {\n    if step == 0.0 || !step.is_finite() { panic!(\"range: step 0 must be a non-zero finite number\"); }\n    let mut out = Vec::new();\n    let mut x = a;\n    while if step > 0.0 { x < b } else { x > b } { out.push(x); x += step; }\n    out\n}"], "array/slice": ["fn _whole(x: f64) -> i64 {\n    if !x.is_finite() || x != x.trunc() { panic!(\"expected a whole number, got {}\", x); }\n    x as i64\n}", "fn _slice<T: Clone>(a: &[T], s: f64, e: Option<f64>) -> Vec<T> {\n    let st = _whole(s);\n    let en = e.map(_whole);\n    if st < 0 || en.map_or(false, |v| v < 0) { panic!(\"slice: not a whole number from 0\"); }\n    let st = (st as usize).min(a.len());\n    let en = en.map_or(a.len(), |v| (v as usize).min(a.len()));\n    if en <= st { Vec::new() } else { a[st..en].to_vec() }\n}"], "array/take": ["fn _count(x: f64) -> usize {\n    if !x.is_finite() || x != x.trunc() || x < 0.0 { panic!(\"count is not a whole number from 0\"); }\n    x as usize\n}", "fn _take<T: Clone>(a: &[T], n: f64) -> Vec<T> { a.iter().take(_count(n)).cloned().collect() }"], "array/drop": ["fn _count(x: f64) -> usize {\n    if !x.is_finite() || x != x.trunc() || x < 0.0 { panic!(\"count is not a whole number from 0\"); }\n    x as usize\n}", "fn _drop<T: Clone>(a: &[T], n: f64) -> Vec<T> { a.iter().skip(_count(n)).cloned().collect() }"], "array/takeLast": ["fn _count(x: f64) -> usize {\n    if !x.is_finite() || x != x.trunc() || x < 0.0 { panic!(\"count is not a whole number from 0\"); }\n    x as usize\n}", "fn _take_last<T: Clone>(a: &[T], n: f64) -> Vec<T> { let k = _count(n).min(a.len()); a[a.len() - k..].to_vec() }"], "array/dropLast": ["fn _count(x: f64) -> usize {\n    if !x.is_finite() || x != x.trunc() || x < 0.0 { panic!(\"count is not a whole number from 0\"); }\n    x as usize\n}", "fn _drop_last<T: Clone>(a: &[T], n: f64) -> Vec<T> { let k = _count(n).min(a.len()); a[..a.len() - k].to_vec() }"], "array/append": ["fn _append<T: Clone>(a: &[T], x: T) -> Vec<T> { let mut v = a.to_vec(); v.push(x); v }"], "array/prepend": ["fn _prepend<T: Clone>(a: &[T], x: T) -> Vec<T> { let mut v = vec![x]; v.extend(a.iter().cloned()); v }"], "array/indexOf": ["fn _index_of<T: PartialEq>(a: &[T], x: &T) -> f64 { a.iter().position(|y| y == x).map_or(-1.0, |i| i as f64) }"], "array/unique": ["fn _unique<T: Clone + PartialEq>(a: &[T]) -> Vec<T> {\n    let mut out: Vec<T> = Vec::new();\n    for x in a { if !out.contains(x) { out.push(x.clone()); } }\n    out\n}"], "array/flatten": ["fn _flatten<T: Clone>(a: &[Vec<T>]) -> Vec<T> { a.iter().flat_map(|v| v.iter().cloned()).collect() }"], "array/zip": ["fn _zip<T: Clone>(a: &[T], b: &[T]) -> Vec<Vec<T>> { a.iter().cloned().zip(b.iter().cloned()).map(|(x, y)| vec![x, y]).collect() }"], "array/concat": ["macro_rules! _vconcat {\n    ($($x:expr),+ $(,)?) => {{\n        let mut v_ = Vec::new();\n        $( v_.extend($x.iter().cloned()); )+\n        v_\n    }};\n}"], "array/sort": ["fn _sort<T: Clone + PartialOrd>(a: &[T]) -> Vec<T> {\n    let mut v = a.to_vec();\n    v.sort_by(|x, y| x.partial_cmp(y).unwrap_or(std::cmp::Ordering::Equal));\n    v\n}"], "array/reduce": ["fn _reduce<T: Clone, A>(a: &[T], init: A, f: impl Fn(A, T) -> A) -> A { a.iter().cloned().fold(init, f) }"], "math/round": ["fn _round(x: f64, d: f64) -> f64 {\n    let m = 10.0_f64.powf(d);\n    let r = (x.abs() * m + 0.5).floor() / m;\n    if x < 0.0 { -r } else { r }\n}"], "math/acos": ["fn _acos(x: f64) -> Option<f64> { if (-1.0..=1.0).contains(&x) { Some(x.acos()) } else { None } }"], "math/asin": ["fn _asin(x: f64) -> Option<f64> { if (-1.0..=1.0).contains(&x) { Some(x.asin()) } else { None } }"], "math/approach": ["fn _approach(c: f64, t: f64, d: f64) -> f64 { if (t - c).abs() <= d { t } else { c + (t - c).signum() * d } }"], "math/map": ["fn _map(v: f64, a: f64, b: f64, c: f64, d: f64) -> f64 { if b == a { c } else { c + (v - a) / (b - a) * (d - c) } }"], "math/wrap": ["fn _wrap(v: f64, lo: f64, hi: f64) -> f64 {\n    let r = hi - lo;\n    if r <= 0.0 { lo } else { ((v - lo) % r + r) % r + lo }\n}"], "array/insert": ["fn _whole(x: f64) -> i64 {\n    if !x.is_finite() || x != x.trunc() { panic!(\"expected a whole number, got {}\", x); }\n    x as i64\n}", "fn _insert<T: Clone>(a: &[T], i: f64, x: T) -> Vec<T> {\n    let k = _whole(i);\n    if k < 0 || k as usize > a.len() { panic!(\"insert: index {} is not within a {}-item array\", k, a.len()); }\n    let mut v = a.to_vec();\n    v.insert(k as usize, x);\n    v\n}"], "array/remove": ["fn _whole(x: f64) -> i64 {\n    if !x.is_finite() || x != x.trunc() { panic!(\"expected a whole number, got {}\", x); }\n    x as i64\n}", "fn _remove<T: Clone>(a: &[T], i: f64) -> Vec<T> {\n    let k = _whole(i);\n    if k < 0 || k as usize >= a.len() { panic!(\"remove: index {} is outside a {}-item array\", k, a.len()); }\n    let mut v = a.to_vec();\n    v.remove(k as usize);\n    v\n}"], "array/removeItem": ["fn _remove_item<T: Clone + PartialEq>(a: &[T], x: &T) -> Vec<T> {\n    let mut v = a.to_vec();\n    if let Some(p) = v.iter().position(|y| y == x) { v.remove(p); }\n    v\n}"], "math/sqrt": ["fn _sqrt(x: f64) -> Option<f64> { if x < 0.0 { None } else { Some(x.sqrt()) } }"], "math/ln": ["fn _ln(x: f64) -> Option<f64> { if x <= 0.0 { None } else { Some(x.ln()) } }"], "math/log10": ["fn _log10(x: f64) -> Option<f64> { if x <= 0.0 { None } else { Some(x.log10()) } }"], "math/pow": ["fn _pow(a: f64, b: f64) -> Option<f64> { let r = a.powf(b); if r.is_finite() { Some(r) } else { None } }"], "math/sign": ["fn _sign(x: f64) -> f64 { if x > 0.0 { 1.0 } else if x < 0.0 { -1.0 } else { 0.0 } }"], "object/get": ["fn _get<V: Clone>(m: &std::collections::BTreeMap<String, V>, k: &str) -> Option<V> { m.get(k).cloned() }"], "object/merge": ["fn _merge<V: Clone>(a: &std::collections::BTreeMap<String, V>, b: &std::collections::BTreeMap<String, V>) -> std::collections::BTreeMap<String, V> {\n    let mut m = a.clone();\n    for (k, v) in b { m.insert(k.clone(), v.clone()); }\n    m\n}"], "object/pick": ["fn _pick<V: Clone>(m: &std::collections::BTreeMap<String, V>, ks: &[String]) -> std::collections::BTreeMap<String, V> {\n    m.iter().filter(|(k, _)| ks.contains(k)).map(|(k, v)| (k.clone(), v.clone())).collect()\n}"], "object/omit": ["fn _omit<V: Clone>(m: &std::collections::BTreeMap<String, V>, ks: &[String]) -> std::collections::BTreeMap<String, V> {\n    m.iter().filter(|(k, _)| !ks.contains(k)).map(|(k, v)| (k.clone(), v.clone())).collect()\n}"], "unsupported": ["#[derive(Clone)]\nstruct _U;\nfn _unsupported(op: &str) -> _U { panic!(\"no native template for operator {}\", op) }\nimpl From<_U> for f64 { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl From<_U> for String { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl From<_U> for bool { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl From<_U> for Option<f64> { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl From<_U> for Option<String> { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl From<_U> for Option<bool> { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl<T> From<_U> for Vec<T> { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl<T> From<_U> for Option<Vec<T>> { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl<K: Ord, V> From<_U> for std::collections::BTreeMap<K, V> { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl<K: Ord, V> From<_U> for Option<std::collections::BTreeMap<K, V>> { fn from(_: _U) -> Self { panic!(\"unsupported\") } }"] }
+      helpers: { "store": ["pub trait Store {\n    fn persist(&mut self, op: &str, entity: &str, data: serde_json::Value) -> (bool, serde_json::Value);\n    fn fetch(&mut self, entity: &str, keep: Option<&dyn Fn(&serde_json::Map<String, serde_json::Value>) -> bool>) -> (bool, serde_json::Value);\n}\n\nfn _order(a: &serde_json::Map<String, serde_json::Value>, b: &serde_json::Map<String, serde_json::Value>) -> std::cmp::Ordering {\n    let (sa, sb) = (a.get(\"createdAt\").filter(|v| !v.is_null()), b.get(\"createdAt\").filter(|v| !v.is_null()));\n    let by_stamp = match (sa, sb) {\n        (Some(_), None) => std::cmp::Ordering::Less,\n        (None, Some(_)) => std::cmp::Ordering::Greater,\n        (Some(x), Some(y)) => match (x.as_f64(), y.as_f64(), x.as_str(), y.as_str()) {\n            (Some(p), Some(q), _, _) => p.partial_cmp(&q).unwrap_or(std::cmp::Ordering::Equal),\n            (_, _, Some(p), Some(q)) => p.cmp(q),\n            _ => std::cmp::Ordering::Equal,\n        },\n        (None, None) => std::cmp::Ordering::Equal,\n    };\n    let id = |m: &serde_json::Map<String, serde_json::Value>| m.get(\"id\").and_then(|v| v.as_str()).unwrap_or(\"\").to_string();\n    by_stamp.then_with(|| id(a).cmp(&id(b)))\n}\n\n#[derive(Default)]\npub struct MemoryStore {\n    tables: std::collections::BTreeMap<String, Vec<(String, serde_json::Map<String, serde_json::Value>)>>,\n    minted: u64,\n}\n\nimpl Store for MemoryStore {\n    fn persist(&mut self, op: &str, entity: &str, data: serde_json::Value) -> (bool, serde_json::Value) {\n        let rows = self.tables.entry(entity.to_string()).or_default();\n        if op == \"create\" {\n            let mut row = data.as_object().cloned().unwrap_or_default();\n            let id = match row.get(\"id\").and_then(|v| v.as_str()).filter(|v| !v.is_empty()) {\n                Some(v) => v.to_string(),\n                None => {\n                    self.minted += 1;\n                    format!(\"{}-{}\", entity, self.minted)\n                }\n            };\n            row.insert(\"id\".to_string(), serde_json::Value::String(id.clone()));\n            rows.push((id, row.clone()));\n            return (true, serde_json::Value::Object(row));\n        }\n        let key = match &data {\n            serde_json::Value::String(v) => v.clone(),\n            v => v.get(\"id\").and_then(|x| x.as_str()).unwrap_or(\"\").to_string(),\n        };\n        let Some(pos) = rows.iter().position(|(k, _)| *k == key) else {\n            return (false, serde_json::json!({ \"error\": format!(\"{} {} not found\", entity, key), \"code\": \"not-found\" }));\n        };\n        if op == \"delete\" {\n            rows.remove(pos);\n            return (true, serde_json::json!({ \"id\": key, \"deleted\": true }));\n        }\n        if let Some(obj) = data.as_object() {\n            for (k, v) in obj {\n                rows[pos].1.insert(k.clone(), v.clone());\n            }\n        }\n        (true, serde_json::Value::Object(rows[pos].1.clone()))\n    }\n\n    fn fetch(&mut self, entity: &str, keep: Option<&dyn Fn(&serde_json::Map<String, serde_json::Value>) -> bool>) -> (bool, serde_json::Value) {\n        let mut rows: Vec<serde_json::Map<String, serde_json::Value>> = self.tables.get(entity).map_or_else(Vec::new, |t| t.iter().map(|(_, r)| r.clone()).collect());\n        rows.retain(|r| keep.map_or(true, |k| k(r)));\n        rows.sort_by(_order);\n        let n = rows.len();\n        (true, serde_json::json!({ \"data\": rows, \"totalCount\": n }))\n    }\n}\n\nmacro_rules! _routed_store {\n    ($t:ty) => {\n        impl _Routed for $t {\n            fn state(&self) -> String { self.state.clone() }\n            fn entity_json(&self) -> serde_json::Value { serde_json::to_value(&self.entity).unwrap_or(serde_json::Value::Null) }\n            fn emitted_len(&self) -> usize { self.emitted.len() }\n            fn emitted_from(&self, n: usize) -> Vec<(String, serde_json::Value, bool)> {\n                self.emitted[n..].iter().enumerate().map(|(j, (e, p))| (e.clone(), p.clone().unwrap_or_else(|| serde_json::json!({})), self.completed.contains(&(n + j)))).collect()\n            }\n            fn as_any(&mut self) -> &mut dyn std::any::Any { self }\n        }\n    };\n}"], "router": ["trait _Routed {\n    fn state(&self) -> String;\n    fn entity_json(&self) -> serde_json::Value;\n    fn emitted_len(&self) -> usize;\n    fn emitted_from(&self, n: usize) -> Vec<(String, serde_json::Value, bool)>;\n    fn as_any(&mut self) -> &mut dyn std::any::Any;\n}\n\nmacro_rules! _routed {\n    ($t:ty) => {\n        impl _Routed for $t {\n            fn state(&self) -> String { self.state.clone() }\n            fn entity_json(&self) -> serde_json::Value { serde_json::to_value(&self.entity).unwrap_or(serde_json::Value::Null) }\n            fn emitted_len(&self) -> usize { self.emitted.len() }\n            fn emitted_from(&self, n: usize) -> Vec<(String, serde_json::Value, bool)> {\n                self.emitted[n..].iter().map(|(e, p)| (e.clone(), p.clone().unwrap_or_else(|| serde_json::json!({})), false)).collect()\n            }\n            fn as_any(&mut self) -> &mut dyn std::any::Any { self }\n        }\n    };\n}\n\nfn _decode<T: serde::de::DeserializeOwned>(payload: &serde_json::Value) -> T {\n    serde_json::from_value(payload.clone()).expect(\"a payload of the declared shape\")\n}\n\ntype _Guard = fn(&serde_json::Value) -> bool;\ntype _Map = fn(&serde_json::Value) -> serde_json::Value;\n\nstruct _Item {\n    target: String,\n    event: String,\n    payload: serde_json::Value,\n    source: serde_json::Value,\n    guard: Option<_Guard>,\n    fans: bool,\n    completion: bool,\n}\n\n#[derive(Default)]\npub struct _Router {\n    traits: Vec<(String, Box<dyn _Routed>)>,\n    pub handles: std::collections::HashMap<String, std::collections::BTreeMap<String, Vec<String>>>,\n    rows: Vec<(String, String, String, String, Option<_Guard>, Option<_Map>)>,\n    pub log: Vec<(String, String, serde_json::Value)>,\n}\n\nimpl _Router {\n    fn add(&mut self, key: String, trait_: Box<dyn _Routed>) {\n        self.traits.push((key, trait_));\n    }\n\n    fn row(&mut self, source: String, event: String, target: String, trigger: String, guard: Option<_Guard>, mapping: Option<_Map>) {\n        self.rows.push((source, event, target, trigger, guard, mapping));\n    }\n\n    fn find(&mut self, key: &str) -> Option<&mut Box<dyn _Routed>> {\n        self.traits.iter_mut().find(|(k, _)| k == key).map(|(_, t)| t)\n    }\n\n    pub fn entity_of(&mut self, key: &str) -> serde_json::Value {\n        self.find(key).map_or(serde_json::Value::Null, |t| t.entity_json())\n    }\n\n    fn get<T: 'static>(&mut self, key: &str) -> Option<&mut T> {\n        self.find(key).and_then(|t| t.as_any().downcast_mut::<T>())\n    }\n\n    fn targets(&self, source: &str, event: &str, payload: &serde_json::Value, completion: bool) -> Vec<_Item> {\n        self.rows\n            .iter()\n            .filter(|(s, e, ..)| s == source && e == event)\n            .map(|(_, _, target, trigger, guard, mapping)| _Item {\n                target: target.clone(),\n                event: trigger.clone(),\n                payload: mapping.map_or_else(|| payload.clone(), |m| m(payload)),\n                source: payload.clone(),\n                guard: *guard,\n                fans: false,\n                completion,\n            })\n            .collect()\n    }\n}\n\ntrait _Program {\n    fn router(&mut self) -> &mut _Router;\n    fn deliver(&mut self, target: &str, event: &str, payload: &serde_json::Value);\n}\n\nfn _dispatch<P: _Program>(program: &mut P, trait_: &str, event: &str, payload: serde_json::Value) {\n    let mut queue = std::collections::VecDeque::from(vec![_Item {\n        target: trait_.to_string(),\n        event: event.to_string(),\n        payload: payload.clone(),\n        source: payload,\n        guard: None,\n        fans: true,\n        completion: false,\n    }]);\n    let mut seen = std::collections::HashSet::new();\n    let mut steps = 0;\n    while let Some(item) = queue.pop_front() {\n        let Some((state, entity)) = program.router().find(&item.target).map(|t| (t.state(), t.entity_json())) else { continue };\n        let key = serde_json::json!([item.target, item.event, state, item.payload, entity]).to_string();\n        if !item.completion && seen.contains(&key) {\n            continue;\n        }\n        if let Some(guard) = item.guard {\n            if !guard(&item.source) {\n                continue;\n            }\n        }\n        if steps >= 2000 {\n            break;\n        }\n        steps += 1;\n        seen.insert(key);\n        let n = program.router().find(&item.target).map_or(0, |t| t.emitted_len());\n        program.deliver(&item.target, &item.event, &item.payload);\n        let router = program.router();\n        let mut fanned = if item.fans { router.targets(&item.target, &item.event, &item.payload, false) } else { Vec::new() };\n        let (new_state, emits) = router.find(&item.target).map_or((String::new(), Vec::new()), |t| (t.state(), t.emitted_from(n)));\n        let mut own = Vec::new();\n        for (ev, out, completion) in emits {\n            router.log.push((item.target.clone(), ev.clone(), out.clone()));\n            if router.handles.get(&item.target).and_then(|h| h.get(&new_state)).is_some_and(|evs| evs.contains(&ev)) {\n                own.push(_Item { target: item.target.clone(), event: ev.clone(), payload: out.clone(), source: out.clone(), guard: None, fans: false, completion });\n            }\n            fanned.extend(router.targets(&item.target, &ev, &out, completion));\n        }\n        for x in own.into_iter().rev() {\n            queue.push_front(x);\n        }\n        queue.extend(fanned);\n    }\n}"], "/": ["fn _div(a: f64, b: f64) -> Option<f64> { if b == 0.0 { None } else { Some(a / b) } }"], "%": ["fn _mod(a: f64, b: f64) -> Option<f64> { if b == 0.0 { None } else { Some(a % b) } }"], "math/mod": ["fn _mod(a: f64, b: f64) -> Option<f64> { if b == 0.0 { None } else { Some(a % b) } }"], "default": ["trait _OrDefault<T> { fn _or_default(self, d: T) -> T; }\nimpl<T> _OrDefault<T> for Option<T> { fn _or_default(self, d: T) -> T { self.unwrap_or(d) } }\nimpl<T> _OrDefault<T> for T { fn _or_default(self, _d: T) -> T { self } }\nfn _default<T, V: _OrDefault<T>>(v: V, d: T) -> T { v._or_default(d) }"], "str/concat": ["fn _num_text(x: f64) -> String {\n    if x.is_nan() { return \"NaN\".to_string(); }\n    if x.is_infinite() { return (if x > 0.0 { \"Infinity\" } else { \"-Infinity\" }).to_string(); }\n    if x == 0.0 { return \"0\".to_string(); }\n    let a = x.abs();\n    if a >= 1e21 || a < 1e-6 {\n        let s = format!(\"{:e}\", x);\n        return match s.split_once('e') {\n            Some((m, e)) => if e.starts_with('-') { format!(\"{}e{}\", m, e) } else { format!(\"{}e+{}\", m, e) },\n            None => s,\n        };\n    }\n    format!(\"{}\", x)\n}", "trait _Text { fn _text(&self) -> String; }\nimpl _Text for String { fn _text(&self) -> String { self.clone() } }\nimpl _Text for bool { fn _text(&self) -> String { (if *self { \"true\" } else { \"false\" }).to_string() } }\nimpl _Text for f64 { fn _text(&self) -> String { _num_text(*self) } }", "macro_rules! _concat {\n    ($($x:expr),+ $(,)?) => {{\n        let mut s_ = String::new();\n        $( s_.push_str(&_Text::_text(&$x)); )+\n        s_\n    }};\n}"], "str/join": ["fn _num_text(x: f64) -> String {\n    if x.is_nan() { return \"NaN\".to_string(); }\n    if x.is_infinite() { return (if x > 0.0 { \"Infinity\" } else { \"-Infinity\" }).to_string(); }\n    if x == 0.0 { return \"0\".to_string(); }\n    let a = x.abs();\n    if a >= 1e21 || a < 1e-6 {\n        let s = format!(\"{:e}\", x);\n        return match s.split_once('e') {\n            Some((m, e)) => if e.starts_with('-') { format!(\"{}e{}\", m, e) } else { format!(\"{}e+{}\", m, e) },\n            None => s,\n        };\n    }\n    format!(\"{}\", x)\n}", "trait _Text { fn _text(&self) -> String; }\nimpl _Text for String { fn _text(&self) -> String { self.clone() } }\nimpl _Text for bool { fn _text(&self) -> String { (if *self { \"true\" } else { \"false\" }).to_string() } }\nimpl _Text for f64 { fn _text(&self) -> String { _num_text(*self) } }", "fn _join<T: _Text>(a: &[T], d: &str) -> String { a.iter().map(|x| x._text()).collect::<Vec<_>>().join(d) }"], "str/split": ["fn _split(s: &str, d: &str) -> Vec<String> {\n    if d.is_empty() { s.chars().map(|c| c.to_string()).collect() } else { s.split(d).map(|p| p.to_string()).collect() }\n}"], "str/slice": ["fn _whole(x: f64) -> i64 {\n    if !x.is_finite() || x != x.trunc() { panic!(\"expected a whole number, got {}\", x); }\n    x as i64\n}", "fn _str_slice(s: &str, a: f64, b: Option<f64>) -> String {\n    let c: Vec<char> = s.chars().collect();\n    let n = c.len() as i64;\n    let norm = |i: i64| -> i64 { if i < 0 { (n + i).max(0) } else { i.min(n) } };\n    let st = norm(_whole(a));\n    let en = match b { Some(v) => norm(_whole(v)), None => n };\n    if en <= st { String::new() } else { c[st as usize..en as usize].iter().collect() }\n}"], "str/padStart": ["fn _whole(x: f64) -> i64 {\n    if !x.is_finite() || x != x.trunc() { panic!(\"expected a whole number, got {}\", x); }\n    x as i64\n}", "fn _pad_start(s: &str, n: f64, p: &str) -> String {\n    if p.chars().count() != 1 { panic!(\"expected a single padding character, got {:?}\", p); }\n    let w = _whole(n);\n    let len = s.chars().count() as i64;\n    if w <= len { return s.to_string(); }\n    let pad: String = std::iter::repeat(p).take((w - len) as usize).collect();\n    format!(\"{}{}\", pad, s)\n}"], "str/padEnd": ["fn _whole(x: f64) -> i64 {\n    if !x.is_finite() || x != x.trunc() { panic!(\"expected a whole number, got {}\", x); }\n    x as i64\n}", "fn _pad_end(s: &str, n: f64, p: &str) -> String {\n    if p.chars().count() != 1 { panic!(\"expected a single padding character, got {:?}\", p); }\n    let w = _whole(n);\n    let len = s.chars().count() as i64;\n    if w <= len { return s.to_string(); }\n    let pad: String = std::iter::repeat(p).take((w - len) as usize).collect();\n    format!(\"{}{}\", s, pad)\n}"], "str/truncate": ["fn _whole(x: f64) -> i64 {\n    if !x.is_finite() || x != x.trunc() { panic!(\"expected a whole number, got {}\", x); }\n    x as i64\n}", "fn _truncate(s: &str, n: f64, suffix: &str) -> String {\n    let w = _whole(n);\n    if (s.chars().count() as i64) <= w { return s.to_string(); }\n    let head: String = s.chars().take(w.max(0) as usize).collect();\n    format!(\"{}{}\", head, suffix)\n}"], "str/repeat": ["fn _count(x: f64) -> usize {\n    if !x.is_finite() || x != x.trunc() || x < 0.0 { panic!(\"count is not a whole number from 0\"); }\n    x as usize\n}", "fn _repeat(s: &str, n: f64) -> String { s.repeat(_count(n)) }"], "str/capitalize": ["fn _capitalize(s: &str) -> String {\n    let mut c = s.chars();\n    match c.next() {\n        Some(f) => f.to_uppercase().collect::<String>() + &c.as_str().to_lowercase(),\n        None => String::new(),\n    }\n}"], "str/to-int": ["fn _to_int(s: &str) -> Option<f64> { s.parse::<i64>().ok().map(|v| v as f64) }"], "array/sum": ["fn _sum(a: &[f64]) -> f64 { a.iter().fold(0.0_f64, |s, x| s + x) }"], "array/avg": ["fn _avg(a: &[f64]) -> Option<f64> { if a.is_empty() { None } else { Some(a.iter().fold(0.0_f64, |s, x| s + x) / a.len() as f64) } }"], "array/max": ["fn _amax(a: &[f64]) -> Option<f64> { a.iter().cloned().fold(None, |m, x| Some(match m { Some(y) => if x > y { x } else { y }, None => x })) }"], "array/min": ["fn _amin(a: &[f64]) -> Option<f64> { a.iter().cloned().fold(None, |m, x| Some(match m { Some(y) => if x < y { x } else { y }, None => x })) }"], "array/first": ["fn _first<T: Clone>(a: &[T]) -> Option<T> { a.first().cloned() }"], "array/last": ["fn _last<T: Clone>(a: &[T]) -> Option<T> { a.last().cloned() }"], "array/nth": ["fn _nth<T: Clone>(a: &[T], i: f64) -> Option<T> {\n    if !i.is_finite() || i != i.trunc() || i < 0.0 { panic!(\"nth: index {} is not a whole number from 0\", i); }\n    a.get(i as usize).cloned()\n}"], "array/range": ["fn _range(a: f64, b: f64, step: f64) -> Vec<f64> {\n    if step == 0.0 || !step.is_finite() { panic!(\"range: step 0 must be a non-zero finite number\"); }\n    let mut out = Vec::new();\n    let mut x = a;\n    while if step > 0.0 { x < b } else { x > b } { out.push(x); x += step; }\n    out\n}"], "array/slice": ["fn _whole(x: f64) -> i64 {\n    if !x.is_finite() || x != x.trunc() { panic!(\"expected a whole number, got {}\", x); }\n    x as i64\n}", "fn _slice<T: Clone>(a: &[T], s: f64, e: Option<f64>) -> Vec<T> {\n    let st = _whole(s);\n    let en = e.map(_whole);\n    if st < 0 || en.map_or(false, |v| v < 0) { panic!(\"slice: not a whole number from 0\"); }\n    let st = (st as usize).min(a.len());\n    let en = en.map_or(a.len(), |v| (v as usize).min(a.len()));\n    if en <= st { Vec::new() } else { a[st..en].to_vec() }\n}"], "array/take": ["fn _count(x: f64) -> usize {\n    if !x.is_finite() || x != x.trunc() || x < 0.0 { panic!(\"count is not a whole number from 0\"); }\n    x as usize\n}", "fn _take<T: Clone>(a: &[T], n: f64) -> Vec<T> { a.iter().take(_count(n)).cloned().collect() }"], "array/drop": ["fn _count(x: f64) -> usize {\n    if !x.is_finite() || x != x.trunc() || x < 0.0 { panic!(\"count is not a whole number from 0\"); }\n    x as usize\n}", "fn _drop<T: Clone>(a: &[T], n: f64) -> Vec<T> { a.iter().skip(_count(n)).cloned().collect() }"], "array/takeLast": ["fn _count(x: f64) -> usize {\n    if !x.is_finite() || x != x.trunc() || x < 0.0 { panic!(\"count is not a whole number from 0\"); }\n    x as usize\n}", "fn _take_last<T: Clone>(a: &[T], n: f64) -> Vec<T> { let k = _count(n).min(a.len()); a[a.len() - k..].to_vec() }"], "array/dropLast": ["fn _count(x: f64) -> usize {\n    if !x.is_finite() || x != x.trunc() || x < 0.0 { panic!(\"count is not a whole number from 0\"); }\n    x as usize\n}", "fn _drop_last<T: Clone>(a: &[T], n: f64) -> Vec<T> { let k = _count(n).min(a.len()); a[..a.len() - k].to_vec() }"], "array/append": ["fn _append<T: Clone>(a: &[T], x: T) -> Vec<T> { let mut v = a.to_vec(); v.push(x); v }"], "array/prepend": ["fn _prepend<T: Clone>(a: &[T], x: T) -> Vec<T> { let mut v = vec![x]; v.extend(a.iter().cloned()); v }"], "array/indexOf": ["fn _index_of<T: PartialEq>(a: &[T], x: &T) -> f64 { a.iter().position(|y| y == x).map_or(-1.0, |i| i as f64) }"], "array/unique": ["fn _unique<T: Clone + PartialEq>(a: &[T]) -> Vec<T> {\n    let mut out: Vec<T> = Vec::new();\n    for x in a { if !out.contains(x) { out.push(x.clone()); } }\n    out\n}"], "array/flatten": ["fn _flatten<T: Clone>(a: &[Vec<T>]) -> Vec<T> { a.iter().flat_map(|v| v.iter().cloned()).collect() }"], "array/zip": ["fn _zip<T: Clone>(a: &[T], b: &[T]) -> Vec<Vec<T>> { a.iter().cloned().zip(b.iter().cloned()).map(|(x, y)| vec![x, y]).collect() }"], "array/concat": ["macro_rules! _vconcat {\n    ($($x:expr),+ $(,)?) => {{\n        let mut v_ = Vec::new();\n        $( v_.extend($x.iter().cloned()); )+\n        v_\n    }};\n}"], "array/sort": ["fn _sort<T: Clone + PartialOrd>(a: &[T]) -> Vec<T> {\n    let mut v = a.to_vec();\n    v.sort_by(|x, y| x.partial_cmp(y).unwrap_or(std::cmp::Ordering::Equal));\n    v\n}"], "array/reduce": ["fn _reduce<T: Clone, A>(a: &[T], init: A, f: impl Fn(A, T) -> A) -> A { a.iter().cloned().fold(init, f) }"], "math/round": ["fn _round(x: f64, d: f64) -> f64 {\n    let m = 10.0_f64.powf(d);\n    let r = (x.abs() * m + 0.5).floor() / m;\n    if x < 0.0 { -r } else { r }\n}"], "math/acos": ["fn _acos(x: f64) -> Option<f64> { if (-1.0..=1.0).contains(&x) { Some(x.acos()) } else { None } }"], "math/asin": ["fn _asin(x: f64) -> Option<f64> { if (-1.0..=1.0).contains(&x) { Some(x.asin()) } else { None } }"], "math/approach": ["fn _approach(c: f64, t: f64, d: f64) -> f64 { if (t - c).abs() <= d { t } else { c + (t - c).signum() * d } }"], "math/map": ["fn _map(v: f64, a: f64, b: f64, c: f64, d: f64) -> f64 { if b == a { c } else { c + (v - a) / (b - a) * (d - c) } }"], "math/wrap": ["fn _wrap(v: f64, lo: f64, hi: f64) -> f64 {\n    let r = hi - lo;\n    if r <= 0.0 { lo } else { ((v - lo) % r + r) % r + lo }\n}"], "array/insert": ["fn _whole(x: f64) -> i64 {\n    if !x.is_finite() || x != x.trunc() { panic!(\"expected a whole number, got {}\", x); }\n    x as i64\n}", "fn _insert<T: Clone>(a: &[T], i: f64, x: T) -> Vec<T> {\n    let k = _whole(i);\n    if k < 0 || k as usize > a.len() { panic!(\"insert: index {} is not within a {}-item array\", k, a.len()); }\n    let mut v = a.to_vec();\n    v.insert(k as usize, x);\n    v\n}"], "array/remove": ["fn _whole(x: f64) -> i64 {\n    if !x.is_finite() || x != x.trunc() { panic!(\"expected a whole number, got {}\", x); }\n    x as i64\n}", "fn _remove<T: Clone>(a: &[T], i: f64) -> Vec<T> {\n    let k = _whole(i);\n    if k < 0 || k as usize >= a.len() { panic!(\"remove: index {} is outside a {}-item array\", k, a.len()); }\n    let mut v = a.to_vec();\n    v.remove(k as usize);\n    v\n}"], "array/removeItem": ["fn _remove_item<T: Clone + PartialEq>(a: &[T], x: &T) -> Vec<T> {\n    let mut v = a.to_vec();\n    if let Some(p) = v.iter().position(|y| y == x) { v.remove(p); }\n    v\n}"], "math/sqrt": ["fn _sqrt(x: f64) -> Option<f64> { if x < 0.0 { None } else { Some(x.sqrt()) } }"], "math/ln": ["fn _ln(x: f64) -> Option<f64> { if x <= 0.0 { None } else { Some(x.ln()) } }"], "math/log10": ["fn _log10(x: f64) -> Option<f64> { if x <= 0.0 { None } else { Some(x.log10()) } }"], "math/pow": ["fn _pow(a: f64, b: f64) -> Option<f64> { let r = a.powf(b); if r.is_finite() { Some(r) } else { None } }"], "math/sign": ["fn _sign(x: f64) -> f64 { if x > 0.0 { 1.0 } else if x < 0.0 { -1.0 } else { 0.0 } }"], "object/get": ["trait _Lookup {\n    type Out;\n    fn lookup(&self, k: &str) -> Self::Out;\n}\nimpl<V: Clone> _Lookup for std::collections::BTreeMap<String, V> {\n    type Out = Option<V>;\n    fn lookup(&self, k: &str) -> Option<V> { self.get(k).cloned() }\n}\nimpl _Lookup for serde_json::Map<String, serde_json::Value> {\n    type Out = _Json;\n    fn lookup(&self, k: &str) -> _Json { _Json(self.get(k).cloned().filter(|v| !v.is_null())) }\n}\nimpl<T: _Lookup + ?Sized> _Lookup for &T {\n    type Out = T::Out;\n    fn lookup(&self, k: &str) -> T::Out { (**self).lookup(k) }\n}\n#[derive(Clone, Debug)]\nstruct _Json(Option<serde_json::Value>);\nimpl PartialEq<String> for _Json {\n    fn eq(&self, o: &String) -> bool { self.0.as_ref().and_then(|v| v.as_str()) == Some(o.as_str()) }\n}\nimpl PartialEq<f64> for _Json {\n    fn eq(&self, o: &f64) -> bool { self.0.as_ref().and_then(|v| v.as_f64()) == Some(*o) }\n}\nimpl PartialEq<bool> for _Json {\n    fn eq(&self, o: &bool) -> bool { self.0.as_ref().and_then(|v| v.as_bool()) == Some(*o) }\n}\nfn _get<M: _Lookup>(m: &M, k: &str) -> M::Out { m.lookup(k) }"], "object/merge": ["fn _merge<V: Clone>(a: &std::collections::BTreeMap<String, V>, b: &std::collections::BTreeMap<String, V>) -> std::collections::BTreeMap<String, V> {\n    let mut m = a.clone();\n    for (k, v) in b { m.insert(k.clone(), v.clone()); }\n    m\n}"], "object/pick": ["fn _pick<V: Clone>(m: &std::collections::BTreeMap<String, V>, ks: &[String]) -> std::collections::BTreeMap<String, V> {\n    m.iter().filter(|(k, _)| ks.contains(k)).map(|(k, v)| (k.clone(), v.clone())).collect()\n}"], "object/omit": ["fn _omit<V: Clone>(m: &std::collections::BTreeMap<String, V>, ks: &[String]) -> std::collections::BTreeMap<String, V> {\n    m.iter().filter(|(k, _)| !ks.contains(k)).map(|(k, v)| (k.clone(), v.clone())).collect()\n}"], "unsupported": ["#[derive(Clone)]\nstruct _U;\nfn _unsupported(op: &str) -> _U { panic!(\"no native template for operator {}\", op) }\nimpl From<_U> for f64 { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl From<_U> for String { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl From<_U> for bool { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl From<_U> for Option<f64> { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl From<_U> for Option<String> { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl From<_U> for Option<bool> { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl<T> From<_U> for Vec<T> { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl<T> From<_U> for Option<Vec<T>> { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl<K: Ord, V> From<_U> for std::collections::BTreeMap<K, V> { fn from(_: _U) -> Self { panic!(\"unsupported\") } }\nimpl<K: Ord, V> From<_U> for Option<std::collections::BTreeMap<K, V>> { fn from(_: _U) -> Self { panic!(\"unsupported\") } }"] }
       helperGap: "\n"
       portEffects: ["persist", "fetch", "fetch-stream", "notify", "navigate", "navigate-back", "call-service", "cancel-call", "send-server", "spawn", "despawn", "log"]
       portCall: "(self.ports)(\"{{name}}\", serde_json::json!([{{*}}]))"
@@ -82,14 +82,39 @@ orbital LoloRustOrbital {
       enumForm: "{{enum}}::{{member}}"
       enumMemberCase: "split-pascal"
       fieldNames: { "type": "type_" }
+      programOpen: ["pub struct Program {", "{{i}}pub router: _Router,", "}", "", "impl Program {", "{{i}}pub fn new(entities: ({{entities}},){{store}}) -> Self {", "{{i}}{{i}}let mut router = _Router::default();"]
+      programEntity: "{{entity}}"
+      programEntitySep: ", "
+      programTrait: "{{i}}{{i}}_routed!({{class}}); router.add({{key}}, Box::new({{class}}::new(entities.{{n}})));"
+      programHandles: "{{i}}{{i}}router.handles.insert({{key}}, {{table}});"
+      programRow: "{{i}}{{i}}router.row({{source}}, {{event}}, {{target}}, {{trigger}}, {{guard}}, {{map}});"
+      deliverOpen: ["{{i}}{{i}}Program { router }", "{{i}}}", "", "{{i}}pub fn dispatch(&mut self, trait_: &str, event: &str, payload: serde_json::Value) {", "{{i}}{{i}}_dispatch(self, trait_, event, payload)", "{{i}}}", "}", "", "impl _Program for Program {", "{{i}}fn router(&mut self) -> &mut _Router {", "{{i}}{{i}}&mut self.router", "{{i}}}", "", "{{i}}fn deliver(&mut self, target: &str, event: &str, payload: &serde_json::Value) {"]
+      deliverCase: "{{i}}{{i}}if target == {{target}} && event == {{event}} { if let Some(t) = self.router.get::<{{class}}>(target) { t.{{method}}({{arg}}); } return; }"
+      deliverCasePlain: "{{i}}{{i}}if target == {{target}} && event == {{event}} { if let Some(t) = self.router.get::<{{class}}>(target) { t.{{method}}(); } return; }"
+      deliverClose: ["{{i}}}", "}"]
+      programClose: []
+      payloadDecode: "&_decode::<{{type}}>({{value}})"
+      guardForm: ["", "fn {{name}}(payload_json: &serde_json::Value) -> bool {", "{{i}}let payload = {{decode}};", "{{i}}{{expr}}", "}"]
+      mapForm: ["", "fn {{name}}(payload_json: &serde_json::Value) -> serde_json::Value {", "{{i}}let payload = {{decode}};", "{{i}}serde_json::to_value({{expr}}).expect(\"a mapped payload\")", "}"]
+      guardName: "_guard_{{n}}"
+      mapName: "_map_{{n}}"
+      guardRef: "Some({{name}})"
+      mapRef: "Some({{name}})"
       modelImportEach: true
       fileHeader: "#![allow(dead_code, unused_macros, unused_parens, unused_variables)]"
       sectionGap: "\n\n"
       classOpen: "macro_rules! _list {\n    ($($x:expr),* $(,)?) => { vec![$(($x).clone()),*] };\n}\n\npub struct {{class}} {"
       classClose: "}"
       classEmpty: ""
-      constructor: ["{{i}}pub state: String,", "{{i}}pub entity: {{entity}},", "{{i}}pub config: {{configType}},", "{{i}}pub ports: Box<dyn FnMut(&str, serde_json::Value)>,", "{{i}}pub emitted: Vec<(String, Option<serde_json::Value>)>,", "}", "", "impl {{class}} {", "{{i}}pub fn new(entity: {{entity}}) -> Self {", "{{i}}{{i}}Self { state: {{initial}}, entity, config: {{configType}}::default(), ports: Box::new(|_, _| {}), emitted: Vec::new() }", "{{noConfig}}{{i}}{{i}}Self { state: {{initial}}, entity, ports: Box::new(|_, _| {}), emitted: Vec::new() }", "{{i}}}", "", "{{i}}pub fn with_config(mut self, config: {{configType}}) -> Self {", "{{withConfig}}{{i}}{{i}}self.config = config;", "{{withConfig}}{{i}}{{i}}self", "{{withConfig}}{{i}}}", "{{withConfig}}", "{{i}}pub fn with_ports(mut self, ports: impl FnMut(&str, serde_json::Value) + 'static) -> Self {", "{{i}}{{i}}self.ports = Box::new(ports);", "{{i}}{{i}}self", "{{i}}}"]
+      constructor: ["{{i}}pub state: String,", "{{i}}pub entity: {{entity}},", "{{i}}pub config: {{configType}},", "{{i}}pub ports: Box<dyn FnMut(&str, serde_json::Value)>,", "{{i}}pub emitted: Vec<(String, Option<serde_json::Value>)>,", "{{withStore}}{{i}}pub store: Option<std::rc::Rc<std::cell::RefCell<dyn Store>>>,", "{{withStore}}{{i}}pub completed: Vec<usize>,", "}", "", "impl {{class}} {", "{{i}}pub fn new(entity: {{entity}}) -> Self {", "{{noStore}}{{i}}{{i}}Self { state: {{initial}}, entity, config: {{configType}}::default(), ports: Box::new(|_, _| {}), emitted: Vec::new() }", "{{noStore}}{{noConfig}}{{i}}{{i}}Self { state: {{initial}}, entity, ports: Box::new(|_, _| {}), emitted: Vec::new() }", "{{withStore}}{{i}}{{i}}Self { state: {{initial}}, entity, config: {{configType}}::default(), ports: Box::new(|_, _| {}), emitted: Vec::new(), store: None, completed: Vec::new() }", "{{withStore}}{{noConfig}}{{i}}{{i}}Self { state: {{initial}}, entity, ports: Box::new(|_, _| {}), emitted: Vec::new(), store: None, completed: Vec::new() }", "{{i}}}", "", "{{i}}pub fn with_config(mut self, config: {{configType}}) -> Self {", "{{withConfig}}{{i}}{{i}}self.config = config;", "{{withConfig}}{{i}}{{i}}self", "{{withConfig}}{{i}}}", "{{withConfig}}", "{{i}}pub fn with_ports(mut self, ports: impl FnMut(&str, serde_json::Value) + 'static) -> Self {", "{{i}}{{i}}self.ports = Box::new(ports);", "{{i}}{{i}}self", "{{i}}}"]
       emitMethod: ["{{i}}fn emit(&mut self, event: String, payload: Option<serde_json::Value>) {", "{{i}}{{i}}self.emitted.push((event, payload));", "{{i}}}"]
+      completeMethod: ["", "{{i}}fn complete(&mut self, answer: (bool, serde_json::Value), success: Option<String>, failure: Option<String>) {", "{{i}}{{i}}let (ok, payload) = answer;", "{{i}}{{i}}if let Some(route) = if ok { success } else { failure } {", "{{i}}{{i}}{{i}}self.completed.push(self.emitted.len());", "{{i}}{{i}}{{i}}self.emitted.push((route, Some(payload)));", "{{i}}{{i}}}", "{{i}}}", "", "{{i}}fn use_store(&self) -> std::rc::Rc<std::cell::RefCell<dyn Store>> {", "{{i}}{{i}}self.store.clone().expect(\"no store\")", "{{i}}}"]
+      routedEffects: {"persist": "self.complete(self.use_store().borrow_mut().persist(&{{0}}, &{{1}}, serde_json::to_value(&{{2}}).expect(\"a row\")), {{success}}, {{failure}})", "fetch": "self.complete(self.use_store().borrow_mut().fetch(&{{entity}}, {{filter}}), {{success}}, {{failure}})"}
+      fetchAll: "None"
+      routeForm: "Some({{route}})"
+      filterForm: "Some(&({{lambda}}))"
+      programStoreParam: ", store: std::rc::Rc<std::cell::RefCell<dyn Store>>"
+      programTraitStore: "{{i}}{{i}}_routed_store!({{class}}); let mut t{{n}} = {{class}}::new(entities.{{n}}); t{{n}}.store = Some(store.clone()); router.add({{key}}, Box::new(t{{n}}));"
       methodOpen: "{{i}}pub fn {{method}}(&mut self, payload: &{{payloadType}}) {"
       methodOpenPlain: "{{i}}pub fn {{method}}(&mut self) {"
       methodClose: "{{i}}}"