diff --git a/deploy/setup.sql b/deploy/setup.sql
index 2cb3f5e..4d6fe5b 100644
--- a/deploy/setup.sql
+++ b/deploy/setup.sql
@@ -302,7 +302,7 @@ BEGIN
     RETURN _message;
 END;
 $f$
-LANGUAGE plpgsql
+LANGUAGE plpgsql;
 
 -----generate sql to create select based on schema
 DROP FUNCTION IF EXISTS tps.build_srce_view_sql(text, text);
@@ -773,14 +773,20 @@ $f$
                             NULL
                     END retain_val
                 FROM 
+                    --------------------------start with all regex maps------------------------------------------------------------------------------------
                     tps.map_rm m
+                    --------------------------isolate matching basis to limit map to only look at certain json---------------------------------------------
                     LEFT JOIN LATERAL jsonb_array_elements(m.regex->'regex'->'where') w(v) ON TRUE
+                    --------------------------join to main transaction table but only certain key/values are included--------------------------------------
                     INNER JOIN new_table t ON 
                         t.srce = m.srce AND
                         t.rec @> w.v
+                    --------------------------break out array of regluar expressions in the map------------------------------------------------------------
                     LEFT JOIN LATERAL jsonb_array_elements(m.regex->'regex'->'defn') WITH ORDINALITY e(v, rn) ON true
+                    --------------------------each regex references a path to the target value, extract the target from the reference and do regex---------
                     LEFT JOIN LATERAL regexp_matches(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text,COALESCE(e.v ->> 'flag','')) WITH ORDINALITY mt(mt, rn) ON
                         m.regex->'regex'->>'function' = 'extract'
+                    --------------------------same as above but for a replacement type function------------------------------------------------------------
                     LEFT JOIN LATERAL regexp_replace(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text, e.v ->> 'replace'::text,e.v ->> 'flag') WITH ORDINALITY rp(rp, rn) ON
                         m.regex->'regex'->>'function' = 'replace'
                 ORDER BY 
@@ -1190,7 +1196,7 @@ BEGIN
         t.rec,
         m.target,
         m.seq,
-        regex->>'function' regex_function,
+        regex->'regex'->>'function' regex_function,
         e.v ->> 'field' result_key_name,
         e.v ->> 'key' target_json_path,
         e.v ->> 'flag' regex_options_flag,
@@ -1209,7 +1215,7 @@ BEGIN
         END map_key,
         CASE e.v->>'map'
             WHEN 'y' THEN
-                CASE regex->>'function'
+                CASE regex->'regex'->>'function'
                     WHEN 'extract' THEN
                         CASE WHEN array_upper(mt.mt,1)=1 
                             THEN to_json(mt.mt[1])
@@ -1231,7 +1237,7 @@ BEGIN
         END retain_key,
         CASE e.v->>'retain'
             WHEN 'y' THEN
-                CASE regex->>'function'
+                CASE regex->'regex'->>'function'
                     WHEN 'extract' THEN
                         CASE WHEN array_upper(mt.mt,1)=1 
                             THEN to_json(trim(mt.mt[1]))
@@ -1246,16 +1252,22 @@ BEGIN
                 NULL
         END retain_val
     FROM 
+        --------------------------start with all regex maps------------------------------------------------------------------------------------
         tps.map_rm m
-        LEFT JOIN LATERAL jsonb_array_elements(m.regex->'where') w(v) ON TRUE
+        --------------------------isolate matching basis to limit map to only look at certain json---------------------------------------------
+        LEFT JOIN LATERAL jsonb_array_elements(m.regex->'regex'->'where') w(v) ON TRUE
+        --------------------------join to main transaction table but only certain key/values are included--------------------------------------
         INNER JOIN tps.trans t ON 
             t.srce = m.srce AND
             t.rec @> w.v
-        LEFT JOIN LATERAL jsonb_array_elements(m.regex->'defn') WITH ORDINALITY e(v, rn) ON true
+        --------------------------break out array of regluar expressions in the map------------------------------------------------------------
+        LEFT JOIN LATERAL jsonb_array_elements(m.regex->'regex'->'defn') WITH ORDINALITY e(v, rn) ON true
+        --------------------------each regex references a path to the target value, extract the target from the reference and do regex---------
         LEFT JOIN LATERAL regexp_matches(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text,COALESCE(e.v ->> 'flag','')) WITH ORDINALITY mt(mt, rn) ON
-            m.regex->>'function' = 'extract'
+            m.regex->'regex'->>'function' = 'extract'
+        --------------------------same as above but for a replacement type function------------------------------------------------------------
         LEFT JOIN LATERAL regexp_replace(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text, e.v ->> 'replace'::text,e.v ->> 'flag') WITH ORDINALITY rp(rp, rn) ON
-            m.regex->>'function' = 'replace'
+            m.regex->'regex'->>'function' = 'replace'
     WHERE
         --t.allj IS NULL
         t.srce = _srce
