diff --git a/README.md b/README.md
index 3e7a1797..a634df10 100644
--- a/README.md
+++ b/README.md
@@ -25,10 +25,15 @@ C:\vcpkg> set VCPKGRS_DYNAMIC=1 (or simply set it as your environment variable)
 Changes:
 - Major changes: Javascript scripting!
 - Updated config-wasm to parse legacy and scripting yaml files
+- New binary pewpew-config-updater will attempt to convert legacy config yamls to the new version. If it can't convert the code it will leave in PLACEHOLDERS and TODO
+  - Known issues:
+  - Expressions in vars will not wrap environment variables in the expected `${e:VAR}`
+  - vars in `logs` and `provides` will not have the prepended `_v.` before the var name.
 
 Bugs:
-- Collect returns an array of strings regardless of input type
-- auto-converter removes code templates. Leave in and TODO
+- Collect returns an array of strings regardless of input type. Workaround, use scripting to `.map(parseInt)`.
+- Declare expressions that create strings will escape out any json/quotes. No workaround currently.
+- Vars cannot be decimal point values. Ex `peakLoad: 0.87`. Workaround: `peakLoad: ${x:0.87}`
 - global loggers may not be running in try script
 
 Bug fixes:
diff --git a/deny.toml b/deny.toml
index 360514cc..d68bd04b 100644
--- a/deny.toml
+++ b/deny.toml
@@ -14,7 +14,7 @@ unmaintained = "warn"
 yanked = "warn"
 notice = "warn"
 ignore = [
-    "RUSTSEC-2020-0071",
+    # "RUSTSEC-2020-0071",
 ]
 
 [licenses]
diff --git a/guide/build-guide.sh b/guide/build-guide.sh
index c4e601aa..330a879b 100755
--- a/guide/build-guide.sh
+++ b/guide/build-guide.sh
@@ -42,7 +42,7 @@ wasm-pack build --release -t bundler -d $CFG_GEN_OUTPUT_REACT_DIR --scope fs
 
 # build the results viewer (which includes putting the output into the book's src)
 cd $RESULTS_VIEWER_REACT_DIR
-npm install
+npm ci
 npm run build
 
 # build the book
diff --git a/guide/serve-guide.sh b/guide/serve-guide.sh
index e6d1cb58..83e8a542 100755
--- a/guide/serve-guide.sh
+++ b/guide/serve-guide.sh
@@ -42,7 +42,7 @@ wasm-pack build --release -t bundler -d $CFG_GEN_OUTPUT_REACT_DIR --scope fs
 
 # build the results viewer (which includes putting the output into the book's src)
 cd $RESULTS_VIEWER_REACT_DIR
-npm install
+npm ci
 npm run build
 
 # build the book
diff --git a/lib/config-gen/tests/test.js b/lib/config-gen/tests/test.js
index 4ab2f378..7f570987 100644
--- a/lib/config-gen/tests/test.js
+++ b/lib/config-gen/tests/test.js
@@ -66,15 +66,15 @@ loggers:
         timestamp: epoch("ms")
       for_each: []
       where: null
+    limit: null
     to: stdout
     pretty: false
-    limit: null
     kill: false
   test2:
     query: null
+    limit: null
     to: !file out.txt
     pretty: false
-    limit: null
     kill: false
 providers:
   sequence: !list
