diff --git a/diff.patch b/diff.patch
index 8e7c6df..9d6af69 100644
--- a/diff.patch
+++ b/diff.patch
@@ -1,19 +1,8 @@
 diff --git a/crates/ssd/src/generators/rhai.rs b/crates/ssd/src/generators/rhai.rs
-index d4ba8e3..178d4bb 100644
+index d4ba8e3..764211d 100644
 --- a/crates/ssd/src/generators/rhai.rs
 +++ b/crates/ssd/src/generators/rhai.rs
-@@ -45,6 +45,10 @@ fn error_to_runtime_error<E: std::error::Error>(e: E) -> Box<EvalAltResult> {
- 
- use rhai::Token;
- 
-+fn script_count_vec<T>(v: &Vec<T>) -> usize {
-+    v.len()
-+}
-+
- fn script_exists(path: &str) -> bool {
-     PathBuf::from(path).exists()
- }
-@@ -281,21 +285,31 @@ pub fn build_engine(messages: Rc<RefCell<Vec<String>>>, debug: bool) -> Engine {
+@@ -281,27 +281,64 @@ pub fn build_engine(messages: Rc<RefCell<Vec<String>>>, debug: bool) -> Engine {
      engine.register_global_module(package.as_shared_module());
  
      engine.register_iterator::<Vec<serde_value::Value>>();
@@ -38,8 +27,11 @@ index d4ba8e3..178d4bb 100644
 +        ($T: ty) => {
 +            engine
 +                .register_type::<Vec<$T>>()
-+                .register_fn("len", Vec::<$T>::len)
-+                .register_iterator::<Vec<$T>>();
++                .register_fn("len", |v: Vec<$T>| v.len())
++                .register_iterator::<Vec<$T>>()
++                .register_iterator::<&Vec<&$T>>()
++                .register_iterator::<Vec<$T>>()
++                .register_iterator::<&Vec<&$T>>();
 +        };
 +    }
 +
@@ -56,9 +48,169 @@ index d4ba8e3..178d4bb 100644
 +    register_vec!((String, Service));
 +    register_vec!((String, TypeName));
 +    register_vec!((String, Function));
++
++    // The globally mutable shared value
++    let indent = Rc::new(RefCell::new(INDENT.to_owned()));
++
++    let v = indent.clone();
++    engine.on_var(move |name, _, _| match name {
++        "IND" => Ok(Some(v.borrow().clone().into())),
++        _ => Ok(None),
++    });
++
++    // Register an API to access the globally mutable shared value
++    let v = indent.clone();
++    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
++    engine.register_fn("IND", move |count: i64| v.borrow().repeat(count as usize));
++
++    let v = indent.clone();
++    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
++    engine.register_fn("SET_INDENT", move |count: i64| {
++        *v.borrow_mut() = " ".repeat(count as usize)
++    });
++
++    let v = indent.clone();
++    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
++    engine.register_fn("SET_INDENT", move |value: &str, count: i64| {
++        *v.borrow_mut() = value.repeat(count as usize)
++    });
  
      engine.register_fn("to_string", |this: &mut Import| this.path.clone());
      #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+     engine.register_fn("NL", |count: i64| "\n".repeat(count as usize));
+-    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+-    engine.register_fn("IND", move |count: i64| INDENT.repeat(count as usize));
+ 
+     #[allow(clippy::items_after_statements)]
+     fn script_first<A: Clone, B>(tuple: &mut (A, B)) -> A {
+@@ -336,6 +373,7 @@ pub fn build_engine(messages: Rc<RefCell<Vec<String>>>, debug: bool) -> Engine {
+         Enum,
+         DataType,
+         Service,
++        Event,
+         Function,
+         TypeName,
+         EnumValue,
+@@ -398,7 +436,7 @@ pub fn build_engine(messages: Rc<RefCell<Vec<String>>>, debug: bool) -> Engine {
+ 
+     engine
+         .register_type::<TypeName>()
+-        .register_get("typ", TypeName::typ)
++        .register_get("type", TypeName::typ)
+         .register_get("is_list", TypeName::is_list)
+         .register_get("count", TypeName::count)
+         .register_get("attributes", TypeName::attributes);
+@@ -488,27 +526,77 @@ pub fn build_engine(messages: Rc<RefCell<Vec<String>>>, debug: bool) -> Engine {
+         .register_fn("all", script_all)
+         .register_fn("none", script_none);
+ 
+-    {
+-        let messages = messages.clone();
+-        engine.register_fn("-", move |msg: &str| {
+-            messages.borrow_mut().push(msg.to_owned());
+-        });
++    macro_rules! register_msg_single {
++        ($($T: ty),*) => {
++            $(
++            {
++                let messages = messages.clone();
++                engine.register_fn("-", move |msg: $T| {
++                    messages.borrow_mut().push(format!("{msg}"));
++                });
++            }
++            )*
++        };
+     }
+-    {
+-        let messages = messages.clone();
+-        engine.register_fn("++", move |a: &str, b: &str| {
+-            messages.borrow_mut().push(a.to_owned());
+-            messages.borrow_mut().push(b.to_owned());
+-        });
++
++    register_msg_single!(&str, usize, bool);
++
++    macro_rules! register_msg_multi {
++        ($(($A: ty, $B: ty)),*) => {
++            $(
++            {
++                let messages = messages.clone();
++                engine.register_fn("++", move |a: $A, b: $B| {
++                    messages.borrow_mut().push(format!("{a}"));
++                    messages.borrow_mut().push(format!("{b}"));
++                });
++            }
++            )*
++        };
+     }
+-    {
+-        let messages = messages.clone();
+-        engine.register_fn("++", move |a: &str, b: usize| {
+-            messages.borrow_mut().push(a.to_owned());
+-            messages.borrow_mut().push(b.to_string());
+-        });
++
++    register_msg_multi!(
++        (&str, &str),
++        (&str, usize),
++        (usize, &str),
++        (usize, usize),
++        (&str, bool),
++        (bool, &str),
++        (bool, usize),
++        (bool, bool)
++    );
++
++    macro_rules! register_comparison {
++        ($(($A: ty, $B: ty, $C: ty)),*) => {
++            $(
++            engine.register_fn(">",  |left: $A, right: $B| left as $C >  right as $C);
++            engine.register_fn(">=", |left: $A, right: $B| left as $C >= right as $C);
++            engine.register_fn("<",  |left: $A, right: $B| left as $C <  right as $C);
++            engine.register_fn("<=", |left: $A, right: $B| left as $C <= right as $C);
++            engine.register_fn("!=", |left: $A, right: $B| left as $C != right as $C);
++            engine.register_fn("==", |left: $A, right: $B| left as $C == right as $C);
++
++            engine.register_fn(">",  |left: $B, right: $A| left as $C >  right as $C);
++            engine.register_fn(">=", |left: $B, right: $A| left as $C >= right as $C);
++            engine.register_fn("<",  |left: $B, right: $A| left as $C <  right as $C);
++            engine.register_fn("<=", |left: $B, right: $A| left as $C <= right as $C);
++            engine.register_fn("!=", |left: $B, right: $A| left as $C != right as $C);
++            engine.register_fn("==", |left: $B, right: $A| left as $C == right as $C);
++            )*
++        };
+     }
+ 
++    register_comparison!(
++        (i64, usize, i128),
++        (i32, usize, i128),
++        (i16, usize, i128),
++        (i8, usize, i128),
++        (u64, usize, usize),
++        (u32, usize, usize),
++        (u16, usize, usize),
++        (u8, usize, usize)
++    );
++
+     macro_rules! register_string_concat_void {
+         ($($T: ty),*) => {$({
+             let messages = messages.clone();
+@@ -682,7 +770,6 @@ pub fn generate_web(
+     scope.push("module", module);
+     scope.push_constant("defines", defines);
+     scope.push_constant("NL", "\n");
+-    scope.push_constant("IND", INDENT);
+     engine.run_with_scope(&mut scope, script)?;
+     let messages = messages.borrow();
+     Ok(messages.join(""))
+@@ -716,7 +803,6 @@ pub fn generate(
+     };
+     scope.push_constant("defines", defines);
+     scope.push_constant("NL", "\n");
+-    scope.push_constant("IND", INDENT);
+     engine.run_file_with_scope(&mut scope, script)?;
+     let messages = messages.borrow();
+     if !messages.is_empty() {
 diff --git a/crates/ssd/src/generators/tera.rs b/crates/ssd/src/generators/tera.rs
 index 2cfb3eb..251a225 100644
 --- a/crates/ssd/src/generators/tera.rs