@@ -1510,88 +1522,89 @@ BEGIN
     --------------------apply regex operations to transactions---------------------------------------------------------------------------------
 
     rx AS (
-    SELECT 
-        t.srce,
-        t.id,
-        t.rec,
-        m.target,
-        m.seq,
-        regex->>'function' regex_function,
-        e.v ->> 'field' result_key_name,
-        e.v ->> 'key' target_json_path,
-        e.v ->> 'flag' regex_options_flag,
-        e.v->>'map' map_intention,
-        e.v->>'retain' retain_result,
-        e.v->>'regex' regex_expression,
-        e.rn target_item_number,
-        COALESCE(mt.rn,rp.rn,1) result_number,
-        mt.mt rx_match,
-        rp.rp rx_replace,
-        --------------------------json key name assigned to return value-----------------------------------------------------------------------
-        CASE e.v->>'map'
-            WHEN 'y' THEN
-                e.v->>'field'
-            ELSE
-                null
-        END map_key,
-        --------------------------json value resulting from regular expression-----------------------------------------------------------------
-        CASE e.v->>'map'
-            WHEN 'y' THEN
-                CASE regex->>'function'
-                    WHEN 'extract' THEN
-                        CASE WHEN array_upper(mt.mt,1)=1 
-                            THEN to_json(mt.mt[1])
-                            ELSE array_to_json(mt.mt)
-                        END::jsonb
-                    WHEN 'replace' THEN
-                        to_jsonb(rp.rp)
-                    ELSE
-                        '{}'::jsonb
-                END
-            ELSE
-                NULL
-        END map_val,
-        --------------------------flag for if retruned regex result is stored as a new part of the final json output---------------------------
-        CASE e.v->>'retain'
-            WHEN 'y' THEN
-                e.v->>'field'
-            ELSE
-                NULL
-        END retain_key,
-        --------------------------push regex result into json object---------------------------------------------------------------------------
-        CASE e.v->>'retain'
-            WHEN 'y' THEN
-                CASE regex->>'function'
-                    WHEN 'extract' THEN
-                        CASE WHEN array_upper(mt.mt,1)=1 
-                            THEN to_json(trim(mt.mt[1]))
-                            ELSE array_to_json(mt.mt)
-                        END::jsonb
-                    WHEN 'replace' THEN
-                        to_jsonb(rtrim(rp.rp))
-                    ELSE
-                        '{}'::jsonb
-                END
-            ELSE
-                NULL
-        END retain_val
-    FROM 
-        --------------------------start with all regex maps------------------------------------------------------------------------------------
-        (SELECT _defn->>'srce' srce, _defn->>'name' target, _defn->'regex' regex, (_defn->>'sequence')::numeric seq) m
-        --------------------------isolate matching basis to limit map to only look at certain json---------------------------------------------
-        JOIN LATERAL jsonb_array_elements(m.regex->'where') w(v) ON TRUE
-        --------------------------break out array of regluar expressions in the map------------------------------------------------------------
-        JOIN LATERAL jsonb_array_elements(m.regex->'defn') WITH ORDINALITY e(v, rn) ON true
-        --------------------------join to main transaction table but only certain key/values are included--------------------------------------
-        INNER JOIN tps.trans t ON 
-            t.srce = m.srce AND
-            t.rec @> w.v
-        --------------------------each regex references a path to the target value, extract the target from the reference and do regex---------
-        LEFT JOIN LATERAL regexp_matches(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text,COALESCE(e.v ->> 'flag','')) WITH ORDINALITY mt(mt, rn) ON
-            m.regex->>'function' = 'extract'
-        --------------------------same as above but for a replacement type function------------------------------------------------------------
-        LEFT JOIN LATERAL regexp_replace(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text, e.v ->> 'replace'::text,e.v ->> 'flag') WITH ORDINALITY rp(rp, rn) ON
-            m.regex->>'function' = 'replace'
+        SELECT 
+            t.srce,
+            t.id,
+            t.rec,
+            m.target,
+            m.seq,
+            regex->'regex'->>'function' regex_function,
+            e.v ->> 'field' result_key_name,
+            e.v ->> 'key' target_json_path,
+            e.v ->> 'flag' regex_options_flag,
+            e.v->>'map' map_intention,
+            e.v->>'retain' retain_result,
+            e.v->>'regex' regex_expression,
+            e.rn target_item_number,
+            COALESCE(mt.rn,rp.rn,1) result_number,
+            mt.mt rx_match,
+            rp.rp rx_replace,
+            CASE e.v->>'map'
+                WHEN 'y' THEN
+                    e.v->>'field'
+                ELSE
+                    null
+            END map_key,
+            CASE e.v->>'map'
+                WHEN 'y' THEN
+                    CASE regex->'regex'->>'function'
+                        WHEN 'extract' THEN
+                            CASE WHEN array_upper(mt.mt,1)=1 
+                                THEN to_json(mt.mt[1])
+                                ELSE array_to_json(mt.mt)
+                            END::jsonb
+                        WHEN 'replace' THEN
+                            to_jsonb(rp.rp)
+                        ELSE
+                            '{}'::jsonb
+                    END
+                ELSE
+                    NULL
+            END map_val,
+            CASE e.v->>'retain'
+                WHEN 'y' THEN
+                    e.v->>'field'
+                ELSE
+                    NULL
+            END retain_key,
+            CASE e.v->>'retain'
+                WHEN 'y' THEN
+                    CASE regex->'regex'->>'function'
+                        WHEN 'extract' THEN
+                            CASE WHEN array_upper(mt.mt,1)=1 
+                                THEN to_json(trim(mt.mt[1]))
+                                ELSE array_to_json(mt.mt)
+                            END::jsonb
+                        WHEN 'replace' THEN
+                            to_jsonb(rtrim(rp.rp))
+                        ELSE
+                            '{}'::jsonb
+                    END
+                ELSE
+                    NULL
+            END retain_val
+        FROM 
+            --------------------------start with all regex maps------------------------------------------------------------------------------------
+            (SELECT _defn->>'srce' srce, _defn->>'name' target, _defn->'regex' regex, (_defn->>'sequence')::numeric seq) m
+            --------------------------isolate matching basis to limit map to only look at certain json---------------------------------------------
+            LEFT JOIN LATERAL jsonb_array_elements(m.regex->'regex'->'where') w(v) ON TRUE
+            --------------------------break out array of regluar expressions in the map------------------------------------------------------------
+            LEFT JOIN LATERAL jsonb_array_elements(m.regex->'regex'->'defn') WITH ORDINALITY e(v, rn) ON true
+            --------------------------join to main transaction table but only certain key/values are included--------------------------------------
+            INNER JOIN tps.trans t ON 
+                t.srce = m.srce AND
+                t.rec @> w.v
+            --------------------------each regex references a path to the target value, extract the target from the reference and do regex---------
+            LEFT JOIN LATERAL regexp_matches(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text,COALESCE(e.v ->> 'flag','')) WITH ORDINALITY mt(mt, rn) ON
+                m.regex->'regex'->>'function' = 'extract'
+            --------------------------same as above but for a replacement type function------------------------------------------------------------
+            LEFT JOIN LATERAL regexp_replace(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text, e.v ->> 'replace'::text,e.v ->> 'flag') WITH ORDINALITY rp(rp, rn) ON
+                m.regex->'regex'->>'function' = 'replace'
+        ORDER BY 
+            t.id DESC,
+            m.target,
+            e.rn,
+            COALESCE(mt.rn,rp.rn,1)
     )
 
     --SELECT * FROM rx LIMIT 100