diff --git a/lib/config/src/configv1/convert_helper.rs b/lib/config/src/configv1/convert_helper.rs
index 421d2ca3..ded96caf 100644
--- a/lib/config/src/configv1/convert_helper.rs
+++ b/lib/config/src/configv1/convert_helper.rs
@@ -374,17 +374,60 @@ fn map_query(
     for_each: Vec<WithMarker<String>>,
     where_clause: Option<WithMarker<String>>,
 ) -> Option<Query<False>> {
-    if let Some(w) = where_clause {
+    // Fallback query if we can't parse anything
+    let empty_query = Query::simple("PLEASE_UPDATE_MANUALLY".to_owned(), vec![], None).unwrap();
+
+    // Attempt to parse the where_clause
+    let where_clause = if let Some(w) = where_clause {
         let w = w.destruct().0;
-        log::warn!("query `where` item {w:?} must be updated manually");
+        Some(w)
+    } else {
+        None
+    };
+    // Attempt to parse the for_each
+    let for_each: Vec<String> = for_each
+        .iter()
+        .map(|fe| (fe.inner.to_string(), fe.marker).0)
+        .collect();
+
+    // See if we can create a fallback with the where and for_each but without the select
+    let manual_query = match Query::simple(
+        "PLEASE_UPDATE_MANUALLY".to_owned(),
+        for_each.clone(),
+        where_clause.clone(),
+    ) {
+        Ok(q) => q,
+        Err(e) => {
+            log::warn!("query `where` or `for_each` item must be updated manually: {e:?}");
+            empty_query
+        }
     };
-    for_each.into_iter().for_each(|fe| {
-        let fe = fe.destruct().0;
-        log::warn!("query `for_each` item {fe:?} must be updated manually");
-    });
+
+    // Finally attempt to parse the select but fallback to the manual_query or empty_query
     select.map(|s| {
-        log::warn!("query `select` item {s:?} must be updated manually");
-        Query::simple("PLEASE_UPDATE_MANUALLY".to_owned(), vec![], None).unwrap()
+        let select_temp = s.inner();
+        log::debug!("select_temp query: {select_temp}");
+        let query = match select_temp {
+            json::Value::Object(_) => {
+                log::info!("Object query: {select_temp}");
+                Query::<False>::complex_json(
+                    format!("{select_temp}").as_str(),
+                    for_each,
+                    where_clause,
+                )
+            }
+            json::Value::String(s) => Query::simple(s.to_string(), for_each, where_clause),
+            _ => Query::simple(format!("{select_temp}"), for_each, where_clause),
+        };
+        let query = match query {
+            Ok(q) => q,
+            Err(e) => {
+                log::warn!("query `select` {select_temp} must be updated manually: {e:?}");
+                manual_query
+            }
+        };
+        log::debug!("new query: {query:?}");
+        query
     })
 }
 
diff --git a/lib/config/src/configv1/expression_functions.rs b/lib/config/src/configv1/expression_functions.rs
index e113b29c..85ac5e12 100644
--- a/lib/config/src/configv1/expression_functions.rs
+++ b/lib/config/src/configv1/expression_functions.rs
@@ -17,6 +17,48 @@ use zip_all::zip_all;
 
 use std::{borrow::Cow, cmp::Ordering, collections::BTreeMap, fmt, iter, sync::Arc, task::Poll};
 
+/// Helper function for converting to new v2 config where we use a Uniform Range.
+/// Takes a format!("{range:?}") and finds the low an high and returns them as strings
+///
+/// # Panics
+///
+/// Panics if .
+fn get_low_high(uniform: String) -> (String, String) {
+    // Will be something like Uniform(UniformInt { low: 0, range: 10, z: 6 })
+    // Or Uniform(UniformFloat { low: 1.1, scale: 9.200000000000001 })
+    let re_int = Regex::new(r"low: (\d+), range: (\d+),").unwrap();
+    let re_float = Regex::new(r"low: ([0-9\.]+), scale: ([0-9\.]+) ").unwrap();
+    match re_int.captures(uniform.as_str()) {
+        Some(caps) => {
+            let low = (caps[1]).parse::<i64>();
+            let range = (caps[2]).parse::<i64>();
+            if let (Ok(low), Ok(range)) = (low, range) {
+                let high = range + low;
+                (format!("{low:.0}"), format!("{high:.0}"))
+            } else {
+                ((caps[1]).to_owned(), (caps[2]).to_owned())
+            }
+        }
+        None => match re_float.captures(uniform.as_str()) {
+            Some(caps) => {
+                let low = (caps[1]).parse::<f64>();
+                let range = (caps[2]).parse::<f64>();
+                if let (Ok(low), Ok(range)) = (low, range) {
+                    let high = range + low;
+                    if low.fract() == 0.0 && high.fract() == 0.0 {
+                        (format!("{low:.0}"), format!("{high:.0}"))
+                    } else {
+                        (format!("{low:.3}"), format!("{high:.3}"))
+                    }
+                } else {
+                    ((caps[1]).to_owned(), (caps[2]).to_owned())
+                }
+            }
+            None => (uniform, "unknown".to_string()),
+        },
+    }
+}
+
 #[derive(Clone, Debug)]
 pub(super) struct Collect {
     arg: ValueOrExpression,
@@ -149,6 +191,12 @@ pub(super) struct Encode {
     encoding: Encoding,
 }
 
+impl std::fmt::Display for Encode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "encode({}, \"{}\")", self.arg, self.encoding)
+    }
+}
+
 impl Encode {
     pub(super) fn new(
         mut args: Vec<ValueOrExpression>,
@@ -219,6 +267,12 @@ pub struct Entries {
     arg: ValueOrExpression,
 }
 
+impl std::fmt::Display for Entries {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "entries({})", self.arg)
+    }
+}
+
 impl Entries {
     pub(super) fn new(
         mut args: Vec<ValueOrExpression>,
@@ -381,6 +435,12 @@ pub(super) struct If {
     third: ValueOrExpression,
 }
 
+impl std::fmt::Display for If {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "if({}, {}, {})", self.first, self.second, self.third)
+    }
+}
+
 impl If {
     pub(super) fn new(
         mut args: Vec<ValueOrExpression>,
@@ -498,6 +558,10 @@ impl If {
             }
         })
     }