@@ -1734,88 +1747,89 @@ WITH
 --------------------apply regex operations to transactions---------------------------------------------------------------------------------
 
 rx AS (
-SELECT 
-    t.srce,
-    t.id,
-    t.rec,
-    m.target,
-    m.seq,
-    regex->>'function' regex_function,
-    e.v ->> 'field' result_key_name,
-    e.v ->> 'key' target_json_path,
-    e.v ->> 'flag' regex_options_flag,
-    e.v->>'map' map_intention,
-    e.v->>'retain' retain_result,
-    e.v->>'regex' regex_expression,
-    e.rn target_item_number,
-    COALESCE(mt.rn,rp.rn,1) result_number,
-    mt.mt rx_match,
-    rp.rp rx_replace,
-    --------------------------json key name assigned to return value-----------------------------------------------------------------------
-    CASE e.v->>'map'
-        WHEN 'y' THEN
-            e.v->>'field'
-        ELSE
-            null
-    END map_key,
-    --------------------------json value resulting from regular expression-----------------------------------------------------------------
-    CASE e.v->>'map'
-        WHEN 'y' THEN
-            CASE regex->>'function'
-                WHEN 'extract' THEN
-                    CASE WHEN array_upper(mt.mt,1)=1 
-                        THEN to_json(mt.mt[1])
-                        ELSE array_to_json(mt.mt)
-                    END::jsonb
-                WHEN 'replace' THEN
-                    to_jsonb(rp.rp)
+        SELECT 
+            t.srce,
+            t.id,
+            t.rec,
+            m.target,
+            m.seq,
+            regex->'regex'->>'function' regex_function,
+            e.v ->> 'field' result_key_name,
+            e.v ->> 'key' target_json_path,
+            e.v ->> 'flag' regex_options_flag,
+            e.v->>'map' map_intention,
+            e.v->>'retain' retain_result,
+            e.v->>'regex' regex_expression,
+            e.rn target_item_number,
+            COALESCE(mt.rn,rp.rn,1) result_number,
+            mt.mt rx_match,
+            rp.rp rx_replace,
+            CASE e.v->>'map'
+                WHEN 'y' THEN
+                    e.v->>'field'
                 ELSE
-                    '{}'::jsonb
-            END
-        ELSE
-            NULL
-    END map_val,
-    --------------------------flag for if retruned regex result is stored as a new part of the final json output---------------------------
-    CASE e.v->>'retain'
-        WHEN 'y' THEN
-            e.v->>'field'
-        ELSE
-            NULL
-    END retain_key,
-    --------------------------push regex result into json object---------------------------------------------------------------------------
-    CASE e.v->>'retain'
-        WHEN 'y' THEN
-            CASE regex->>'function'
-                WHEN 'extract' THEN
-                    CASE WHEN array_upper(mt.mt,1)=1 
-                        THEN to_json(trim(mt.mt[1]))
-                        ELSE array_to_json(mt.mt)
-                    END::jsonb
-                WHEN 'replace' THEN
-                    to_jsonb(rtrim(rp.rp))
+                    null
+            END map_key,
+            CASE e.v->>'map'
+                WHEN 'y' THEN
+                    CASE regex->'regex'->>'function'
+                        WHEN 'extract' THEN
+                            CASE WHEN array_upper(mt.mt,1)=1 
+                                THEN to_json(mt.mt[1])
+                                ELSE array_to_json(mt.mt)
+                            END::jsonb
+                        WHEN 'replace' THEN
+                            to_jsonb(rp.rp)
+                        ELSE
+                            '{}'::jsonb
+                    END
                 ELSE
-                    '{}'::jsonb
-            END
-        ELSE
-            NULL
-    END retain_val
-FROM 
-    --------------------------start with all regex maps------------------------------------------------------------------------------------
-    (SELECT _defn->>'srce' srce, _defn->>'name' target, _defn->'regex' regex, (_defn->>'sequence')::numeric seq) m
-    --------------------------isolate matching basis to limit map to only look at certain json---------------------------------------------
-    JOIN LATERAL jsonb_array_elements(m.regex->'where') w(v) ON TRUE
-    --------------------------break out array of regluar expressions in the map------------------------------------------------------------
-    JOIN LATERAL jsonb_array_elements(m.regex->'defn') WITH ORDINALITY e(v, rn) ON true
-    --------------------------join to main transaction table but only certain key/values are included--------------------------------------
-    INNER JOIN tps.trans t ON 
-        t.srce = m.srce AND
-        t.rec @> w.v
-    --------------------------each regex references a path to the target value, extract the target from the reference and do regex---------
-    LEFT JOIN LATERAL regexp_matches(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text,COALESCE(e.v ->> 'flag','')) WITH ORDINALITY mt(mt, rn) ON
-        m.regex->>'function' = 'extract'
-    --------------------------same as above but for a replacement type function------------------------------------------------------------
-    LEFT JOIN LATERAL regexp_replace(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text, e.v ->> 'replace'::text,e.v ->> 'flag') WITH ORDINALITY rp(rp, rn) ON
-        m.regex->>'function' = 'replace'
+                    NULL
+            END map_val,
+            CASE e.v->>'retain'
+                WHEN 'y' THEN
+                    e.v->>'field'
+                ELSE
+                    NULL
+            END retain_key,
+            CASE e.v->>'retain'
+                WHEN 'y' THEN
+                    CASE regex->'regex'->>'function'
+                        WHEN 'extract' THEN
+                            CASE WHEN array_upper(mt.mt,1)=1 
+                                THEN to_json(trim(mt.mt[1]))
+                                ELSE array_to_json(mt.mt)
+                            END::jsonb
+                        WHEN 'replace' THEN
+                            to_jsonb(rtrim(rp.rp))
+                        ELSE
+                            '{}'::jsonb
+                    END
+                ELSE
+                    NULL
+            END retain_val
+        FROM 
+            --------------------------start with all regex maps------------------------------------------------------------------------------------
+            (SELECT _defn->>'srce' srce, _defn->>'name' target, _defn regex, (_defn->>'sequence')::numeric seq) m
+            --------------------------isolate matching basis to limit map to only look at certain json---------------------------------------------
+            LEFT JOIN LATERAL jsonb_array_elements(m.regex->'regex'->'where') w(v) ON TRUE
+            --------------------------break out array of regluar expressions in the map------------------------------------------------------------
+            LEFT JOIN LATERAL jsonb_array_elements(m.regex->'regex'->'defn') WITH ORDINALITY e(v, rn) ON true
+            --------------------------join to main transaction table but only certain key/values are included--------------------------------------
+            INNER JOIN tps.trans t ON 
+                t.srce = m.srce AND
+                t.rec @> w.v
+            --------------------------each regex references a path to the target value, extract the target from the reference and do regex---------
+            LEFT JOIN LATERAL regexp_matches(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text,COALESCE(e.v ->> 'flag','')) WITH ORDINALITY mt(mt, rn) ON
+                m.regex->'regex'->>'function' = 'extract'
+            --------------------------same as above but for a replacement type function------------------------------------------------------------
+            LEFT JOIN LATERAL regexp_replace(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text, e.v ->> 'replace'::text,e.v ->> 'flag') WITH ORDINALITY rp(rp, rn) ON
+                m.regex->'regex'->>'function' = 'replace'
+        ORDER BY 
+            t.id DESC,
+            m.target,
+            e.rn,
+            COALESCE(mt.rn,rp.rn,1)
 )
 
 --SELECT * FROM rx LIMIT 100
diff --git a/interface/import/map_trigger.sql b/interface/import/map_trigger.sql
index 6002dc1..f9215e3 100644
--- a/interface/import/map_trigger.sql
+++ b/interface/import/map_trigger.sql
@@ -74,14 +74,20 @@ $f$
                             NULL
                     END retain_val
                 FROM 
+                    --------------------------start with all regex maps------------------------------------------------------------------------------------
                     tps.map_rm m
+                    --------------------------isolate matching basis to limit map to only look at certain json---------------------------------------------
                     LEFT JOIN LATERAL jsonb_array_elements(m.regex->'regex'->'where') w(v) ON TRUE
+                    --------------------------join to main transaction table but only certain key/values are included--------------------------------------
                     INNER JOIN new_table t ON 
                         t.srce = m.srce AND
                         t.rec @> w.v
+                    --------------------------break out array of regluar expressions in the map------------------------------------------------------------
                     LEFT JOIN LATERAL jsonb_array_elements(m.regex->'regex'->'defn') WITH ORDINALITY e(v, rn) ON true
+                    --------------------------each regex references a path to the target value, extract the target from the reference and do regex---------
                     LEFT JOIN LATERAL regexp_matches(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text,COALESCE(e.v ->> 'flag','')) WITH ORDINALITY mt(mt, rn) ON
                         m.regex->'regex'->>'function' = 'extract'