+
+    pub(super) fn convert_to_v2(&self) -> String {
+        format!("({}) ? {} : {}", self.first, self.second, self.third)
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -507,6 +571,16 @@ pub(super) struct Join {
     sep2: Option<String>,
 }
 
+impl std::fmt::Display for Join {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(sep2) = &self.sep2 {
+            write!(f, "join({}, \"{}\", \"{}\")", self.arg, self.sep, sep2)
+        } else {
+            write!(f, "join({}, \"{}\")", self.arg, self.sep)
+        }
+    }
+}
+
 impl Join {
     pub(super) fn new(
         mut args: Vec<ValueOrExpression>,
@@ -620,6 +694,7 @@ pub(super) struct JsonPath {
     provider: String,
     selector: Arc<json_path::Compiled>,
     marker: Marker,
+    args: Vec<ValueOrExpression>, // Save for display
 }
 
 impl fmt::Debug for JsonPath {
@@ -634,6 +709,18 @@ impl fmt::Debug for JsonPath {
     }
 }
 
+impl std::fmt::Display for JsonPath {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let args: Vec<String> = self
+            .args
+            .clone()
+            .into_iter()
+            .map(|arg| format!("{}", arg))
+            .collect();
+        write!(f, "json_path({})", args.join(","))
+    }
+}
+
 impl JsonPath {
     pub(super) fn new(
         args: Vec<ValueOrExpression>,
@@ -668,6 +755,7 @@ impl JsonPath {
                     provider: provider.into(),
                     selector: json_path.into(),
                     marker,
+                    args: args.clone(),
                 };
                 let v = static_vars.get(provider).cloned();
                 if let Some(v) = v {
@@ -733,6 +821,12 @@ pub(super) struct Match {
     regex: Regex,
 }
 
+impl std::fmt::Display for Match {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "match({}, \"{}\")", self.arg, self.regex)
+    }
+}
+
 impl Match {
     pub(super) fn new(
         args: Vec<ValueOrExpression>,
@@ -839,6 +933,22 @@ pub(super) struct MinMax {
     min: bool,
 }
 
+impl std::fmt::Display for MinMax {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let args: Vec<String> = self
+            .args
+            .clone()
+            .into_iter()
+            .map(|arg| format!("{arg}"))
+            .collect();
+        if self.min {
+            write!(f, "min({})", args.join(", "))
+        } else {
+            write!(f, "max({})", args.join(", "))
+        }
+    }
+}
+
 impl MinMax {
     pub(super) fn new(
         min: bool,
@@ -949,6 +1059,24 @@ pub(super) struct Pad {
     padding: String,
 }
 
+impl std::fmt::Display for Pad {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.start {
+            write!(
+                f,
+                "start_pad({}, {}, \"{}\")",
+                self.arg, self.min_length, self.padding
+            )
+        } else {
+            write!(
+                f,
+                "end_pad({}, {}, \"{}\")",
+                self.arg, self.min_length, self.padding
+            )
+        }
+    }
+}
+
 impl Pad {
     pub(super) fn new(
         start: bool,
@@ -1066,6 +1194,13 @@ pub enum Random {
     Float(Uniform<f64>),
 }
 
+impl std::fmt::Display for Random {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let (low, high) = self.get_low_high();
+        write!(f, "random({}, {})", low, high)
+    }
+}
+
 impl Random {
     pub(super) fn new(
         args: Vec<ValueOrExpression>,
@@ -1111,6 +1246,25 @@ impl Random {
             Ok((self.evaluate().into_owned(), Vec::new()))
         }))
     }
+
+    /// Helper function for converting to new v2 config where we use a Uniform Range.
+    /// Takes a format!("{range:?}") and finds the low an high and returns them as strings
+    ///
+    /// # Panics
+    ///
+    /// Panics if .
+    pub(super) fn get_low_high(&self) -> (String, String) {
+        let uniform = match self {
+            Random::Integer(r) => format!("{:?}", r),
+            Random::Float(r) => format!("{:?}", r),
+        };
+        get_low_high(uniform)
+    }
+
+    pub(super) fn convert_to_v2(&self) -> String {
+        let (low, high) = self.get_low_high();
+        format!("random({}, {}, ${{p:null}})", low, high)
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -1149,6 +1303,26 @@ pub(super) enum Range {
     Range(ReversibleRange),
 }
 
+impl std::fmt::Display for Range {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Range::Args(args) => write!(f, "range({}, {})", args.0, args.1),
+            Range::Range(range) => {
+                if range.reverse {
+                    write!(
+                        f,
+                        "range({}, {})",
+                        range.range.end - 1,
+                        range.range.start - 1
+                    )
+                } else {
+                    write!(f, "range({}, {})", range.range.start, range.range.end)
+                }
+            }
+        }
+    }
+}
+
 impl Range {
     pub(super) fn new(
         mut args: Vec<ValueOrExpression>,
@@ -1269,6 +1443,17 @@ pub(super) struct Repeat {
     random: Option<Uniform<u64>>,
 }
 
+impl std::fmt::Display for Repeat {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(uniform) = self.random {
+            let (_, high) = get_low_high(format!("{uniform:?}"));
+            write!(f, "repeat({}, {})", self.min, high)
+        } else {
+            write!(f, "repeat({})", self.min)
+        }
+    }
+}
+
 impl Repeat {
     pub(super) fn new(
         mut args: Vec<ValueOrExpression>,
@@ -1345,6 +1530,16 @@ pub(super) struct Replace {
     replacer: ValueOrExpression,
 }
 
+impl std::fmt::Display for Replace {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "replace({}, {}, {})",
+            self.needle, self.haystack, self.replacer
+        )
+    }
+}
+
 impl Replace {
     pub(super) fn new(
         mut args: Vec<ValueOrExpression>,
@@ -1467,6 +1662,16 @@ pub(super) struct ParseNum {
     is_float: bool,
 }
 
+impl std::fmt::Display for ParseNum {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.is_float {
+            write!(f, "parseFloat({})", self.arg)
+        } else {
+            write!(f, "parseInt({})", self.arg)
+        }
+    }
+}
+
 impl ParseNum {
     pub(super) fn new(
         float: bool,
diff --git a/lib/config/src/configv1/select_parser.rs b/lib/config/src/configv1/select_parser.rs
index 7cfab8a8..3110b205 100644
--- a/lib/config/src/configv1/select_parser.rs
+++ b/lib/config/src/configv1/select_parser.rs
@@ -204,6 +204,27 @@ impl FunctionCall {
         Ok(r)
     }
 
+    fn convert_to_v2(&self) -> String {
+        debug!("FunctionCall::evaluate function=\"{:?}\"", self);
+        match self {
+            FunctionCall::Collect(c) => format!("{c:?}"),
+            FunctionCall::Encode(e) => format!("{e}"),
+            FunctionCall::Entries(e) => format!("{e}"),
+            FunctionCall::Epoch(e) => format!("{e}"),
+            FunctionCall::If(i) => i.convert_to_v2(),
+            FunctionCall::Join(j) => format!("{j}"),
+            FunctionCall::JsonPath(j) => format!("{j}"),
+            FunctionCall::Match(m) => format!("{m}"),
+            FunctionCall::MinMax(m) => format!("{m}"),
+            FunctionCall::Pad(p) => format!("{p}"),
+            FunctionCall::Range(r) => format!("{r}"),
+            FunctionCall::Random(r) => r.convert_to_v2(),
+            FunctionCall::Repeat(r) => format!("{r}"),
+            FunctionCall::Replace(r) => format!("{r}"),
+            FunctionCall::ParseNum(p) => format!("{p}"),
+        }
+    }
+
     fn evaluate<'a, 'b: 'a>(
         &'b self,
         d: Cow<'a, json::Value>,
@@ -450,6 +471,23 @@ pub struct Path {
     pub(super) marker: Marker,
 }
 
+impl std::fmt::Display for Path {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.rest.is_empty() {
+            write!(f, "{}", self.start)
+        } else {
+            let rest: Vec<String> = self
+                .rest
+                .clone()
+                .into_iter()
+                .map(|piece| format!("{piece}"))
+                .collect();
+            let rest = rest.join(".");
+            write!(f, "{}.{}", self.start, rest)
+        }
+    }
+}
+
 impl Path {
     fn evaluate<'a, 'b: 'a>(
         &'b self,
@@ -626,6 +664,15 @@ pub enum ValueOrExpression {
     Expression(Expression),
 }
 
+impl std::fmt::Display for ValueOrExpression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Value(v) => write!(f, "{}", v),
+            Self::Expression(x) => write!(f, "{}", x),
+        }
+    }
+}
+
 impl ValueOrExpression {
     pub fn new(
         expr: &str,
@@ -708,6 +755,39 @@ pub enum Value {
     Template(Template),
 }
 
+impl std::fmt::Display for Value {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Path(p) => {
+                if p.rest.is_empty() {
+                    match &p.start {
+                        PathStart::Ident(i) => write!(f, "{i}"),
+                        PathStart::FunctionCall(func) => write!(f, "{}", &func.convert_to_v2()),
+                        PathStart::Value(v) => write!(f, "{v}"),
+                    }
+                } else {
+                    let rest: Vec<String> = p
+                        .rest
+                        .clone()
+                        .into_iter()
+                        .map(|piece| format!("{piece}"))
+                        .collect();
+                    let rest = rest.join(".");
+                    match &p.start {
+                        PathStart::Ident(i) => write!(f, "{i}.{rest}"),
+                        PathStart::FunctionCall(func) => {
+                            write!(f, "{}.{}", &func.convert_to_v2(), rest)
+                        }
+                        PathStart::Value(v) => write!(f, "{v}.{rest}"),
+                    }
+                }
+            }
+            Self::Json(j) => write!(f, "{j}"),
+            Self::Template(t) => write!(f, "{}", t),
+        }
+    }
+}
+
 impl Value {
     fn evaluate<'a, 'b: 'a>(
         &'b self,
@@ -787,11 +867,21 @@ impl Value {
 
 #[derive(Clone, Debug)]
 pub(super) enum PathSegment {
-    Number(usize),
-    String(String),
+    Number(usize),  // [0]
+    String(String), // like .body on response.body
     Template(Arc<Template>),
 }
 
+impl std::fmt::Display for PathSegment {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Number(n) => write!(f, "[{n}]"), // [0]
+            Self::String(s) => write!(f, "{s}"),
+            Self::Template(t) => write!(f, "{t}"),
+        }
+    }
+}
+
 impl PathSegment {
     fn from_str(
         s: &str,
@@ -829,6 +919,16 @@ pub(super) enum PathStart {
     Value(json::Value),
 }
 
+impl std::fmt::Display for PathStart {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self {
+            PathStart::Ident(i) => write!(f, "{i}"),
+            PathStart::FunctionCall(func) => write!(f, "{}", &func.convert_to_v2()),
+            PathStart::Value(v) => write!(f, "{v}"),
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug, PartialEq)]
 enum InfixOperator {
     Add = 0,
@@ -846,6 +946,26 @@ enum InfixOperator {
     Subtract = 12,
 }
 
+impl std::fmt::Display for InfixOperator {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            InfixOperator::Add => write!(f, "+"),
+            InfixOperator::And => write!(f, "&&"),
+            InfixOperator::Divide => write!(f, "/"),
+            InfixOperator::Eq => write!(f, "=="),
+            InfixOperator::Gt => write!(f, ">"),
+            InfixOperator::Gte => write!(f, ">="),
+            InfixOperator::Lt => write!(f, "<"),
+            InfixOperator::Lte => write!(f, "<="),
+            InfixOperator::Mod => write!(f, "%"),
+            InfixOperator::Multiply => write!(f, "*"),
+            InfixOperator::Ne => write!(f, "!="),
+            InfixOperator::Or => write!(f, "||"),
+            InfixOperator::Subtract => write!(f, "-"),
+        }
+    }
+}
+
 static INFIX_OPERATOR_PRECEDENCE: [u8; 13] = [
     4, // Add
     2, // And
@@ -937,8 +1057,23 @@ enum ExpressionLhs {
 #[derive(Clone, Debug)]
 pub struct Expression {
     not: Option<bool>,
-    lhs: ExpressionLhs,
-    op: Option<(InfixOperator, Box<Expression>)>,
+    left_hand_side: ExpressionLhs,
+    right_hand_side: Option<(InfixOperator, Box<Expression>)>,
+}
+
+impl std::fmt::Display for Expression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // I can't get a test to even evaluate the not, so I'm not sure if this is working
+        let not = if self.not.unwrap_or(false) { "!" } else { "" };
+        let right_hand_side = match &self.right_hand_side {
+            Some((operator, right_hand_side)) => format!(" {operator} {right_hand_side}"),
+            None => "".to_owned(),
+        };
+        match &self.left_hand_side {
+            ExpressionLhs::Expression(x) => write!(f, "{not}{x}{right_hand_side}"),
+            ExpressionLhs::Value(v) => write!(f, "{not}{v}{right_hand_side}"),
+        }
+    }
 }
 
 impl Expression {
@@ -948,8 +1083,8 @@ impl Expression {
         no_recoverable_error: bool,
         for_each: Option<&[Cow<'a, json::Value>]>,
     ) -> Result<Cow<'a, json::Value>, ExecutingExpressionError> {
-        let mut v = if let Some((op, rhs)) = &self.op {
-            let v = match &self.lhs {
+        let mut v = if let Some((op, rhs)) = &self.right_hand_side {
+            let v = match &self.left_hand_side {
                 ExpressionLhs::Expression(e) => {
                     e.evaluate(Cow::Borrowed(&*d), no_recoverable_error, for_each)?
                 }
@@ -960,7 +1095,7 @@ impl Expression {
             let rhs = rhs.evaluate(Cow::Borrowed(&*d), no_recoverable_error, for_each);
             Cow::Owned(op.evaluate(&v, rhs)?)
         } else {
-            match &self.lhs {
+            match &self.left_hand_side {
                 ExpressionLhs::Expression(e) => e.evaluate(d, no_recoverable_error, for_each)?,
                 ExpressionLhs::Value(v) => v.evaluate(d, no_recoverable_error, for_each)?,
             }
@@ -988,7 +1123,9 @@ impl Expression {
         impl Iterator<Item = Result<Cow<'a, json::Value>, ExecutingExpressionError>> + Clone,
         ExecutingExpressionError,
     > {
-        let i = if let (None, None, ExpressionLhs::Value(v)) = (&self.op, &self.not, &self.lhs) {
+        let i = if let (None, None, ExpressionLhs::Value(v)) =
+            (&self.right_hand_side, &self.not, &self.left_hand_side)
+        {
             Either3::A(v.evaluate_as_iter(d, no_recoverable_error, for_each)?)
         } else {
             let value = self.evaluate(d, no_recoverable_error, for_each)?;
@@ -1014,12 +1151,12 @@ impl Expression {
         no_recoverable_error: bool,
     ) -> impl Stream<Item = Result<(json::Value, Vec<Ar>), ExecutingExpressionError>> + Send + Unpin
     {
-        let v = match self.lhs {
+        let v = match self.left_hand_side {
             ExpressionLhs::Expression(e) => e.into_stream(providers, no_recoverable_error).a(),
             ExpressionLhs::Value(v) => v.into_stream(providers, no_recoverable_error).b(),
         };
         let not = self.not;
-        let v = if let Some((op, rhs)) = self.op {
+        let v = if let Some((op, rhs)) = self.right_hand_side {
             v.zip(rhs.into_stream(providers, no_recoverable_error))
                 .map(move |(a, b)| {
                     let (lhs, mut returns) = a?;
@@ -1057,8 +1194,8 @@ impl Expression {
     fn simplify_to_json(self) -> Result<Either<json::Value, Self>, CreatingExpressionError> {
         let aorb = match self {
             Expression {
-                lhs: ExpressionLhs::Value(Value::Json(v)),
-                op: None,
+                left_hand_side: ExpressionLhs::Value(Value::Json(v)),
+                right_hand_side: None,
                 ..
             } => {
                 if let Some(not) = self.not {
@@ -1073,8 +1210,8 @@ impl Expression {
                 }
             }
             Expression {
-                lhs: ExpressionLhs::Expression(e),
-                op: None,
+                left_hand_side: ExpressionLhs::Expression(e),
+                right_hand_side: None,
                 ..
             } => return e.simplify_to_json(),
             e => Either::B(e),
@@ -1171,6 +1308,15 @@ enum TemplatePiece {
     NotExpression(String),
 }
 
+impl std::fmt::Display for TemplatePiece {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TemplatePiece::Expression(x) => write!(f, "{x}"),
+            TemplatePiece::NotExpression(s) => write!(f, "{s}"),
+        }
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct Template {
     pieces: Vec<TemplatePiece>,
@@ -1178,6 +1324,23 @@ pub struct Template {
     no_recoverable_error: bool,
 }
 
+impl std::fmt::Display for Template {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // Empty strings get turned into empty Templates with no pieces
+        if self.pieces.is_empty() {
+            write!(f, "\"\"")
+        } else {
+            let pieces: Vec<String> = self
+                .pieces
+                .clone()
+                .into_iter()
+                .map(|piece| format!("{piece}"))
+                .collect();
+            write!(f, "{}", pieces.join(""))
+        }
+    }
+}
+
 impl Template {
     pub(crate) fn new(
         t: &str,
@@ -1946,14 +2109,14 @@ fn expression_helper(
             };
             let right = expression_helper(right, level)?;
             let op = Some((operator, right.into()));
-            e = if e.op.is_none() {
-                e.op = op;
+            e = if e.right_hand_side.is_none() {
+                e.right_hand_side = op;
                 e
             } else {
                 Expression {
-                    lhs: ExpressionLhs::Expression(e.into()),
+                    left_hand_side: ExpressionLhs::Expression(e.into()),
                     not: None,
-                    op,
+                    right_hand_side: op,
                 }
             };
             Ok(e)
@@ -2014,8 +2177,8 @@ fn parse_expression_pieces(
                 not_count = 0;
                 let e = Expression {
                     not,
-                    lhs: ExpressionLhs::Value(v),
-                    op: None,
+                    left_hand_side: ExpressionLhs::Value(v),
+                    right_hand_side: None,
                 };
                 let eoo = ExpressionOrOperator::Expression(e);
                 pieces.push(eoo);
@@ -2531,6 +2694,28 @@ pub mod template_convert {
         /// - `"${port}"`
         /// - `"${sessionId}"`
         SingleSource(String),
+        /// Interpolations where the contents are a single expression.
+        ///
+        /// Whether the source is a Function, (required by Templates in configv2 being
+        /// more explicit) will be inferred later in the conversion at a point when more data is
+        /// available.
+        ///
+        /// # Examples of V1 Template segments that would become this variant.
+        ///
+        /// - `"${epoch('ms')}"`
+        /// - `"${parseInt(TEST_COUNT)}"`
+        SingleExpression(String),
+        /// Interpolations where the contents are a multiple expressions.
+        ///
+        /// Whether the source is a Function, (required by Templates in configv2 being
+        /// more explicit) will be inferred later in the conversion at a point when more data is
+        /// available.
+        ///
+        /// # Examples of V1 Template segments that would become this variant.
+        ///
+        /// - `"${match(PROFILE, "[^-]+")["0"]}"`
+        /// - `"${response.status}"`
+        MultiExpression(Vec<Segment>),
         /// Any other interpolation segment.
         ///
         /// It's not necessarily "impossible" for this to be autoconverted, but efforts to make it
@@ -2549,8 +2734,8 @@ pub mod template_convert {
         pub fn dump(self) -> Vec<Segment> {
             self.pieces
                 .into_iter()
-                .map(|p| match p {
-                    TemplatePiece::NotExpression(s) => Segment::Outer(s),
+                .map(|p| match p.clone() {
+                    TemplatePiece::NotExpression(s) => Segment::Outer(s.to_owned()),
                     TemplatePiece::Expression(e) => match e {
                         ValueOrExpression::Value(Value::Json(j)) => {
                             log::warn!("not sure what this is supposed to be for, so please update manually: {j:?}");
@@ -2561,25 +2746,71 @@ pub mod template_convert {
                                 start: PathStart::Ident(s),
                                 rest,
                                 ..
-                            } if rest.is_empty() => Segment::SingleSource(s),
+                            } if rest.is_empty() => Segment::SingleSource(s.to_owned()),
                             other => {
-                                log::warn!("template path {other:?} must be updated manually");
+                                log::warn!("template value path {other:?} must be updated manually");
                                 Segment::Placeholder
                             }
                         },
                         ValueOrExpression::Expression(Expression {
                             not: None,
-                            lhs: ExpressionLhs::Value(Value::Path(p)),
-                            op: None,
-                        }) => match *p {
-                            Path {
-                                start: PathStart::Ident(s),
-                                rest,
-                                ..
-                            } if rest.is_empty() => Segment::SingleSource(s),
-                            other => {
-                                log::warn!("template path {other:?} must be updated manually");
-                                Segment::Placeholder
+                            left_hand_side: ExpressionLhs::Value(Value::Path(path)),
+                            right_hand_side,
+                        }) => {
+                            log::debug!("template expression path {0:?} - {1:?}; is_empty: {2:?}, right_hand_side: {3:?}", path.start, path.rest, path.rest.is_empty(), right_hand_side);
+                            let mut segments: Vec<Segment> = vec![];
+                            // Handle !rest.is_empty()
+                            // rest: [String("nextPageToken")] is .nextPageToken
+                            for path_segment in &path.rest {
+                                let mut decimal = "";
+                                if let PathSegment::String(_) = path_segment {
+                                    decimal = ".";
+                                }
+                                segments.push(Segment::Outer(format!("{decimal}{path_segment}")))
+                            }
+                            // Hanlde the right_hand_side
+                            if let Some((operator, expression)) = right_hand_side {
+                                log::debug!("{operator} {expression}");
+                                segments.push(Segment::Outer(format!(" {operator} {expression}")))
+                            }
+                            match *path {
+                                Path {
+                                    start: PathStart::Ident(ident_path),
+                                    rest: _,
+                                    ..
+                                } => if segments.is_empty() {
+                                    Segment::SingleSource(ident_path)
+                                } else {
+                                    // no unshift, so push then rotate_right(1) to put at start
+                                    segments.push(Segment::SingleSource(ident_path));
+                                    segments.rotate_right(1);
+                                    Segment::MultiExpression(segments)
+                                },
+                                Path {
+                                    start: PathStart::FunctionCall(function_call),
+                                    rest: _,
+                                    ..
+                                } => {
+                                        log::debug!("template expression function {function_call:?}");
+                                        let segment = if let FunctionCall::Collect(_) = function_call {
+                                            log::warn!("template expression collect {function_call:?} must be updated manually");
+                                            Segment::Placeholder
+                                        } else {
+                                            Segment::SingleExpression(function_call.convert_to_v2())
+                                        };
+                                        if segments.is_empty() {
+                                            segment
+                                        } else {
+                                            // no unshift, so push then rotate_right(1) to put at start
+                                            segments.push(segment);
+                                            segments.rotate_right(1);
+                                            Segment::MultiExpression(segments)
+                                        }
+                                },
+                                other => {
+                                    log::warn!("template expression path {other:?} must be updated manually");
+                                    Segment::Placeholder
+                                }
                             }
                         },
                         other => {
@@ -2588,7 +2819,7 @@ pub mod template_convert {
                         }
                     },
                 })
-                .collect()
+                .collect::<Vec<Segment>>()
         }
     }
 
@@ -2656,11 +2887,73 @@ pub mod template_convert {
                     Segment::SingleSource("port".to_owned()),
                     Segment::Outer("/".to_owned()),
                     // Placeholder because of script expr.
-                    Segment::Placeholder,
+                    Segment::SingleExpression("encode(foo, \"percent-userinfo\")".to_owned()),
                     // Placeholder because of complex path.
-                    Segment::Placeholder,
+                    Segment::MultiExpression(vec![
+                        Segment::SingleSource("response".to_owned()),
+                        Segment::Outer(".body".to_owned()),
+                        Segment::Outer(".a".to_owned()),
+                    ]),
                 ]
             );
         }
+
+        #[test]
+        fn template_convert_functions() {
+            let tests = BTreeMap::from([
+                // ("${collect(foo, 3, 5)}", "collect(foo, 3, 5)"), Collect is still a placeholder
+                (
+                    "${encode(foo, \"percent-userinfo\")}",
+                    "encode(foo, \"percent-userinfo\")",
+                ),
+                ("${end_pad(foo, 3, \"-\")}", "end_pad(foo, 3, \"-\")"),
+                ("${entries(foo)}", "entries(foo)"),
+                ("${epoch(\"ms\")}", "epoch(\"ms\")"),
+                ("${if(foo, foo, bar)}", "(foo) ? foo : bar"),
+                (
+                    "${if(match(foo, \"test\") != null, foo, bar)}",
+                    "(match(foo, \"test\") != null) ? foo : bar",
+                ),
+                ("${join(foo, \",\")}", "join(foo, \",\")"),
+                ("${join(foo, \":\", \"\\n\")}", "join(foo, \":\", \"\\n\")"),
+                (
+                    "${json_path(\"response.body.groups.*.id\")}",
+                    "json_path(\"response.body.groups.*.id\")",
+                ),
+                (
+                    "${match(response.body, \"test\")}",
+                    "match(response.body, \"test\")",
+                ),
+                ("${max(foo, bar)}", "max(foo, bar)"),
+                ("${min(foo, bar)}", "min(foo, bar)"),
+                ("${random(0, 10)}", "random(0, 10, ${p:null})"),
+                ("${random(1, 10)}", "random(1, 10, ${p:null})"),
+                ("${random(1.1, 10.3)}", "random(1.100, 10.300, ${p:null})"),
+                ("${range(0, 10)}", "range(0, 10)"),
+                ("${range(10, 0)}", "range(10, 0)"),
+                ("${range(foo, bar)}", "range(foo, bar)"),
+                ("${repeat(10)}", "repeat(10)"),
+                ("${repeat(5, 10)}", "repeat(5, 10)"),
+                (
+                    "${replace(\"abc\", foo, \"123\")}",
+                    "replace(\"abc\", foo, \"123\")",
+                ),
+                ("${parseInt(foo)}", "parseInt(foo)"),
+                ("${parseFloat(foo)}", "parseFloat(foo)"),
+            ]);
+
+            for (input, output) in &tests {
+                let t = Template::new(
+                    input,
+                    &BTreeMap::new(),
+                    &mut RequiredProviders::new(),
+                    false,
+                    unsafe { std::mem::zeroed() },
+                )
+                .unwrap();
+                let t = t.dump();
+                assert_eq!(t, vec![Segment::SingleExpression(output.to_string())]);
+            }
+        }
     }
 }
diff --git a/lib/config/src/configv2/loggers.rs b/lib/config/src/configv2/loggers.rs
index ce149935..daeebcd4 100644
--- a/lib/config/src/configv2/loggers.rs
+++ b/lib/config/src/configv2/loggers.rs
@@ -8,10 +8,10 @@ use serde::Deserialize;
 #[serde(deny_unknown_fields)]
 pub struct Logger<VD: Bool = True> {
     pub query: Option<super::query::Query<VD>>,
+    pub limit: Option<u64>,
     pub to: LogTo<VD>,
     #[serde(default)]
     pub pretty: bool,
-    pub limit: Option<u64>,
     #[serde(default)]
     pub kill: bool,
 }
diff --git a/lib/config/src/configv2/query.rs b/lib/config/src/configv2/query.rs
index ff82c881..c525f81f 100644
--- a/lib/config/src/configv2/query.rs
+++ b/lib/config/src/configv2/query.rs
@@ -101,16 +101,28 @@ impl<VD: Bool> Query<VD> {
     ///
     /// The json defines the structure of the select, where any terminal string value is an
     /// expression to evaluate.
-    pub fn from_json(json: &str) -> Result<Self, QueryGenError> {
+    pub fn complex_json(
+        json: &str,
+        for_each: Vec<String>,
+        r#where: Option<String>,
+    ) -> Result<Self, QueryGenError> {
         let structure: SelectTmp = serde_json::from_str(json)?;
 
         QueryTmp {
             select: structure,
-            for_each: vec![],
-            r#where: None,
+            for_each,
+            r#where,
         }
         .try_into()
     }
+
+    /// Create a query from a JSON string.
+    ///
+    /// The json defines the structure of the select, where any terminal string value is an
+    /// expression to evaluate.
+    pub fn from_json(json: &str) -> Result<Self, QueryGenError> {
+        Query::complex_json(json, vec![], None)
+    }
 }
 
 impl<VD: Bool> TryFrom<QueryTmp> for Query<VD> {
diff --git a/lib/config/src/configv2/templating.rs b/lib/config/src/configv2/templating.rs
index f9b70e79..ed5af583 100644
--- a/lib/config/src/configv2/templating.rs
+++ b/lib/config/src/configv2/templating.rs
@@ -479,6 +479,44 @@ impl<T: TemplateType> TemplatedString<T> {
                         _ => Err(crate::convert::TemplateSegmentError(s)),
                     }
                 }
+                template_convert::Segment::SingleExpression(x) => {
+                    Ok(Segment::Expr(vec![Segment::Raw(x)], True))
+                }
+                template_convert::Segment::MultiExpression(template_segments) => {
+                    let mut segments: Vec<Segment<T, helpers::True>> = vec![];
+                    for x in template_segments {
+                        match x {
+                            template_convert::Segment::Outer(s) => segments.push(Segment::Raw(s)),
+                            template_convert::Segment::SingleSource(s) => {
+                                // Assume segment type based on what is allowed, and if there is a var named
+                                // that
+                                match (
+                                    T::EnvsAllowed::try_default(),
+                                    T::VarsAllowed::try_default(),
+                                    T::ProvAllowed::try_default(),
+                                    var_names.contains::<str>(&s),
+                                ) {
+                                    (Some(b), None, None, _) => segments.push(Segment::Env(s, b)),
+                                    (None, Some(b), _, true) => segments.push(Segment::Var(s, b)),
+                                    (None, _, Some(b), _) => segments.push(Segment::Prov(s, b)),
+                                    _ => segments.push(Segment::Raw(
+                                        "PLACEHOLDER__PLEASE_UPDATE_MANUALLY".to_owned(),
+                                    )),
+                                }
+                            }
+                            template_convert::Segment::SingleExpression(x) => {
+                                segments.push(Segment::Raw(x))
+                            }
+                            template_convert::Segment::MultiExpression(_) => {
+                                panic!("Cannot have a MultiExpression inside a MultiExpression")
+                            }
+                            template_convert::Segment::Placeholder => segments.push(Segment::Raw(
+                                "PLACEHOLDER__PLEASE_UPDATE_MANUALLY".to_owned(),
+                            )),
+                        }
+                    }
+                    Ok(Segment::Expr(segments, True))
+                }
                 template_convert::Segment::Placeholder => Ok(Segment::Expr(
                     vec![Segment::Raw(
                         "PLACEHOLDER__PLEASE_UPDATE_MANUALLY".to_owned(),
diff --git a/lib/config/src/shared.rs b/lib/config/src/shared.rs
index 85ffdc08..466b6af5 100644
--- a/lib/config/src/shared.rs
+++ b/lib/config/src/shared.rs
@@ -119,3 +119,14 @@ impl FromStr for Epoch {
         }
     }
 }
+
+impl std::fmt::Display for Epoch {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Seconds => write!(f, "epoch(\"s\")"),
+            Self::Milliseconds => write!(f, "epoch(\"ms\")"),
+            Self::Microseconds => write!(f, "epoch(\"mu\")"),
+            Self::Nanoseconds => write!(f, "epoch(\"ns\")"),
+        }
+    }
+}
diff --git a/lib/config/src/shared/encode.rs b/lib/config/src/shared/encode.rs
index 3e97aa89..50e9b21b 100644
--- a/lib/config/src/shared/encode.rs
+++ b/lib/config/src/shared/encode.rs
@@ -105,3 +105,17 @@ impl FromStr for Encoding {
         }
     }
 }
+
+impl std::fmt::Display for Encoding {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Base64 => write!(f, "base64"),
+            Self::PercentSimple => write!(f, "percent-simple"),
+            Self::PercentQuery => write!(f, "percent-query"),
+            Self::Percent => write!(f, "percent"),
+            Self::PercentPath => write!(f, "percent-path"),
+            Self::PercentUserinfo => write!(f, "percent-userinfo"),
+            Self::NonAlphanumeric => write!(f, "non-alphanumeric"),
+        }
+    }
+}
diff --git a/pewpew-config-updater/README.md b/pewpew-config-updater/README.md
index 2b6e6578..a6e8b9a3 100644
--- a/pewpew-config-updater/README.md
+++ b/pewpew-config-updater/README.md
@@ -3,3 +3,8 @@ cli tool to partially automate conversion from `0.5.x` pewpew YAML config files
 Expression segments (queries and some templating sections) will need to be updated manually.
 
 setting `RUST_LOG` to at least `warn` is recommended, as log warnings can help indicate what needs to be updated manually
+
+
+Known issues:
+- Expressions in vars will not wrap environment variables in the expected `${e:VAR}`
+- vars in `logs` and `provides` will not have the prepended `_v.` before the var name.