+                    --------------------------same as above but for a replacement type function------------------------------------------------------------
                     LEFT JOIN LATERAL regexp_replace(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text, e.v ->> 'replace'::text,e.v ->> 'flag') WITH ORDINALITY rp(rp, rn) ON
                         m.regex->'regex'->>'function' = 'replace'
                 ORDER BY 
diff --git a/interface/map_def/test_regex.sql b/interface/map_def/test_regex.sql
index 71e928d..d09b6e9 100644
--- a/interface/map_def/test_regex.sql
+++ b/interface/map_def/test_regex.sql
@@ -12,88 +12,89 @@ BEGIN
     --------------------apply regex operations to transactions---------------------------------------------------------------------------------
 
     rx AS (
-    SELECT 
-        t.srce,
-        t.id,
-        t.rec,
-        m.target,
-        m.seq,
-        regex->>'function' regex_function,
-        e.v ->> 'field' result_key_name,
-        e.v ->> 'key' target_json_path,
-        e.v ->> 'flag' regex_options_flag,
-        e.v->>'map' map_intention,
-        e.v->>'retain' retain_result,
-        e.v->>'regex' regex_expression,
-        e.rn target_item_number,
-        COALESCE(mt.rn,rp.rn,1) result_number,
-        mt.mt rx_match,
-        rp.rp rx_replace,
-        --------------------------json key name assigned to return value-----------------------------------------------------------------------
-        CASE e.v->>'map'
-            WHEN 'y' THEN
-                e.v->>'field'
-            ELSE
-                null
-        END map_key,
-        --------------------------json value resulting from regular expression-----------------------------------------------------------------
-        CASE e.v->>'map'
-            WHEN 'y' THEN
-                CASE regex->>'function'
-                    WHEN 'extract' THEN
-                        CASE WHEN array_upper(mt.mt,1)=1 
-                            THEN to_json(mt.mt[1])
-                            ELSE array_to_json(mt.mt)
-                        END::jsonb
-                    WHEN 'replace' THEN
-                        to_jsonb(rp.rp)
-                    ELSE
-                        '{}'::jsonb
-                END
-            ELSE
-                NULL
-        END map_val,
-        --------------------------flag for if retruned regex result is stored as a new part of the final json output---------------------------
-        CASE e.v->>'retain'
-            WHEN 'y' THEN
-                e.v->>'field'
-            ELSE
-                NULL
-        END retain_key,
-        --------------------------push regex result into json object---------------------------------------------------------------------------
-        CASE e.v->>'retain'
-            WHEN 'y' THEN
-                CASE regex->>'function'
-                    WHEN 'extract' THEN
-                        CASE WHEN array_upper(mt.mt,1)=1 
-                            THEN to_json(trim(mt.mt[1]))
-                            ELSE array_to_json(mt.mt)
-                        END::jsonb
-                    WHEN 'replace' THEN
-                        to_jsonb(rtrim(rp.rp))
-                    ELSE
-                        '{}'::jsonb
-                END
-            ELSE
-                NULL
-        END retain_val
-    FROM 
-        --------------------------start with all regex maps------------------------------------------------------------------------------------
-        (SELECT _defn->>'srce' srce, _defn->>'name' target, _defn->'regex' regex, (_defn->>'sequence')::numeric seq) m
-        --------------------------isolate matching basis to limit map to only look at certain json---------------------------------------------
-        JOIN LATERAL jsonb_array_elements(m.regex->'where') w(v) ON TRUE
-        --------------------------break out array of regluar expressions in the map------------------------------------------------------------
-        JOIN LATERAL jsonb_array_elements(m.regex->'defn') WITH ORDINALITY e(v, rn) ON true
-        --------------------------join to main transaction table but only certain key/values are included--------------------------------------
-        INNER JOIN tps.trans t ON 
-            t.srce = m.srce AND
-            t.rec @> w.v
-        --------------------------each regex references a path to the target value, extract the target from the reference and do regex---------
-        LEFT JOIN LATERAL regexp_matches(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text,COALESCE(e.v ->> 'flag','')) WITH ORDINALITY mt(mt, rn) ON
-            m.regex->>'function' = 'extract'
-        --------------------------same as above but for a replacement type function------------------------------------------------------------
-        LEFT JOIN LATERAL regexp_replace(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text, e.v ->> 'replace'::text,e.v ->> 'flag') WITH ORDINALITY rp(rp, rn) ON
-            m.regex->>'function' = 'replace'
+        SELECT 
+            t.srce,
+            t.id,
+            t.rec,
+            m.target,
+            m.seq,
+            regex->'regex'->>'function' regex_function,
+            e.v ->> 'field' result_key_name,
+            e.v ->> 'key' target_json_path,
+            e.v ->> 'flag' regex_options_flag,
+            e.v->>'map' map_intention,
+            e.v->>'retain' retain_result,
+            e.v->>'regex' regex_expression,
+            e.rn target_item_number,
+            COALESCE(mt.rn,rp.rn,1) result_number,
+            mt.mt rx_match,
+            rp.rp rx_replace,
+            CASE e.v->>'map'
+                WHEN 'y' THEN
+                    e.v->>'field'
+                ELSE
+                    null
+            END map_key,
+            CASE e.v->>'map'
+                WHEN 'y' THEN
+                    CASE regex->'regex'->>'function'
+                        WHEN 'extract' THEN
+                            CASE WHEN array_upper(mt.mt,1)=1 
+                                THEN to_json(mt.mt[1])
+                                ELSE array_to_json(mt.mt)
+                            END::jsonb
+                        WHEN 'replace' THEN
+                            to_jsonb(rp.rp)
+                        ELSE
+                            '{}'::jsonb
+                    END
+                ELSE
+                    NULL
+            END map_val,
+            CASE e.v->>'retain'
+                WHEN 'y' THEN
+                    e.v->>'field'
+                ELSE
+                    NULL
+            END retain_key,
+            CASE e.v->>'retain'
+                WHEN 'y' THEN
+                    CASE regex->'regex'->>'function'
+                        WHEN 'extract' THEN
+                            CASE WHEN array_upper(mt.mt,1)=1 
+                                THEN to_json(trim(mt.mt[1]))
+                                ELSE array_to_json(mt.mt)
+                            END::jsonb
+                        WHEN 'replace' THEN
+                            to_jsonb(rtrim(rp.rp))
+                        ELSE
+                            '{}'::jsonb
+                    END
+                ELSE
+                    NULL
+            END retain_val
+        FROM 
+            --------------------------start with all regex maps------------------------------------------------------------------------------------
+            (SELECT _defn->>'srce' srce, _defn->>'name' target, _defn regex, (_defn->>'sequence')::numeric seq) m
+            --------------------------isolate matching basis to limit map to only look at certain json---------------------------------------------
+            LEFT JOIN LATERAL jsonb_array_elements(m.regex->'regex'->'where') w(v) ON TRUE
+            --------------------------break out array of regluar expressions in the map------------------------------------------------------------
+            LEFT JOIN LATERAL jsonb_array_elements(m.regex->'regex'->'defn') WITH ORDINALITY e(v, rn) ON true
+            --------------------------join to main transaction table but only certain key/values are included--------------------------------------
+            INNER JOIN tps.trans t ON 
+                t.srce = m.srce AND
+                t.rec @> w.v
+            --------------------------each regex references a path to the target value, extract the target from the reference and do regex---------
+            LEFT JOIN LATERAL regexp_matches(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text,COALESCE(e.v ->> 'flag','')) WITH ORDINALITY mt(mt, rn) ON
+                m.regex->'regex'->>'function' = 'extract'
+            --------------------------same as above but for a replacement type function------------------------------------------------------------
+            LEFT JOIN LATERAL regexp_replace(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text, e.v ->> 'replace'::text,e.v ->> 'flag') WITH ORDINALITY rp(rp, rn) ON
+                m.regex->'regex'->>'function' = 'replace'
+        ORDER BY 
+            t.id DESC,
+            m.target,
+            e.rn,
+            COALESCE(mt.rn,rp.rn,1)
     )
 
     --SELECT * FROM rx LIMIT 100
diff --git a/interface/map_def/test_regex_recs.sql b/interface/map_def/test_regex_recs.sql
index 3522b0e..2844ba3 100644
--- a/interface/map_def/test_regex_recs.sql
+++ b/interface/map_def/test_regex_recs.sql
@@ -12,88 +12,89 @@ WITH
 --------------------apply regex operations to transactions---------------------------------------------------------------------------------
 
 rx AS (
-SELECT 
-    t.srce,
-    t.id,
-    t.rec,
-    m.target,
-    m.seq,
-    regex->>'function' regex_function,
-    e.v ->> 'field' result_key_name,
-    e.v ->> 'key' target_json_path,
-    e.v ->> 'flag' regex_options_flag,
-    e.v->>'map' map_intention,
-    e.v->>'retain' retain_result,
-    e.v->>'regex' regex_expression,
-    e.rn target_item_number,
-    COALESCE(mt.rn,rp.rn,1) result_number,
-    mt.mt rx_match,
-    rp.rp rx_replace,
-    --------------------------json key name assigned to return value-----------------------------------------------------------------------
-    CASE e.v->>'map'
-        WHEN 'y' THEN
-            e.v->>'field'
-        ELSE
-            null
-    END map_key,
-    --------------------------json value resulting from regular expression-----------------------------------------------------------------
-    CASE e.v->>'map'
-        WHEN 'y' THEN
-            CASE regex->>'function'
-                WHEN 'extract' THEN
-                    CASE WHEN array_upper(mt.mt,1)=1 
-                        THEN to_json(mt.mt[1])
-                        ELSE array_to_json(mt.mt)
-                    END::jsonb
-                WHEN 'replace' THEN
-                    to_jsonb(rp.rp)
+        SELECT 
+            t.srce,
+            t.id,
+            t.rec,
+            m.target,
+            m.seq,
+            regex->'regex'->>'function' regex_function,
+            e.v ->> 'field' result_key_name,
+            e.v ->> 'key' target_json_path,
+            e.v ->> 'flag' regex_options_flag,
+            e.v->>'map' map_intention,
+            e.v->>'retain' retain_result,
+            e.v->>'regex' regex_expression,
+            e.rn target_item_number,
+            COALESCE(mt.rn,rp.rn,1) result_number,
+            mt.mt rx_match,
+            rp.rp rx_replace,
+            CASE e.v->>'map'
+                WHEN 'y' THEN
+                    e.v->>'field'
                 ELSE
-                    '{}'::jsonb
-            END
-        ELSE
-            NULL
-    END map_val,
-    --------------------------flag for if retruned regex result is stored as a new part of the final json output---------------------------
-    CASE e.v->>'retain'
-        WHEN 'y' THEN
-            e.v->>'field'
-        ELSE
-            NULL
-    END retain_key,
-    --------------------------push regex result into json object---------------------------------------------------------------------------
-    CASE e.v->>'retain'
-        WHEN 'y' THEN
-            CASE regex->>'function'
-                WHEN 'extract' THEN
-                    CASE WHEN array_upper(mt.mt,1)=1 
-                        THEN to_json(trim(mt.mt[1]))
-                        ELSE array_to_json(mt.mt)
-                    END::jsonb
-                WHEN 'replace' THEN
-                    to_jsonb(rtrim(rp.rp))
+                    null
+            END map_key,
+            CASE e.v->>'map'
+                WHEN 'y' THEN
+                    CASE regex->'regex'->>'function'
+                        WHEN 'extract' THEN
+                            CASE WHEN array_upper(mt.mt,1)=1 
+                                THEN to_json(mt.mt[1])
+                                ELSE array_to_json(mt.mt)
+                            END::jsonb
+                        WHEN 'replace' THEN
+                            to_jsonb(rp.rp)
+                        ELSE
+                            '{}'::jsonb
+                    END
                 ELSE
-                    '{}'::jsonb
-            END
-        ELSE
-            NULL
-    END retain_val
-FROM 
-    --------------------------start with all regex maps------------------------------------------------------------------------------------
-    (SELECT _defn->>'srce' srce, _defn->>'name' target, _defn->'regex' regex, (_defn->>'sequence')::numeric seq) m
-    --------------------------isolate matching basis to limit map to only look at certain json---------------------------------------------
-    JOIN LATERAL jsonb_array_elements(m.regex->'where') w(v) ON TRUE
-    --------------------------break out array of regluar expressions in the map------------------------------------------------------------
-    JOIN LATERAL jsonb_array_elements(m.regex->'defn') WITH ORDINALITY e(v, rn) ON true
-    --------------------------join to main transaction table but only certain key/values are included--------------------------------------
-    INNER JOIN tps.trans t ON 
-        t.srce = m.srce AND
-        t.rec @> w.v
-    --------------------------each regex references a path to the target value, extract the target from the reference and do regex---------
-    LEFT JOIN LATERAL regexp_matches(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text,COALESCE(e.v ->> 'flag','')) WITH ORDINALITY mt(mt, rn) ON
-        m.regex->>'function' = 'extract'
-    --------------------------same as above but for a replacement type function------------------------------------------------------------
-    LEFT JOIN LATERAL regexp_replace(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text, e.v ->> 'replace'::text,e.v ->> 'flag') WITH ORDINALITY rp(rp, rn) ON
-        m.regex->>'function' = 'replace'
+                    NULL
+            END map_val,
+            CASE e.v->>'retain'
+                WHEN 'y' THEN
+                    e.v->>'field'
+                ELSE
+                    NULL
+            END retain_key,
+            CASE e.v->>'retain'
+                WHEN 'y' THEN
+                    CASE regex->'regex'->>'function'
+                        WHEN 'extract' THEN
+                            CASE WHEN array_upper(mt.mt,1)=1 
+                                THEN to_json(trim(mt.mt[1]))
+                                ELSE array_to_json(mt.mt)
+                            END::jsonb
+                        WHEN 'replace' THEN
+                            to_jsonb(rtrim(rp.rp))
+                        ELSE
+                            '{}'::jsonb
+                    END
+                ELSE
+                    NULL
+            END retain_val
+        FROM 
+            --------------------------start with all regex maps------------------------------------------------------------------------------------
+            (SELECT _defn->>'srce' srce, _defn->>'name' target, _defn regex, (_defn->>'sequence')::numeric seq) m
+            --------------------------isolate matching basis to limit map to only look at certain json---------------------------------------------
+            LEFT JOIN LATERAL jsonb_array_elements(m.regex->'regex'->'where') w(v) ON TRUE
+            --------------------------break out array of regluar expressions in the map------------------------------------------------------------
+            LEFT JOIN LATERAL jsonb_array_elements(m.regex->'regex'->'defn') WITH ORDINALITY e(v, rn) ON true
+            --------------------------join to main transaction table but only certain key/values are included--------------------------------------
+            INNER JOIN tps.trans t ON 
+                t.srce = m.srce AND
+                t.rec @> w.v
+            --------------------------each regex references a path to the target value, extract the target from the reference and do regex---------
+            LEFT JOIN LATERAL regexp_matches(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text,COALESCE(e.v ->> 'flag','')) WITH ORDINALITY mt(mt, rn) ON
+                m.regex->'regex'->>'function' = 'extract'
+            --------------------------same as above but for a replacement type function------------------------------------------------------------
+            LEFT JOIN LATERAL regexp_replace(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text, e.v ->> 'replace'::text,e.v ->> 'flag') WITH ORDINALITY rp(rp, rn) ON
+                m.regex->'regex'->>'function' = 'replace'
+        ORDER BY 
+            t.id DESC,
+            m.target,
+            e.rn,
+            COALESCE(mt.rn,rp.rn,1)
 )
 
 --SELECT * FROM rx LIMIT 100
diff --git a/interface/map_values/srce_map_overwrite.sql b/interface/map_values/srce_map_overwrite.sql
index 408f8a9..4706f44 100644
--- a/interface/map_values/srce_map_overwrite.sql
+++ b/interface/map_values/srce_map_overwrite.sql
@@ -74,14 +74,20 @@ BEGIN
                 NULL
         END retain_val
     FROM 
+        --------------------------start with all regex maps------------------------------------------------------------------------------------
         tps.map_rm m
+        --------------------------isolate matching basis to limit map to only look at certain json---------------------------------------------
         LEFT JOIN LATERAL jsonb_array_elements(m.regex->'regex'->'where') w(v) ON TRUE
+        --------------------------join to main transaction table but only certain key/values are included--------------------------------------
         INNER JOIN tps.trans t ON 
             t.srce = m.srce AND
             t.rec @> w.v
+        --------------------------break out array of regluar expressions in the map------------------------------------------------------------
         LEFT JOIN LATERAL jsonb_array_elements(m.regex->'regex'->'defn') WITH ORDINALITY e(v, rn) ON true
+        --------------------------each regex references a path to the target value, extract the target from the reference and do regex---------
         LEFT JOIN LATERAL regexp_matches(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text,COALESCE(e.v ->> 'flag','')) WITH ORDINALITY mt(mt, rn) ON
             m.regex->'regex'->>'function' = 'extract'
+        --------------------------same as above but for a replacement type function------------------------------------------------------------
         LEFT JOIN LATERAL regexp_replace(t.rec #>> ((e.v ->> 'key')::text[]), e.v ->> 'regex'::text, e.v ->> 'replace'::text,e.v ->> 'flag') WITH ORDINALITY rp(rp, rn) ON
             m.regex->'regex'->>'function' = 'replace'
     WHERE