@xuda.io/runtime-bundle 1.0.1247 → 1.0.1249

package/js/xuda-runtime-bundle.js

@@ -24677,11 +24677,6 @@ func.common.get_data_from_websocket = async function (SESSION_ID, serviceP, data
 };
 
 func.common.sha256 = async function (inputString) {
-  // const enc = new TextEncoder();
-  // const buf = await crypto.subtle.digest('SHA-256', enc.encode(str));
-  // const bytes = new Uint8Array(buf);
-  // return [...bytes].map((b) => b.toString(16).padStart(2, '0')).join('');
-
   // 1. Create a hash buffer from the input string using SHA-256.
   // This part remains the same as it provides a strong, unique cryptographic starting point.
   const buffer = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(inputString));
@@ -31895,469 +31890,1357 @@ const get_params_obj_new = async function (SESSION_ID, prog_id, nodeP, dsSession
   return { params_res, params_raw };
 };
 
-func.UI.screen.execute_xu_functions = async function (SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, xu_func, $elm, val, is_init, refreshed_ds) {
-  if (is_skeleton) return;
+// func.UI.screen.execute_xu_functions = async function (SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, xu_func, $elm, val, is_init, refreshed_ds) {
+//   if (is_skeleton) return;
+
+//   // console.log(nodeP.id, xu_func, val);
+//   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[paramsP.dsSessionP];
+//   const tag_fx = {
+//     [`xu-panel`]: {
+//       program: async function ($elm, val) {
+//         var ret = {};
+//         var _session = SESSION_OBJ[SESSION_ID];
+//         var _ds = _session.DS_GLB[paramsP.dsSessionP];
+//         const init_program = async function () {
+//           async function render_panel() {
+//             const prog_id = val.value?.prog || val.value;
+//             const params_obj = await get_params_obj_new(SESSION_ID, prog_id, nodeP, paramsP.dsSessionP);
+//             let ret_panel = await func.UI.screen.init(SESSION_ID, prog_id, paramsP.screenId, _ds, $elm, null, _ds.currentRecordId, null, true, params_obj.params_res, 'initXu_panel', undefined, prog_id !== _ds.prog_id ? null : refreshed_ds, params_obj.params_raw);
+//             ret = { $new_div: ret_panel };
+//             if ($container.data().xuData) {
+//               $container.data().xuData.xuPanelProps = $elm.data().xuAttributes;
+//               $container.data().xuData.xuPanelData = ret_panel.data();
+//             }
+//             return ret;
+//           }
 
-  // console.log(nodeP.id, xu_func, val);
-  var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[paramsP.dsSessionP];
-  const tag_fx = {
-    [`xu-panel`]: {
-      program: async function ($elm, val) {
-        var ret = {};
-        var _session = SESSION_OBJ[SESSION_ID];
-        var _ds = _session.DS_GLB[paramsP.dsSessionP];
-        const init_program = async function () {
-          async function render_panel() {
-            const prog_id = val.value?.prog || val.value;
-            const params_obj = await get_params_obj_new(SESSION_ID, prog_id, nodeP, paramsP.dsSessionP);
-            let ret_panel = await func.UI.screen.init(SESSION_ID, prog_id, paramsP.screenId, _ds, $elm, null, _ds.currentRecordId, null, true, params_obj.params_res, 'initXu_panel', undefined, prog_id !== _ds.prog_id ? null : refreshed_ds, params_obj.params_raw);
-            ret = { $new_div: ret_panel };
-            if ($container.data().xuData) {
-              $container.data().xuData.xuPanelProps = $elm.data().xuAttributes;
-              $container.data().xuData.xuPanelData = ret_panel.data();
-            }
-            return ret;
-          }
+//           if (!val.value) {
+//             val.value = '_empty_panel_program';
+//           }
 
-          if (!val.value) {
-            val.value = '_empty_panel_program';
-          }
+//           ret = await render_panel();
 
-          ret = await render_panel();
+//           return ret;
+//         };
+//         const alter_program = async function () {
+//           var _session = SESSION_OBJ[SESSION_ID];
+//           var _ds = _session.DS_GLB[paramsP.dsSessionP];
+
+//           /////////////////
+//           async function render_panel() {
+//             //   // if (!cache_str) {
+//             //   //   await update_container(screen_ready_function);
+//             //   // }
+//             //   // if (cache_str && !CACHE_PROG_UI[cache_str]) {
+//             //   //   await update_container(screen_ready_function);
+//             //   //   save_cache();
+//             //   // }
+//             //   // if (callback) callback($div);
+//             //   // $container.data().xuData.node.children =
+//             //   //   $div.data().xuData.node.children;
+//             //   // //swiper-wrapper
+//             //   // var restore_slides_elements = async function () {
+//             //   //   if ($tmp_div.children().length) {
+//             //   //     $tmp_div
+//             //   //       .find(".swiper-wrapper")
+//             //   //       .empty()
+//             //   //       .append($new_div.children());
+//             //   //     $new_div.append($tmp_div.children());
+//             //   //   }
+//             //   // };
+//             //   // // console.log($tmp_div);
+//             //   // await restore_slides_elements();
+//             //   // // CHANGE_PANEL_BUSY = false;
+//             //   // func.events.delete_job(SESSION_ID, jobNo);
+//             // };
+//             const program = val.value?.prog || val.value;
+//             var $wrapper = $('<div>');
+//             var $div = await func.UI.screen.create_container(SESSION_ID, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, nodeP.attributes, null, null, null, $wrapper, '');
+//             const params_obj = await get_params_obj_new(SESSION_ID, program, nodeP, paramsP.dsSessionP);
+//             let ret_init = await func.UI.screen.init(SESSION_ID, program, paramsP.screenId, _ds, $div, null, _ds.currentRecordId, jobNoP, true, params_obj.params_res, 'alterXu_panel', undefined, undefined, params_obj.params_raw);
+//             ret = {
+//               $new_div: ret_init,
+//               abort: true,
+//             };
+//             await func.UI.screen.panel_post_render_handler(SESSION_ID, $elm, $new_div, nodeP, $div.clone(true), jobNoP);
+
+//             return ret;
+//           }
+//           if (!val.value) {
+//             return { abort: true };
+//           }
+//           await render_panel();
+//           return ret;
+//         };
 
-          return ret;
-        };
-        const alter_program = async function () {
-          var _session = SESSION_OBJ[SESSION_ID];
-          var _ds = _session.DS_GLB[paramsP.dsSessionP];
+//         if (is_init) {
+//           let ret = await init_program();
+//           return ret;
+//         }
+//         return alter_program();
+//       },
 
-          /////////////////
-          async function render_panel() {
-            //   // if (!cache_str) {
-            //   //   await update_container(screen_ready_function);
-            //   // }
-            //   // if (cache_str && !CACHE_PROG_UI[cache_str]) {
-            //   //   await update_container(screen_ready_function);
-            //   //   save_cache();
-            //   // }
-            //   // if (callback) callback($div);
-            //   // $container.data().xuData.node.children =
-            //   //   $div.data().xuData.node.children;
-            //   // //swiper-wrapper
-            //   // var restore_slides_elements = async function () {
-            //   //   if ($tmp_div.children().length) {
-            //   //     $tmp_div
-            //   //       .find(".swiper-wrapper")
-            //   //       .empty()
-            //   //       .append($new_div.children());
-            //   //     $new_div.append($tmp_div.children());
-            //   //   }
-            //   // };
-            //   // // console.log($tmp_div);
-            //   // await restore_slides_elements();
-            //   // // CHANGE_PANEL_BUSY = false;
-            //   // func.events.delete_job(SESSION_ID, jobNo);
-            // };
-            const program = val.value?.prog || val.value;
-            var $wrapper = $('<div>');
-            var $div = await func.UI.screen.create_container(SESSION_ID, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, nodeP.attributes, null, null, null, $wrapper, '');
-            const params_obj = await get_params_obj_new(SESSION_ID, program, nodeP, paramsP.dsSessionP);
-            let ret_init = await func.UI.screen.init(SESSION_ID, program, paramsP.screenId, _ds, $div, null, _ds.currentRecordId, jobNoP, true, params_obj.params_res, 'alterXu_panel', undefined, undefined, params_obj.params_raw);
-            ret = {
-              $new_div: ret_init,
-              abort: true,
-            };
-            await func.UI.screen.panel_post_render_handler(SESSION_ID, $elm, $new_div, nodeP, $div.clone(true), jobNoP);
+//       'xu-render': async function ($elm, val) {
+//         let ret = await common_fx['xu-render']($elm, val, true);
+//         return ret;
+//       },
+//       'xu-ref': async function ($elm, val) {
+//         let ret = await common_fx['xu-ref']($container, val, $container.data().xuData.xuPanelData.xuData.paramsP.dsSessionP);
+//         return ret;
+//       },
+//     },
+//     [`xu-teleport`]: {
+//       to: async function ($elm, val) {
+//         if (!glb.new_xu_render) {
+//           if (val.value) {
+//             // parent_infoP.is_xu_teleport;
+//             if ($elm?.parent()?.data()?.xuData?.length) {
+//               $elm.parent().data('xuTeleportData', []);
+//               for (const [key, node] of Object.entries(nodeP.children)) {
+//                 const $teleport_elm = await func.UI.screen.render_ui_tree(SESSION_ID, $(val.value), node, parent_infoP, paramsP, jobNoP, is_skeleton, Number(key), null, node, null, $root_container);
+
+//                 $elm.parent().data().xuTeleportData.push($teleport_elm.attr('xu-ui-id'));
+//                 $teleport_elm.attr('xu-teleport-parent-id', $elm.parent().attr('xu-ui-id'));
+//               }
+//               $elm.remove();
+//             } else {
+//               $elm.data('xuTeleportData', []).attr('hidden', true);
+//               for (const [key, node] of Object.entries(nodeP.children)) {
+//                 const $to_container = $(val.value);
+//                 if (!$to_container?.length) {
+//                   return console.error(`container ${val.value} for xuTeleportData not found`);
+//                 }
+//                 const $teleport_elm = await func.UI.screen.render_ui_tree(SESSION_ID, $to_container, node, parent_infoP, paramsP, jobNoP, is_skeleton, Number(key), null, node, null, $root_container);
 
-            return ret;
-          }
-          if (!val.value) {
-            return { abort: true };
-          }
-          await render_panel();
-          return ret;
-        };
+//                 $elm.data().xuTeleportData.push($teleport_elm.attr('xu-ui-id'));
+//                 $teleport_elm.attr('xu-teleport-parent-id', $elm.attr('xu-ui-id'));
+//               }
+//             }
+//           }
+//           return { abort: true };
+//         }
 
-        if (is_init) {
-          let ret = await init_program();
-          return ret;
-        }
-        return alter_program();
-      },
+//         if (val.value) {
+//           // // parent_infoP.is_xu_teleport;
+//           // if ($elm?.parent()?.data()?.xuData?.length) {
+//           //   $elm.parent().data('xuTeleportData', []);
+//           //   for (const [key, node] of Object.entries(nodeP.children)) {
+//           //     const $teleport_elm = await func.UI.screen.render_ui_tree(SESSION_ID, $(val.value), node, parent_infoP, paramsP, jobNoP, is_skeleton, Number(key), null, node, null, $root_container);
+//           //     $elm.parent().data().xuTeleportData.push($teleport_elm.attr('xu-ui-id'));
+//           //     $teleport_elm.attr('xu-teleport-parent-id', $elm.parent().attr('xu-ui-id'));
+//           //   }
+//           //   $elm.remove();
+//           // } else {
+//           //   $elm.data('xuTeleportData', []).attr('hidden', true);
+//           //   for (const [key, node] of Object.entries(nodeP.children)) {
+//           //     const $to_container = $(val.value);
+//           //     if (!$to_container?.length) {
+//           //       return console.error(`container ${val.value} for xuTeleportData not found`);
+//           //     }
+//           //     const $teleport_elm = await func.UI.screen.render_ui_tree(SESSION_ID, $to_container, node, parent_infoP, paramsP, jobNoP, is_skeleton, Number(key), null, node, null, $root_container);
+//           //     $elm.data().xuTeleportData.push($teleport_elm.attr('xu-ui-id'));
+//           //     $teleport_elm.attr('xu-teleport-parent-id', $elm.attr('xu-ui-id'));
+//           //   }
+//           // }
+//         }
+//         return {};
+//       },
+//       'xu-render': async function ($elm, val) {
+//         let ret = await common_fx['xu-render']($elm, val, true);
+//         return ret;
+//       },
+//       'xu-show': async function ($elm, val) {
+//         let ret = await common_fx['xu-show']($elm, val, true);
+//         return ret;
+//       },
+//     },
+//   };
 
-      'xu-render': async function ($elm, val) {
-        let ret = await common_fx['xu-render']($elm, val, true);
-        return ret;
-      },
-      'xu-ref': async function ($elm, val) {
-        let ret = await common_fx['xu-ref']($container, val, $container.data().xuData.xuPanelData.xuData.paramsP.dsSessionP);
-        return ret;
-      },
-    },
-    [`xu-teleport`]: {
-      to: async function ($elm, val) {
-        if (!glb.new_xu_render) {
-          if (val.value) {
-            // parent_infoP.is_xu_teleport;
-            if ($elm?.parent()?.data()?.xuData?.length) {
-              $elm.parent().data('xuTeleportData', []);
-              for (const [key, node] of Object.entries(nodeP.children)) {
-                const $teleport_elm = await func.UI.screen.render_ui_tree(SESSION_ID, $(val.value), node, parent_infoP, paramsP, jobNoP, is_skeleton, Number(key), null, node, null, $root_container);
-
-                $elm.parent().data().xuTeleportData.push($teleport_elm.attr('xu-ui-id'));
-                $teleport_elm.attr('xu-teleport-parent-id', $elm.parent().attr('xu-ui-id'));
-              }
-              $elm.remove();
-            } else {
-              $elm.data('xuTeleportData', []).attr('hidden', true);
-              for (const [key, node] of Object.entries(nodeP.children)) {
-                const $to_container = $(val.value);
-                if (!$to_container?.length) {
-                  return console.error(`container ${val.value} for xuTeleportData not found`);
-                }
-                const $teleport_elm = await func.UI.screen.render_ui_tree(SESSION_ID, $to_container, node, parent_infoP, paramsP, jobNoP, is_skeleton, Number(key), null, node, null, $root_container);
+//   const load_cdn = async function (resource) {
+//     // console.log("loading cdn", resource);
+//     if (!_.isObject(resource) && _.isString(resource)) {
+//       resource = { src: resource, type: 'js' };
+//     }
+//     if (!_.isObject(resource)) {
+//       throw new Error('cdn resource in wrong format');
+//     }
+//     return new Promise(async (resolve) => {
+//       try {
+//         switch (resource.type) {
+//           case 'js':
+//             await func.utils.load_js_on_demand(resource.src);
+//             break;
+//           case 'css':
+//             await func.utils.load_js_on_demand(resource.src);
+//             break;
+//           case 'module':
+//             func.utils.load_js_on_demand(resource.src, 'module');
+//             break;
+
+//           default:
+//             await func.utils.load_js_on_demand(resource.src);
+//             break;
+//         }
+//         resolve();
+//       } catch (error) {
+//         func.utils.debug_report(SESSION_ID, 'xu-cdn', 'Fail to load: ' + resource, 'W');
+//         resolve();
+//       }
 
-                $elm.data().xuTeleportData.push($teleport_elm.attr('xu-ui-id'));
-                $teleport_elm.attr('xu-teleport-parent-id', $elm.attr('xu-ui-id'));
-              }
-            }
-          }
-          return { abort: true };
-        }
+//       // if (resource.type === "js" || !resource.type) {
+//       //   await func.utils.load_js_on_demand(resource.src);
+//       //   return resolve();
+//       // }
+//       // if (resource.type === "css") {
+//       //   func.utils.load_css_on_demand(resource.src);
+//       //   return resolve();
+//       // }
+//       // if (resource.type === "module") {
+//       //   func.utils.load_js_on_demand(resource.src, "module");
+//       //   return resolve();
+//       // }
+//       // func.utils.debug_report(
+//       //   SESSION_ID,
+//       //   "xu-cdn",
+//       //   "Fail to load: " + resource,
+//       //   "W"
+//       // );
+//       // return resolve();
+//     });
+//   };
 
-        if (val.value) {
-          // // parent_infoP.is_xu_teleport;
-          // if ($elm?.parent()?.data()?.xuData?.length) {
-          //   $elm.parent().data('xuTeleportData', []);
-          //   for (const [key, node] of Object.entries(nodeP.children)) {
-          //     const $teleport_elm = await func.UI.screen.render_ui_tree(SESSION_ID, $(val.value), node, parent_infoP, paramsP, jobNoP, is_skeleton, Number(key), null, node, null, $root_container);
-          //     $elm.parent().data().xuTeleportData.push($teleport_elm.attr('xu-ui-id'));
-          //     $teleport_elm.attr('xu-teleport-parent-id', $elm.parent().attr('xu-ui-id'));
-          //   }
-          //   $elm.remove();
-          // } else {
-          //   $elm.data('xuTeleportData', []).attr('hidden', true);
-          //   for (const [key, node] of Object.entries(nodeP.children)) {
-          //     const $to_container = $(val.value);
-          //     if (!$to_container?.length) {
-          //       return console.error(`container ${val.value} for xuTeleportData not found`);
-          //     }
-          //     const $teleport_elm = await func.UI.screen.render_ui_tree(SESSION_ID, $to_container, node, parent_infoP, paramsP, jobNoP, is_skeleton, Number(key), null, node, null, $root_container);
-          //     $elm.data().xuTeleportData.push($teleport_elm.attr('xu-ui-id'));
-          //     $teleport_elm.attr('xu-teleport-parent-id', $elm.attr('xu-ui-id'));
-          //   }
-          // }
-        }
-        return {};
-      },
-      'xu-render': async function ($elm, val) {
-        let ret = await common_fx['xu-render']($elm, val, true);
-        return ret;
-      },
-      'xu-show': async function ($elm, val) {
-        let ret = await common_fx['xu-show']($elm, val, true);
-        return ret;
-      },
-    },
-  };
+//   const common_fx = {
+//     'xu-attrs': async function ($elm, val) {
+//       if (!val.value) return {};
+//       if (!_.isObject(val.value)) throw 'xu-attrs value us not an object';
+//       for (const [attr_key, attr_val] of Object.entries(val.value)) {
+//         nodeP.attributes[attr_key] = attr_val;
+//       }
 
-  const load_cdn = async function (resource) {
-    // console.log("loading cdn", resource);
-    if (!_.isObject(resource) && _.isString(resource)) {
-      resource = { src: resource, type: 'js' };
-    }
-    if (!_.isObject(resource)) {
-      throw new Error('cdn resource in wrong format');
-    }
-    return new Promise(async (resolve) => {
-      try {
-        switch (resource.type) {
-          case 'js':
-            await func.utils.load_js_on_demand(resource.src);
-            break;
-          case 'css':
-            await func.utils.load_js_on_demand(resource.src);
-            break;
-          case 'module':
-            func.utils.load_js_on_demand(resource.src, 'module');
-            break;
+//       return {};
+//     },
+//     'xu-ref': async function ($elm, val, dsSession) {
+//       if (!val.value) return {};
 
-          default:
-            await func.utils.load_js_on_demand(resource.src);
-            break;
-        }
-        resolve();
-      } catch (error) {
-        func.utils.debug_report(SESSION_ID, 'xu-cdn', 'Fail to load: ' + resource, 'W');
-        resolve();
-      }
+//       func.UI.update_xu_ref(SESSION_ID, dsSession || paramsP.dsSessionP, val.value, $elm);
 
-      // if (resource.type === "js" || !resource.type) {
-      //   await func.utils.load_js_on_demand(resource.src);
-      //   return resolve();
-      // }
-      // if (resource.type === "css") {
-      //   func.utils.load_css_on_demand(resource.src);
-      //   return resolve();
-      // }
-      // if (resource.type === "module") {
-      //   func.utils.load_js_on_demand(resource.src, "module");
-      //   return resolve();
-      // }
-      // func.utils.debug_report(
-      //   SESSION_ID,
-      //   "xu-cdn",
-      //   "Fail to load: " + resource,
-      //   "W"
-      // );
-      // return resolve();
-    });
-  };
+//       // Select the node that will be observed for mutations
+//       const targetNode = $elm[0];
 
-  const common_fx = {
-    'xu-attrs': async function ($elm, val) {
-      if (!val.value) return {};
-      if (!_.isObject(val.value)) throw 'xu-attrs value us not an object';
-      for (const [attr_key, attr_val] of Object.entries(val.value)) {
-        nodeP.attributes[attr_key] = attr_val;
-      }
+//       if (!targetNode) return;
 
-      return {};
-    },
-    'xu-ref': async function ($elm, val, dsSession) {
-      if (!val.value) return {};
+//       // Options for the observer (which mutations to observe)
+//       const config = { attributes: true, childList: true, subtree: true };
 
-      func.UI.update_xu_ref(SESSION_ID, dsSession || paramsP.dsSessionP, val.value, $elm);
+//       // Callback function to execute when mutations are observed
+//       const callback = (mutationList, observer) => {
+//         func.UI.screen.refresh_xu_attributes(SESSION_ID, [val.value]);
+//       };
 
-      // Select the node that will be observed for mutations
-      const targetNode = $elm[0];
+//       // Create an observer instance linked to the callback function
+//       const observer = new MutationObserver(callback);
+
+//       // Start observing the target node for configured mutations
+//       observer.observe(targetNode, config);
+
+//       // Later, you can stop observing
+//       // observer.disconnect();
+
+//       return {};
+//     },
+//     'xu-bind': async function ($elm, val) {
+//       if (is_skeleton) return;
+
+//       let val_is_reference_field = false;
+
+//       let _prog_id = $elm.data().xuData.paramsP.prog_id;
+//       let _dsP = $elm.data().xuData.paramsP.dsSessionP;
+//       const view_ret = await func.utils.VIEWS_OBJ.get(SESSION_ID, _prog_id);
+//       if (!view_ret) return {};
+
+//       let is_dynamic_field = false;
+//       let field_prop;
+//       let bind_field_id;
+
+//       const input_field_type = $elm.attr('type');
+
+//       const get_bind_field = async function (field_id) {
+//         if (['_FOR_VAL', '_FOR_KEY'].includes(field_id)) {
+//           is_dynamic_field = true;
+//           field_prop = _ds.dynamic_fields[field_id];
+//         } else {
+//           field_prop = func.common.find_item_by_key(view_ret.progFields, 'field_id', field_id);
+//           if (!field_prop) {
+//             /// find the field everywhere in the chain Aug 30 2024
+//             const ret_get_value = await func.datasource.get_value(SESSION_ID, field_id, _dsP);
+
+//             if (ret_get_value.found) {
+//               _dsP = ret_get_value.dsSessionP;
+//               let _ds = SESSION_OBJ[SESSION_ID].DS_GLB[_dsP];
+//               _prog_id = _ds.prog_id;
+//               const view_ret = await func.utils.VIEWS_OBJ.get(SESSION_ID, _prog_id);
+//               if (!view_ret) return {};
+//               field_prop = func.common.find_item_by_key(view_ret.progFields, 'field_id', field_id);
+//             }
+//             if (!field_prop) {
+//               throw `field ${field_id} not found in the program scope`;
+//             }
+//           }
+//         }
+//         return field_id;
+//       };
 
-      if (!targetNode) return;
+//       try {
+//         bind_field_id = await get_bind_field(val.value.split('.')[0]);
+//         val_is_reference_field = true;
+//       } catch (err) {
+//         console.error(err?.message || err);
+//         return {};
+//       }
 
-      // Options for the observer (which mutations to observe)
-      const config = { attributes: true, childList: true, subtree: true };
+//       const field_changed = async function (e) {
+//         var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[_dsP];
 
-      // Callback function to execute when mutations are observed
-      const callback = (mutationList, observer) => {
-        func.UI.screen.refresh_xu_attributes(SESSION_ID, [val.value]);
-      };
+//         // update array for checkbox that not in xu-for
+//         if (field_prop.props.fieldType === 'array' && input_field_type === 'checkbox' && val_is_reference_field) {
+//           let arr_value_before_cast = _.clone((await func.datasource.get_value(SESSION_ID, bind_field_id, _dsP, _ds.currentRecordId)).ret.value);
+//           let value_from_getter = bind.getter($elm[0]);
+//           let value;
+//           if (arr_value_before_cast.includes(value_from_getter)) {
+//             value = arr_value_before_cast.filter((item) => !_.isEqual(item, value_from_getter));
+//           } else {
+//             arr_value_before_cast.push(value_from_getter);
+//             value = arr_value_before_cast;
+//           }
 
-      // Create an observer instance linked to the callback function
-      const observer = new MutationObserver(callback);
+//           let datasource_changes = {
+//             [_dsP]: {
+//               [_ds.currentRecordId]: {
+//                 [bind_field_id]: value,
+//               },
+//             },
+//           };
 
-      // Start observing the target node for configured mutations
-      observer.observe(targetNode, config);
+//           return await func.datasource.update(SESSION_ID, datasource_changes);
+//         }
 
-      // Later, you can stop observing
-      // observer.disconnect();
+//         // update array for radio that not in xu-for
+//         if (field_prop.props.fieldType === 'array' && input_field_type === 'radio' && val_is_reference_field) {
+//           let value_from_getter = bind.getter($elm[0]);
 
-      return {};
-    },
-    'xu-bind': async function ($elm, val) {
-      if (is_skeleton) return;
+//           let datasource_changes = {
+//             [_dsP]: {
+//               [_ds.currentRecordId]: {
+//                 [bind_field_id]: [value_from_getter],
+//               },
+//             },
+//           };
 
-      let val_is_reference_field = false;
+//           return await func.datasource.update(SESSION_ID, datasource_changes);
+//         }
 
-      let _prog_id = $elm.data().xuData.paramsP.prog_id;
-      let _dsP = $elm.data().xuData.paramsP.dsSessionP;
-      const view_ret = await func.utils.VIEWS_OBJ.get(SESSION_ID, _prog_id);
-      if (!view_ret) return {};
+//         var value = await func.common.get_cast_val(SESSION_ID, 'xu-bind', 'value', field_prop.props.fieldType, bind.getter($elm[0]));
 
-      let is_dynamic_field = false;
-      let field_prop;
-      let bind_field_id;
+//         if (field_prop.props.fieldType === 'object') {
+//           value = await func.common.get_cast_val(SESSION_ID, 'xu-bind', 'value', input_field_type, bind.getter($elm[0]));
+//         }
 
-      const input_field_type = $elm.attr('type');
+//         if (!_ds.currentRecordId) return;
 
-      const get_bind_field = async function (field_id) {
-        if (['_FOR_VAL', '_FOR_KEY'].includes(field_id)) {
-          is_dynamic_field = true;
-          field_prop = _ds.dynamic_fields[field_id];
-        } else {
-          field_prop = func.common.find_item_by_key(view_ret.progFields, 'field_id', field_id);
-          if (!field_prop) {
-            /// find the field everywhere in the chain Aug 30 2024
-            const ret_get_value = await func.datasource.get_value(SESSION_ID, field_id, _dsP);
+//         let datasource_changes = {
+//           [_dsP]: {
+//             [_ds.currentRecordId]: {
+//               [bind_field_id]: value,
+//             },
+//           },
+//         };
 
-            if (ret_get_value.found) {
-              _dsP = ret_get_value.dsSessionP;
-              let _ds = SESSION_OBJ[SESSION_ID].DS_GLB[_dsP];
-              _prog_id = _ds.prog_id;
-              const view_ret = await func.utils.VIEWS_OBJ.get(SESSION_ID, _prog_id);
-              if (!view_ret) return {};
-              field_prop = func.common.find_item_by_key(view_ret.progFields, 'field_id', field_id);
-            }
-            if (!field_prop) {
-              throw `field ${field_id} not found in the program scope`;
-            }
-          }
-        }
-        return field_id;
-      };
+//         await func.datasource.update(SESSION_ID, datasource_changes);
+//         const iterate_info = $elm?.data()?.xuData?.iterate_info;
+//         const reference_source_obj = iterate_info?.reference_source_obj;
+//         if (reference_source_obj) {
+//           if (reference_source_obj.ret.type === 'array') {
+//             if (iterate_info.iterator_val === bind_field_id) {
+//               const arr_idx = Number($elm?.data()?.xuData?.iterate_info._key);
 
-      try {
-        bind_field_id = await get_bind_field(val.value.split('.')[0]);
-        val_is_reference_field = true;
-      } catch (err) {
-        console.error(err?.message || err);
-        return {};
-      }
+//               const dataset_arr = await func.datasource.get_value(SESSION_ID, reference_source_obj.fieldIdP, _dsP, reference_source_obj.currentRecordId);
+//               let new_arr = _.cloneDeep(dataset_arr.ret.value);
 
-      const field_changed = async function (e) {
-        var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[_dsP];
+//               if (field_prop.props.fieldType === 'object' && val_is_reference_field) {
+//                 let obj_item = new_arr[arr_idx];
 
-        // update array for checkbox that not in xu-for
-        if (field_prop.props.fieldType === 'array' && input_field_type === 'checkbox' && val_is_reference_field) {
-          let arr_value_before_cast = _.clone((await func.datasource.get_value(SESSION_ID, bind_field_id, _dsP, _ds.currentRecordId)).ret.value);
-          let value_from_getter = bind.getter($elm[0]);
-          let value;
-          if (arr_value_before_cast.includes(value_from_getter)) {
-            value = arr_value_before_cast.filter((item) => !_.isEqual(item, value_from_getter));
-          } else {
-            arr_value_before_cast.push(value_from_getter);
-            value = arr_value_before_cast;
-          }
+//                 let e_exp = val.value.replace(bind_field_id, 'obj_item');
 
-          let datasource_changes = {
-            [_dsP]: {
-              [_ds.currentRecordId]: {
-                [bind_field_id]: value,
-              },
-            },
-          };
+//                 let new_val = eval(e_exp + (input_field_type === 'string' ? `="${value}"` : `=${value}`));
 
-          return await func.datasource.update(SESSION_ID, datasource_changes);
-        }
+//                 new_arr[arr_idx] = obj_item;
+//               } else {
+//                 new_arr[arr_idx] = value;
+//               }
+//               // datasource_changes[_dsP][_ds.currentRecordId][reference_source_obj.fieldIdP] = new_arr;
+
+//               let datasource_changes = {
+//                 [_dsP]: {
+//                   [_ds.currentRecordId]: {
+//                     [reference_source_obj.fieldIdP]: new_arr,
+//                   },
+//                 },
+//               };
 
-        // update array for radio that not in xu-for
-        if (field_prop.props.fieldType === 'array' && input_field_type === 'radio' && val_is_reference_field) {
-          let value_from_getter = bind.getter($elm[0]);
+//               await func.datasource.update(SESSION_ID, datasource_changes, null, true);
+//             }
+//           }
+//         }
 
-          let datasource_changes = {
-            [_dsP]: {
-              [_ds.currentRecordId]: {
-                [bind_field_id]: [value_from_getter],
-              },
-            },
-          };
+//         await func.datasource.update_changes_for_out_parameter(SESSION_ID, _dsP, _ds.parentDataSourceNo);
+//       };
 
-          return await func.datasource.update(SESSION_ID, datasource_changes);
-        }
+//       const bind = new UI_FRAMEWORK_PLUGIN.bind();
 
-        var value = await func.common.get_cast_val(SESSION_ID, 'xu-bind', 'value', field_prop.props.fieldType, bind.getter($elm[0]));
+//       bind.listener($elm[0], field_changed);
 
-        if (field_prop.props.fieldType === 'object') {
-          value = await func.common.get_cast_val(SESSION_ID, 'xu-bind', 'value', input_field_type, bind.getter($elm[0]));
-        }
+//       const set_value = function () {
+//         let _ds = SESSION_OBJ[SESSION_ID].DS_GLB[paramsP.dsSessionP];
+//         if (!_ds.currentRecordId) return;
+//         let value;
+//         try {
+//           if (val_is_reference_field) {
+//             if (is_dynamic_field) {
+//               value = _ds.dynamic_fields[bind_field_id].value;
+//             } else {
+//               const row_idx = func.common.find_ROWID_idx(_ds, _ds.currentRecordId);
+//               value = _ds.data_feed.rows?.[row_idx]?.[bind_field_id];
+//             }
+//             if (field_prop.props.fieldType === 'array' && $elm.attr('type') === 'checkbox' && $elm.attr('value')) {
+//               if (value.includes($elm.attr('value'))) {
+//                 value = true;
+//               } else {
+//                 value = false;
+//               }
+//             } else if (field_prop.props.fieldType === 'array' && $elm.attr('type') === 'radio' && $elm.attr('value')) {
+//               if (value.includes($elm.attr('value'))) {
+//                 value = $elm.attr('value');
+//               } else {
+//                 value = false;
+//               }
+//             } else if (field_prop.props.fieldType === 'object' && val.value.split('.').length > 1) {
+//               let str = val.value.replace(bind_field_id, '(' + JSON.stringify(value) + ')');
+//               value = eval(str);
+//             }
+//           } else {
+//             value = val.value;
+//           }
+//           if (typeof value === 'undefined') return;
+//           bind.setter($elm[0], value);
+//         } catch (err) {
+//           console.error(err);
+//         }
+//       };
+//       /// init value from ds
+//       $('body').on('xu-bind-refresh.' + _ds.dsSession.toString(), () => {
+//         set_value();
+//       });
 
-        if (!_ds.currentRecordId) return;
+//       set_value();
+//       return {};
+//     },
+//     'xu-render': async function ($elm, val, from_panel) {
+//       const old_render = async function () {
+//         var value = await func.common.get_cast_val(SESSION_ID, 'common fx', 'xu-render', 'bool', val.value);
+//         const init_render = function () {
+//           if (!value) {
+//             var cloned_$div = $elm.clone(true);
+
+//             let $xurender = $('<xurender>').attr('xu-ui-id', $elm.attr('xu-ui-id')).attr('hidden', true).appendTo($container); //.hide();
+//             let original_data_obj = {
+//               $container: cloned_$div,
+//               nodeP: _.cloneDeep(nodeP),
+//               parent_infoP,
+//               paramsP,
+//               keyP,
+//               parent_nodeP,
+//               $root_container,
+//             };
+//             $xurender.data('xuData', cloned_$div.data().xuData);
+//             $xurender.data().xuData.original_data_obj = original_data_obj;
+//             $xurender.data().xuData.xurender_node = cloned_$div;
+//             $xurender.data().xuAttributes = nodeP.attributes || {};
+//             // $xurender.hide();
+
+//             $elm.remove();
+//             return { abort: true };
+//           }
+//           return {};
+//         };
 
-        let datasource_changes = {
-          [_dsP]: {
-            [_ds.currentRecordId]: {
-              [bind_field_id]: value,
-            },
-          },
-        };
+//         const post_render = async function () {
+//           if (value) {
+//             try {
+//               // abort if already rended
+//               if ($elm[0].tagName !== 'XURENDER' && $elm?.length) {
+//                 return func.events.delete_job(SESSION_ID, jobNoP);
+//               }
 
-        await func.datasource.update(SESSION_ID, datasource_changes);
-        const iterate_info = $elm?.data()?.xuData?.iterate_info;
-        const reference_source_obj = iterate_info?.reference_source_obj;
-        if (reference_source_obj) {
-          if (reference_source_obj.ret.type === 'array') {
-            if (iterate_info.iterator_val === bind_field_id) {
-              const arr_idx = Number($elm?.data()?.xuData?.iterate_info._key);
+//               let original_data_obj = $elm.data().xuData.original_data_obj;
 
-              const dataset_arr = await func.datasource.get_value(SESSION_ID, reference_source_obj.fieldIdP, _dsP, reference_source_obj.currentRecordId);
-              let new_arr = _.cloneDeep(dataset_arr.ret.value);
+//               if (!original_data_obj) {
+//                 func.events.delete_job(SESSION_ID, jobNoP);
+//                 return { delete_job: jobNoP };
+//               }
 
-              if (field_prop.props.fieldType === 'object' && val_is_reference_field) {
-                let obj_item = new_arr[arr_idx];
+//               const new_$div = await func.UI.screen.render_ui_tree(
+//                 SESSION_ID,
+//                 $elm, //original_data_obj.$container,
+//                 _.cloneDeep(original_data_obj.nodeP),
+//                 original_data_obj.parent_infoP,
+//                 original_data_obj.paramsP,
+//                 jobNoP,
+//                 null,
+//                 original_data_obj.keyP,
+//                 null,
+//                 original_data_obj.parent_nodeP,
+//                 null,
+//                 original_data_obj.$root_container,
+//               );
 
-                let e_exp = val.value.replace(bind_field_id, 'obj_item');
+//               new_$div.data().xuData.original_data_obj = original_data_obj;
+//               new_$div.data().xuData.xurender_node = $elm.clone(true);
+//               new_$div.data().xuAttributes = $elm.data().xuAttributes || {};
 
-                let new_val = eval(e_exp + (input_field_type === 'string' ? `="${value}"` : `=${value}`));
+//               const replace = async function () {
+//                 $elm.replaceWith(new_$div);
+//                 if (from_panel) {
+//                   const xuPanelWrapper = _.clone(new_$div.data().xuPanelWrapper);
+//                   $elm.parent().data().xuPanelWrapper = xuPanelWrapper;
+//                   $elm.replaceWith(new_$div.children());
+//                 }
 
-                new_arr[arr_idx] = obj_item;
-              } else {
-                new_arr[arr_idx] = value;
-              }
-              // datasource_changes[_dsP][_ds.currentRecordId][reference_source_obj.fieldIdP] = new_arr;
+//                 if (val.fields_arr) {
+//                   return await func.UI.screen.refresh_xu_attributes(SESSION_ID, val.fields_arr, val.jobNoP, new_$div);
+//                 }
+//                 func.events.delete_job(SESSION_ID, jobNoP);
+//               };
+//               //  if ($elm && func.UI.utils.find_in_element_data('xuData', $(SESSION_OBJ[SESSION_ID].root_element), 'xu_id', $elm.data().xuData.xu_id).length) {
+//               if ($elm && $(`[xu-ui-id="${$elm.attr('xu-ui-id')}"]`).length) {
+//                 if (new_$div.data().xuData.paramsP) {
+//                   return await replace();
+//                 }
 
-              let datasource_changes = {
-                [_dsP]: {
-                  [_ds.currentRecordId]: {
-                    [reference_source_obj.fieldIdP]: new_arr,
-                  },
-                },
-              };
+//                 func.events.delete_job(SESSION_ID, jobNoP);
+//               }
+//             } catch (error) {
+//               func.events.delete_job(SESSION_ID, jobNoP);
+//             }
+//             return;
+//           }
+//           // if (!value) {
+//           if ($elm.prop('tagName') === 'XURENDER') {
+//             func.events.delete_job(SESSION_ID, jobNoP);
+//             return;
+//           }
 
-              await func.datasource.update(SESSION_ID, datasource_changes, null, true);
-            }
-          }
-        }
+//           let tmp_$div = $('<div>');
 
-        await func.datasource.update_changes_for_out_parameter(SESSION_ID, _dsP, _ds.parentDataSourceNo);
-      };
+//           let $xurender = $('<xurender>').attr('xu-ui-id', $elm.attr('xu-ui-id')).appendTo(tmp_$div); //.hide();
+//           // was true before
+//           if ($elm.data().xuData.xurender_node) {
+//             $xurender.data({
+//               xuAttributes: $elm.data().xuData.xurender_node.data().xuAttributes || {},
+//               xuData: $elm.data().xuData.xurender_node.data().xuData || {},
+//             });
+//           } else {
+//             // default new state
 
-      const bind = new UI_FRAMEWORK_PLUGIN.bind();
+//             $xurender.data({
+//               xuAttributes: $elm.data().xuAttributes || {},
+//               xuData: $elm.data().xuData || {},
+//             });
+//             const original_data_obj = {
+//               nodeP: _.cloneDeep($elm.data().xuData.node_org),
+//               paramsP: $elm.data().xuData.paramsP,
+//               $container: $elm.clone(true),
+//               parent_infoP: parent_infoP,
+//             };
+
+//             $xurender.data().xuData.original_data_obj = original_data_obj;
+//           }
+
+//           //remove xu-teleport trace
+//           $.each($elm.find('xu-teleport'), (key, val) => {
+//             const xuTeleportData = $(val).data().xuTeleportData || [];
+//             for (const teleported_elm_id of xuTeleportData) {
+//               $(`[xu-ui-id="${teleported_elm_id}"]`).remove();
+//             }
+//           });
+
+//           $elm.replaceWith(tmp_$div.children());
+//           func.events.delete_job(SESSION_ID, jobNoP);
+//           // }
+//         };
+//         if (is_init) {
+//           return init_render();
+//         }
+//         return await post_render();
+//       };
+
+//       const new_render = async function () {
+//         var value = await func.common.get_cast_val(SESSION_ID, 'common fx', 'xu-render', 'bool', val.value);
+//         const has_xu_render_attribute = true;
+//         const has_xu_exp_render_attribute = $elm.data()?.xuData?.attr_exp_info?.['xu-render'] ? true : false;
+//         const init_render = async function () {
+//           nodeP.xu_render_made = value;
+//           if (!value) {
+//             if (has_xu_exp_render_attribute) {
+//               return { has_xu_exp_render_attribute, has_xu_render_attribute, xu_render_background_processing: true };
+//             }
+//             return { has_xu_render_attribute, abort: true };
+//           }
+//           return { has_xu_exp_render_attribute, has_xu_render_attribute };
+//         };
+
+//         const post_render = async function () {
+//           // always come from refresh
+//           let nodeP = $container.data().xuData.node.children[keyP];
+//           nodeP.xu_render_made = value;
+//           if (value) {
+//             try {
+//               const xu_render_cache_id = await get_xu_render_cache_str(SESSION_ID, paramsP.dsSessionP, Object.keys($elm.data()?.xuData?.attr_exp_info?.['xu-render']?.fields || {}));
+//               const xu_ui_id = $elm.attr('xu-ui-id');
+//               let new_$div = UI_WORKER_OBJ?.xu_render_cache?.[xu_ui_id + xu_render_cache_id]?.$div.clone(true);
+//               let found_parent_vars = false;
+//               if (new_$div) {
+//                 // validate if $div contains fields from parent ds
+//                 const parent_data = get_parent_ds_fields(SESSION_ID, paramsP.dsSessionP);
+//                 const parent_fields = Object.keys(parent_data);
+
+//                 $.each(new_$div.find('*'), (key, val) => {
+//                   const _xuAttributes = $(val)?.data()?.xuAttributes;
+//                   if (found_parent_vars || !_xuAttributes) return;
+//                   for (const [attr_key, attr_val] of Object.entries(_xuAttributes)) {
+//                     if (found_parent_vars) break;
+//                     for (const [key, val] of Object.entries(parent_fields)) {
+//                       if (attr_val.includes('@' + key)) {
+//                         found_parent_vars = true;
+//                         break;
+//                       }
+//                     }
+//                   }
+//                 });
+//               }
+
+//               if (!new_$div || found_parent_vars) {
+//                 UI_WORKER_OBJ.xu_render_cache[xu_ui_id + xu_render_cache_id] = { paramsP };
+//                 nodeP.xu_render_xu_ui_id = xu_ui_id;
+//                 nodeP.xu_render_cache_id = xu_render_cache_id;
+//                 new_$div = await func.UI.screen.render_ui_tree(SESSION_ID, $container, nodeP, parent_infoP, paramsP, jobNoP, null, keyP, null, parent_nodeP, null, $root_container);
+//                 const _$div = new_$div.clone(true);
+//                 UI_WORKER_OBJ.xu_render_cache[xu_ui_id + xu_render_cache_id].$div = _$div;
+//                 UI_WORKER_OBJ.xu_render_cache[xu_ui_id + xu_render_cache_id].data = _$div.data();
+//               }
+//               // append order handling
+
+//               if (!$container.children().length) {
+//                 new_$div.appendTo($container);
+//               } else {
+//                 // iterate the container node
+//                 let $last_elm_found = [];
+//                 $.each($container.data().xuData.node.children, (item_key, item_val) => {
+//                   // const $elm = $(`[xu-node-id="${item_val.id}"]`);
+//                   const $elm = func.UI.utils.find_in_element_data('xuData', $(SESSION_OBJ[SESSION_ID].root_element), 'nodeid', item_val.id);
+//                   if ($elm.length) {
+//                     $last_elm_found = $elm;
+//                   }
+//                   if (keyP == item_key) {
+//                     if ($last_elm_found.length) {
+//                       new_$div.after($last_elm_found);
+//                     } else {
+//                       $container.prepend(new_$div);
+//                     }
+//                   }
+//                 });
+//               }
+//             } catch (error) {
+//               func.events.delete_job(SESSION_ID, jobNoP);
+//             }
+//             return;
+//           }
+
+//           /////////// !value ///////////
+
+//           const xu_ui_id = $elm.attr('xu-ui-id');
+
+//           const cache_str = await get_xu_render_cache_str(SESSION_ID, paramsP.dsSessionP, Object.keys($elm.data()?.xuData?.attr_exp_info?.['xu-render']?.fields || {}));
+//           const _$div = $elm.clone(true);
+//           UI_WORKER_OBJ.xu_render_cache[xu_ui_id + cache_str] = { $div: _$div, data: _$div.data(), paramsP };
+//           $elm.remove();
+//           func.events.delete_job(SESSION_ID, jobNoP);
+//         };
+//         if (is_init) {
+//           return await init_render();
+//         }
+//         return await post_render();
+//       };
+
+//       if (glb.new_xu_render) {
+//         return new_render();
+//       }
+//       return old_render();
+//     },
+//     'xu-show': async function ($elm, val) {
+//       var value = await func.common.get_cast_val(SESSION_ID, 'common fx', 'xu-show', 'bool', val.value);
+//       if (value) {
+//         $elm.show();
+//       }
+//       if (!value) {
+//         $elm.hide();
+//       }
+//       return {};
+//     },
+//     'xu-content': async function ($elm, val) {
+//       try {
+//         $elm.html(val.value);
+//       } catch (error) {
+//         console.warn(e);
+//       }
+//       return;
+//     },
+//     'xu-text': async function ($elm, val) {
+//       try {
+//         $elm.text(val.value);
+//       } catch (error) {
+//         console.warn(e);
+//       }
+//       return;
+//     },
+//     'xu-html': async function ($elm, val) {
+//       try {
+//         $elm.html(val.value);
+//       } catch (error) {
+//         console.warn(e);
+//       }
+//       return;
+//     },
+//     'xu-for': async function ($elm, data) {
+//       // exit if call from rendered xu-for item to prevent infante loop (parent_infoP?.iterate_info indicate call from rendered item)
+//       if (parent_infoP?.iterate_info) return {};
+//       if (!data.value) return {};
+//       try {
+//         // data.value (xu-for) can store actual values such as an array, a CSV, or a field_id that references a specific field within the dataset, initialized with values for the iteration.
+//         let arr = data.value;
+
+//         // find reference source field
+//         let reference_source_obj;
+
+//         const _progFields = await func.datasource.get_progFields(SESSION_ID, paramsP.dsSessionP);
+
+//         let view_field_obj = func.common.find_item_by_key(_progFields, 'field_id', data.value);
+//         // detect if data.value (xu-for) is reference field_id  by checking if exist in the dataset
+//         if (view_field_obj) {
+//           // xu-for is reference field_id
+//           reference_source_obj = await func.datasource.get_value(SESSION_ID, data.value, paramsP.dsSessionP);
+//           arr = reference_source_obj?.ret?.value;
+//         } else {
+//           // xu-for is actual data
+//           if (typeof data.value === 'string') {
+//             arr = eval(data.value.replaceAll('\\', ''));
+//           }
+//           if (typeof arr === 'number') {
+//             arr = Array.from(Array(arr).keys());
+//           }
+//         }
+
+//         const custom_iterator_key = $elm.data().xuData.iterator_key;
+//         const custom_iterator_val = $elm.data().xuData.iterator_val;
+
+//         let iterator_key = custom_iterator_key;
+//         let iterator_val = custom_iterator_val;
+//         let is_key_dynamic_field, is_val_dynamic_field;
+
+//         // custom FOR_VAL name or namespaced default name
+//         if (!custom_iterator_key) {
+//           is_key_dynamic_field = true;
+
+//           iterator_key = '_FOR_KEY';
+//         }
+
+//         if (!custom_iterator_val) {
+//           is_val_dynamic_field = true;
+
+//           iterator_val = '_FOR_VAL';
+//         }
+
+//         var i = 0;
+//         for await (let [_key, _val] of Object.entries(arr)) {
+//           if (_.isArray(arr)) {
+//             _key = Number(_key);
+//           }
+
+//           const set_value = async function (is_dynamic_field, currentRecordId, field_id, value) {
+//             if (is_dynamic_field) {
+//               func.datasource.add_dynamic_field_to_ds(SESSION_ID, paramsP.dsSessionP, field_id, value);
+//             } else {
+//               const _progFields = await func.datasource.get_progFields(SESSION_ID, paramsP.dsSessionP);
+
+//               let view_field_obj = func.common.find_item_by_key(_progFields, 'field_id', field_id);
+//               if (view_field_obj) {
+//                 let _ds = SESSION_OBJ[SESSION_ID].DS_GLB[paramsP.dsSessionP];
+//                 try {
+//                   const row_idx = func.common.find_ROWID_idx(_ds, currentRecordId);
+//                   _ds.data_feed.rows[row_idx][field_id] = value;
+//                 } catch (err) {
+//                   console.error(err);
+//                 }
+//               } else {
+//                 console.error('field not exist in dataset for xu-for method');
+//               }
+//             }
+//           };
+
+//           var currentRecordId = SESSION_OBJ[SESSION_ID].DS_GLB[paramsP.dsSessionP].currentRecordId.toString();
+
+//           await set_value(is_key_dynamic_field, currentRecordId, iterator_key, _key);
+//           await set_value(is_val_dynamic_field, currentRecordId, iterator_val, _val);
+
+//           var iterate_info = {
+//             _val,
+//             _key,
+//             iterator_key,
+//             iterator_val,
+//             is_key_dynamic_field,
+//             is_val_dynamic_field,
+//             reference_source_obj,
+//           };
+//           // let _parent_info = _.cloneDeep(parent_infoP) || {};
+//           let _parent_info = klona.klona(parent_infoP) || {};
+//           _parent_info.iterate_info = iterate_info;
+
+//           const $divP = await func.UI.screen.render_ui_tree(
+//             SESSION_ID,
+//             $container,
+//             nodeP,
+//             _parent_info, //parent_infoP ? _.cloneDeep(_parent_info) : null,
+//             paramsP,
+//             jobNoP,
+//             null,
+//             i,
+//             null,
+//             nodeP,
+//             null,
+//             $root_container,
+//           );
+
+//           $.each($divP.children(), function (key, val) {
+//             if ($(val)?.data()?.xuData) {
+//               $(val).data().xuData.iterate_info = iterate_info;
+//             }
+//           });
+
+//           i++;
+//         }
+//         $elm.remove();
+//         return { abort: true };
+//       } catch (e) {
+//         console.error(' Iterator Arr parse error');
+//         return { abort: true };
+//       }
+//     },
+//     'xu-for-key': async function ($elm, val) {
+//       $elm.data().xuData.iterator_key = val.value;
+//       return {};
+//     },
+//     'xu-for-val': async function ($elm, val) {
+//       $elm.data().xuData.iterator_val = val.value;
+//       return {};
+//     },
+//     'xu-class': async function ($elm, val) {
+//       try {
+//         const classes_string = val.value;
+//         // let obj = _.isString(classes_string) ? JSON.parse(classes_string) : _.defaults(classes_string, {});
+
+//         const classes_obj = _.isString(classes_string) ? JSON.parse(classes_string) : _.defaults(classes_string, {});
+//         for await (const [cla, cond] of Object.entries(classes_obj)) {
+//           let res = await func.expression.get(
+//             SESSION_ID,
+//             cond,
+//             paramsP.dsSessionP,
+//             'UI Attr EXP',
+//             $elm.data().xuData.currentRecordId, // SESSION_OBJ[SESSION_ID].DS_GLB[paramsP.dsSessionP].currentRecordId
+//             null,
+//             null,
+//             null,
+//             null,
+//             null,
+//             $elm.data().xuData.iterate_info,
+//           );
+
+//           if (res.result) {
+//             $elm.addClass(cla);
+//           } else {
+//             $elm.removeClass(cla);
+//           }
+
+//           $elm.data().xuData.debug_info.attribute_stat['xu-class'] = $elm.attr('class');
+//         }
+//         return {};
+//       } catch (e) {
+//         console.warn('parse error:' + val.value);
+//         return { abort: true };
+//       }
+//     },
+//     'xu-exp': async function ($elm, val) {
+//       let exp = val.value === null ? true : val.value;
+
+//       let exp_ret = await func.expression.get(SESSION_ID, exp, paramsP.dsSessionP, 'UI Attr EXP', SESSION_OBJ[SESSION_ID].DS_GLB[paramsP.dsSessionP].currentRecordId, null, null, null, null, null, $elm.data().xuData.iterate_info);
+
+//       let value = func.UI.screen.fix_val_defaults(val.key, exp_ret.result);
+
+//       var new_val = {
+//         key: val.key,
+//         value,
+//       };
+
+//       if (nodeP.tagName.substr(0, 3) === 'xu-') {
+//         if (tag_fx[nodeP.tagName][new_val.key]) {
+//           return await tag_fx[nodeP.tagName][new_val.key]($elm, new_val);
+//         }
+//         console.warn(`attribute ${new_val.key} not found for ${nodeP.tagName}`);
+//         return {};
+//       }
+//       if (!$elm.data().xuData) return;
+
+//       $elm.data().xuData.debug_info.attribute_stat[new_val.key] = new_val.value;
+
+//       // IGNORE UNDEFINED or NULL ATTRIBUTES
+//       if (typeof new_val.value === 'undefined' || new_val.value === null) {
+//         return {};
+//       }
+
+//       // IGNORE ATTRIBUTES WITH EMPTY VALUES
+//       if (glb.solid_attributes.includes(new_val.key) && !new_val.value) {
+//         return {};
+//       }
+
+//       if (new_val.key.substr(0, 2) === 'xu') {
+//         return await common_fx[new_val.key]($elm, new_val);
+//       }
+
+//       $elm.attr(new_val.key, ($elm.attr(new_val.key) || '') + new_val.value);
+//       return {};
+//     },
+//     'xu-on': async function ($elm, val) {
+//       CLIENT_ACTIVITY_TS = Date.now();
+//       const trigger = val.key.split('xu-on:')[1].toLowerCase();
+//       $elm.on(trigger, async function (evt) {
+//         const _$elm = $(evt.currentTarget);
+//         if (_.isEmpty(_$elm.data().xuAttributes)) return;
+
+//         for await (const [key, val] of Object.entries(_$elm.data().xuAttributes['xu-on:' + evt.type])) {
+//           if (!_.isEmpty(val.props.condition)) {
+//             const expCond = await func.expression.get(SESSION_ID, val.props.condition, paramsP.dsSessionP, 'condition', paramsP.recordid); // execute expression
+//             if (!expCond.result) continue;
+//           }
+
+//           if (val.event_modifiers && evt[val.event_modifiers]) {
+//             evt[val.event_modifiers]();
+//           }
+
+//           // if (val.handler === 'custom') {
+//           if (val.workflow) {
+//             // do BL
+//             for await (const [key2, val2] of Object.entries(val.workflow)) {
+//               // var cond = val2.data.enabled;
+//               // if (val2.data.enabled && val2.props.condition) {
+//               // expCond = await func.expression.get(SESSION_ID, val2.props.condition, paramsP.dsSessionP, 'condition', paramsP.recordid); // execute expression
+//               // cond = expCond.result;
+//               // }
+//               // if (!cond) continue;
+
+//               if (!val2.data.enabled) continue; // added Jul 3, 25 - condition validate on execution
+
+//               func.events.add_to_queue(SESSION_ID, 'element event', val2.id, evt.type, val2.data.action, val2.data.name, null, _$elm.attr('xu-ui-id'), null, evt, null, null, null, paramsP.dsSessionP, null, null, null, evt.type, val2.data.name, null, null, val2, null, null, null, null, null, null);
+//             }
+//           }
+//         }
+//       });
+//       return {};
+//     },
+//     'xu-script': async function ($elm, val) {
+//       var checkExist = setInterval(async function () {
+//         if ($elm.is(':visible')) {
+//           try {
+//             // var res = eval('(' + val.value + ')');
+//             // const fn = `(function(el) {
+//             //  ${val.value}
+//             //  })(document.querySelector(\`[xu-ui-id="${$elm.attr('xu-ui-id')}"]\`));`;
+
+//             const fn = `async (el)=>{${val.value} };`;
+
+//             var res = eval(fn);
+//             await res($elm[0]);
+//             // if (typeof res === 'function') {
+//             //   res($elm[0]);
+//             // }
+//           } catch (e) {
+//             eval(val.value);
+//           }
+
+//           clearInterval(checkExist);
+//         }
+//       }, 100); // check every 100ms
+
+//       return {};
+//     },
+//     'xu-style-global': async function ($elm, val) {
+//       $('head').append(`<style>${val.value}</style>`);
+//       return {};
+//     },
+//     'xu-style': async function ($elm, val) {
+//       var cssString = val.value;
+
+//       var parser = new cssjs();
+
+//       var parsed = parser.parseCSS(cssString);
+//       var xuUiId = `[xu-ui-id="${$elm.attr('xu-ui-id')}"]`;
+
+//       $.each(parsed, function (key, val) {
+//         var selectors_arr = val.selector.split(',');
+
+//         $.each(selectors_arr, function (key2, val2) {
+//           selectors_arr[key2] = `${xuUiId} ${val2}, ${xuUiId}${val2}`;
+//           // console.log(new_selector);
+//         });
+
+//         val.selector = selectors_arr.join(',');
+//         // console.log(parsed);
+//       });
+
+//       var newCSSString = parser.getCSSForEditor(parsed);
+
+//       $('head').append(`<style>${newCSSString}</style>`);
+//       return {};
+//     },
+//     'xu-cdn': async function ($elm, val) {
+//       for await (const [key, resource] of Object.entries(val.value)) {
+//         await load_cdn(resource);
+//       }
+
+//       return {};
+//     },
+//     'xu-ui-plugin': async function ($elm, val) {
+//       var _session = SESSION_OBJ[SESSION_ID];
+
+//       for await (const [plugin_name, value] of Object.entries(val.value)) {
+//         const _plugin = APP_OBJ[_session.app_id]?.app_plugins_purchased?.[plugin_name];
+//         if (_plugin?.installed && _plugin?.manifest?.['runtime.mjs']?.exist && _plugin?.manifest?.['index.mjs']?.exist && value.enabled) {
+//           if (_plugin?.manifest?.['runtime.mjs'].dist && _plugin?.manifest?.['runtime.mjs']?.css) {
+//             const plugin_runtime_css_url = await func.utils.get_plugin_npm_cdn(SESSION_ID, plugin_name, 'dist/runtime.css');
+//             func.utils.load_css_on_demand(plugin_runtime_css_url);
+//           }
+
+//           const plugin_index_src = await func.utils.get_plugin_npm_cdn(SESSION_ID, plugin_name, `${_plugin.manifest['index.mjs'].dist ? 'dist/' : ''}index.mjs`);
+
+//           const plugin_index_resources = await import(plugin_index_src);
+
+//           let properties = _.cloneDeep(plugin_index_resources.properties);
+//           for await (let [prop_name, prop_val] of Object.entries(properties)) {
+//             prop_val.value = value?.attributes?.[prop_name];
+//             if (value?.attributes?.[`xu-exp:${prop_name}`]) {
+//               const res = await func.expression.get(SESSION_ID, value?.attributes?.[`xu-exp:${prop_name}`], paramsP.dsSessionP, 'UI Attr EXP');
+//               prop_val.value = res.result;
+//             }
+//           }
+//           // $elm.data().xu_ui_plugin = { properties };
+//           const plugin_runtime_src = await func.utils.get_plugin_npm_cdn(SESSION_ID, plugin_name, `${_plugin.manifest['runtime.mjs'].dist ? 'dist/' : ''}runtime.mjs`);
+
+//           const plugin_runtime_resources = await import(plugin_runtime_src);
+
+//           if (plugin_runtime_resources.cdn && typeof _.isArray(plugin_runtime_resources.cdn)) {
+//             for await (const resource of plugin_runtime_resources.cdn) {
+//               await load_cdn(resource);
+//             }
+//           }
+
+//           if (plugin_runtime_resources.fn) {
+//             await plugin_runtime_resources.fn(plugin_name, $elm?.[0], properties);
+//             // await plugin_runtime_resources.fn(plugin_name, $elm?.[0], $elm.data().xu_ui_plugin.properties);
+//           }
+//         }
+//       }
+
+//       return {};
+//     },
+//     'xu-store': async function ($elm, val) {
+//       try {
+//         const fields_obj = JSON5.parse(val.value);
+//         for (const [field_id, value] of Object.entries(fields_obj)) {
+//           func.datasource.add_dynamic_field_to_ds(SESSION_ID, paramsP.dsSessionP, field_id, value);
+//         }
+//       } catch (err) {
+//         console.error(err);
+//       }
+//       return {};
+//     },
+//     'xu-viewport': async function ($elm, val) {
+//       // functionality in draw_html_element
+//       return {};
+//     },
+//   };
+
+//   if (nodeP.tagName.substr(0, 3) === 'xu-') {
+//     if (xu_func === 'xu-exp') {
+//       return common_fx[xu_func]($elm, val);
+//     }
+
+//     if (tag_fx?.[nodeP.tagName]?.[xu_func]) {
+//       let ret = await tag_fx[nodeP.tagName][xu_func]($elm, val);
+//       return ret;
+//     }
+//     // if (xu_func !== "tree_id")
+//     console.warn(`attribute ${xu_func} not found for ${nodeP.tagName}`);
+//     return {};
+//   }
+//   if (_.isEmpty($elm.data())) {
+//     return {};
+//   }
+//   if (!$elm.data().xuData.debug_info.attribute_stat) {
+//     $elm.data().xuData.debug_info.attribute_stat = {};
+//   }
+//   if (xu_func !== 'xu-exp') {
+//     $elm.data().xuData.debug_info.attribute_stat[xu_func] = val.value;
+//   }
+//   try {
+//     if (!common_fx[xu_func]) {
+//       console.warn('invalid xu-tag', xu_func, error);
+//       return {};
+//     }
+
+//     return await common_fx[xu_func]($elm, val);
+//   } catch (error) {
+//     debugger;
+//   }
+// };
+
+func.UI.screen.execute_xu_functions = async function (SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, xu_func, $elm, val, is_init, refreshed_ds) {
+  if (is_skeleton) return;
+
+  // Cache frequently accessed values
+  const _session = SESSION_OBJ[SESSION_ID];
+  const _ds = _session.DS_GLB[paramsP.dsSessionP];
+  const elmData = $elm.data();
+  const xuData = elmData.xuData;
+  const nodeTag = nodeP.tagName;
+  const isXuTag = nodeTag && nodeTag.startsWith('xu-');
 
+  const load_cdn = async function (resource) {
+    if (!_.isObject(resource)) {
+      resource = _.isString(resource) ? { src: resource, type: 'js' } : null;
+    }
+    if (!resource) {
+      throw new Error('cdn resource in wrong format');
+    }
+
+    try {
+      const loadFn = resource.type === 'css' ? func.utils.load_css_on_demand : func.utils.load_js_on_demand;
+      const moduleArg = resource.type === 'module' ? 'module' : undefined;
+      await loadFn(resource.src, moduleArg);
+    } catch (error) {
+      func.utils.debug_report(SESSION_ID, 'xu-cdn', 'Fail to load: ' + resource.src, 'W');
+    }
+  };
+
+  const common_fx = {
+    'xu-attrs': async function ($elm, val) {
+      if (!val.value || !_.isObject(val.value)) {
+        if (val.value) throw 'xu-attrs value is not an object';
+        return {};
+      }
+      Object.assign(nodeP.attributes, val.value);
+      return {};
+    },
+
+    'xu-ref': async function ($elm, val, dsSession) {
+      if (!val.value) return {};
+
+      func.UI.update_xu_ref(SESSION_ID, dsSession || paramsP.dsSessionP, val.value, $elm);
+
+      const targetNode = $elm[0];
+      if (!targetNode) return {};
+
+      const observer = new MutationObserver(() => {
+        func.UI.screen.refresh_xu_attributes(SESSION_ID, [val.value]);
+      });
+
+      observer.observe(targetNode, { attributes: true, childList: true, subtree: true });
+      return {};
+    },
+
+    'xu-bind': async function ($elm, val) {
+      if (is_skeleton) return {};
+
+      let val_is_reference_field = false;
+      let _prog_id = xuData.paramsP.prog_id;
+      let _dsP = xuData.paramsP.dsSessionP;
+
+      const view_ret = await func.utils.VIEWS_OBJ.get(SESSION_ID, _prog_id);
+      if (!view_ret) return {};
+
+      let is_dynamic_field = false;
+      let field_prop;
+      let bind_field_id;
+      const input_field_type = $elm.attr('type');
+
+      const get_bind_field = async function (field_id) {
+        if (['_FOR_VAL', '_FOR_KEY'].includes(field_id)) {
+          is_dynamic_field = true;
+          field_prop = _ds.dynamic_fields[field_id];
+        } else {
+          field_prop = func.common.find_item_by_key(view_ret.progFields, 'field_id', field_id);
+          if (!field_prop) {
+            const ret_get_value = await func.datasource.get_value(SESSION_ID, field_id, _dsP);
+            if (ret_get_value.found) {
+              _dsP = ret_get_value.dsSessionP;
+              const ds = _session.DS_GLB[_dsP];
+              _prog_id = ds.prog_id;
+              const new_view_ret = await func.utils.VIEWS_OBJ.get(SESSION_ID, _prog_id);
+              if (!new_view_ret) return {};
+              field_prop = func.common.find_item_by_key(new_view_ret.progFields, 'field_id', field_id);
+            }
+            if (!field_prop) {
+              throw `field ${field_id} not found in the program scope`;
+            }
+          }
+        }
+        return field_id;
+      };
+
+      try {
+        bind_field_id = await get_bind_field(val.value.split('.')[0]);
+        val_is_reference_field = true;
+      } catch (err) {
+        console.error(err?.message || err);
+        return {};
+      }
+
+      const field_changed = async function (e) {
+        const ds = _session.DS_GLB[_dsP];
+        const fieldType = field_prop.props.fieldType;
+        const isCheckbox = input_field_type === 'checkbox';
+        const isRadio = input_field_type === 'radio';
+
+        // Handle array field with checkbox
+        if (fieldType === 'array' && isCheckbox && val_is_reference_field) {
+          const arr_value = _.clone((await func.datasource.get_value(SESSION_ID, bind_field_id, _dsP, ds.currentRecordId)).ret.value);
+          const value_from_getter = bind.getter($elm[0]);
+          const value = arr_value.includes(value_from_getter) ? arr_value.filter((item) => !_.isEqual(item, value_from_getter)) : [...arr_value, value_from_getter];
+
+          return await func.datasource.update(SESSION_ID, {
+            [_dsP]: { [ds.currentRecordId]: { [bind_field_id]: value } },
+          });
+        }
+
+        // Handle array field with radio
+        if (fieldType === 'array' && isRadio && val_is_reference_field) {
+          return await func.datasource.update(SESSION_ID, {
+            [_dsP]: { [ds.currentRecordId]: { [bind_field_id]: [bind.getter($elm[0])] } },
+          });
+        }
+
+        let value = await func.common.get_cast_val(SESSION_ID, 'xu-bind', 'value', fieldType, bind.getter($elm[0]));
+
+        if (fieldType === 'object') {
+          value = await func.common.get_cast_val(SESSION_ID, 'xu-bind', 'value', input_field_type, bind.getter($elm[0]));
+        }
+
+        if (!ds.currentRecordId) return;
+
+        await func.datasource.update(SESSION_ID, {
+          [_dsP]: { [ds.currentRecordId]: { [bind_field_id]: value } },
+        });
+
+        const iterate_info = xuData?.iterate_info;
+        const reference_source_obj = iterate_info?.reference_source_obj;
+
+        if (reference_source_obj?.ret?.type === 'array' && iterate_info.iterator_val === bind_field_id) {
+          const arr_idx = Number(iterate_info._key);
+          const dataset_arr = await func.datasource.get_value(SESSION_ID, reference_source_obj.fieldIdP, _dsP, reference_source_obj.currentRecordId);
+          const new_arr = _.cloneDeep(dataset_arr.ret.value);
+
+          if (fieldType === 'object' && val_is_reference_field) {
+            let obj_item = new_arr[arr_idx];
+            const e_exp = val.value.replace(bind_field_id, 'obj_item');
+            eval(e_exp + (input_field_type === 'string' ? `="${value}"` : `=${value}`));
+            new_arr[arr_idx] = obj_item;
+          } else {
+            new_arr[arr_idx] = value;
+          }
+
+          await func.datasource.update(
+            SESSION_ID,
+            {
+              [_dsP]: { [ds.currentRecordId]: { [reference_source_obj.fieldIdP]: new_arr } },
+            },
+            null,
+            true,
+          );
+        }
+
+        await func.datasource.update_changes_for_out_parameter(SESSION_ID, _dsP, ds.parentDataSourceNo);
+      };
+
+      const bind = new UI_FRAMEWORK_PLUGIN.bind();
       bind.listener($elm[0], field_changed);
 
       const set_value = function () {
-        let _ds = SESSION_OBJ[SESSION_ID].DS_GLB[paramsP.dsSessionP];
-        if (!_ds.currentRecordId) return;
-        let value;
+        const ds = _session.DS_GLB[paramsP.dsSessionP];
+        if (!ds.currentRecordId) return;
+
         try {
+          let value;
           if (val_is_reference_field) {
             if (is_dynamic_field) {
-              value = _ds.dynamic_fields[bind_field_id].value;
+              value = ds.dynamic_fields[bind_field_id].value;
             } else {
-              const row_idx = func.common.find_ROWID_idx(_ds, _ds.currentRecordId);
-              value = _ds.data_feed.rows?.[row_idx]?.[bind_field_id];
+              const row_idx = func.common.find_ROWID_idx(ds, ds.currentRecordId);
+              value = ds.data_feed.rows?.[row_idx]?.[bind_field_id];
             }
-            if (field_prop.props.fieldType === 'array' && $elm.attr('type') === 'checkbox' && $elm.attr('value')) {
-              if (value.includes($elm.attr('value'))) {
-                value = true;
-              } else {
-                value = false;
-              }
-            } else if (field_prop.props.fieldType === 'array' && $elm.attr('type') === 'radio' && $elm.attr('value')) {
-              if (value.includes($elm.attr('value'))) {
-                value = $elm.attr('value');
-              } else {
-                value = false;
-              }
-            } else if (field_prop.props.fieldType === 'object' && val.value.split('.').length > 1) {
-              let str = val.value.replace(bind_field_id, '(' + JSON.stringify(value) + ')');
-              value = eval(str);
+
+            const fieldType = field_prop.props.fieldType;
+            const elmValue = $elm.attr('value');
+
+            if (fieldType === 'array' && input_field_type === 'checkbox' && elmValue) {
+              value = value.includes(elmValue);
+            } else if (fieldType === 'array' && input_field_type === 'radio' && elmValue) {
+              value = value.includes(elmValue) ? elmValue : false;
+            } else if (fieldType === 'object' && val.value.split('.').length > 1) {
+              value = eval(val.value.replace(bind_field_id, '(' + JSON.stringify(value) + ')'));
             }
           } else {
             value = val.value;
           }
-          if (typeof value === 'undefined') return;
-          bind.setter($elm[0], value);
+
+          if (value !== undefined) {
+            bind.setter($elm[0], value);
+          }
         } catch (err) {
           console.error(err);
         }
       };
-      /// init value from ds
-      $('body').on('xu-bind-refresh.' + _ds.dsSession.toString(), () => {
-        set_value();
-      });
 
+      $('body').on('xu-bind-refresh.' + _ds.dsSession, set_value);
       set_value();
       return {};
     },
+
     'xu-render': async function ($elm, val, from_panel) {
-      const old_render = async function () {
-        var value = await func.common.get_cast_val(SESSION_ID, 'common fx', 'xu-render', 'bool', val.value);
+      const value = await func.common.get_cast_val(SESSION_ID, 'common fx', 'xu-render', 'bool', val.value);
+
+      if (!glb.new_xu_render) {
+        // Old render logic (kept as is for compatibility)
         const init_render = function () {
           if (!value) {
-            var cloned_$div = $elm.clone(true);
-
-            let $xurender = $('<xurender>').attr('xu-ui-id', $elm.attr('xu-ui-id')).attr('hidden', true).appendTo($container); //.hide();
-            let original_data_obj = {
+            const cloned_$div = $elm.clone(true);
+            const $xurender = $('<xurender>').attr('xu-ui-id', $elm.attr('xu-ui-id')).attr('hidden', true).appendTo($container);
+            const original_data_obj = {
               $container: cloned_$div,
               nodeP: _.cloneDeep(nodeP),
               parent_infoP,
@@ -32370,8 +33253,6 @@ func.UI.screen.execute_xu_functions = async function (SESSION_ID, is_skeleton, $
             $xurender.data().xuData.original_data_obj = original_data_obj;
             $xurender.data().xuData.xurender_node = cloned_$div;
             $xurender.data().xuAttributes = nodeP.attributes || {};
-            // $xurender.hide();
-
             $elm.remove();
             return { abort: true };
           }
@@ -32381,271 +33262,207 @@ func.UI.screen.execute_xu_functions = async function (SESSION_ID, is_skeleton, $
         const post_render = async function () {
           if (value) {
             try {
-              // abort if already rended
-              if ($elm[0].tagName !== 'XURENDER' && $elm?.length) {
+              if ($elm[0].tagName !== 'XURENDER' || !$elm?.length) {
                 return func.events.delete_job(SESSION_ID, jobNoP);
               }
 
-              let original_data_obj = $elm.data().xuData.original_data_obj;
-
+              const original_data_obj = $elm.data().xuData.original_data_obj;
               if (!original_data_obj) {
                 func.events.delete_job(SESSION_ID, jobNoP);
                 return { delete_job: jobNoP };
               }
 
-              const new_$div = await func.UI.screen.render_ui_tree(
-                SESSION_ID,
-                $elm, //original_data_obj.$container,
-                _.cloneDeep(original_data_obj.nodeP),
-                original_data_obj.parent_infoP,
-                original_data_obj.paramsP,
-                jobNoP,
-                null,
-                original_data_obj.keyP,
-                null,
-                original_data_obj.parent_nodeP,
-                null,
-                original_data_obj.$root_container,
-              );
+              const new_$div = await func.UI.screen.render_ui_tree(SESSION_ID, $elm, _.cloneDeep(original_data_obj.nodeP), original_data_obj.parent_infoP, original_data_obj.paramsP, jobNoP, null, original_data_obj.keyP, null, original_data_obj.parent_nodeP, null, original_data_obj.$root_container);
 
               new_$div.data().xuData.original_data_obj = original_data_obj;
               new_$div.data().xuData.xurender_node = $elm.clone(true);
               new_$div.data().xuAttributes = $elm.data().xuAttributes || {};
 
               const replace = async function () {
-                $elm.replaceWith(new_$div);
+                $elm.replaceWith(from_panel ? new_$div.children() : new_$div);
                 if (from_panel) {
-                  const xuPanelWrapper = _.clone(new_$div.data().xuPanelWrapper);
-                  $elm.parent().data().xuPanelWrapper = xuPanelWrapper;
-                  $elm.replaceWith(new_$div.children());
+                  $elm.parent().data().xuPanelWrapper = _.clone(new_$div.data().xuPanelWrapper);
                 }
-
                 if (val.fields_arr) {
                   return await func.UI.screen.refresh_xu_attributes(SESSION_ID, val.fields_arr, val.jobNoP, new_$div);
                 }
                 func.events.delete_job(SESSION_ID, jobNoP);
               };
-              //  if ($elm && func.UI.utils.find_in_element_data('xuData', $(SESSION_OBJ[SESSION_ID].root_element), 'xu_id', $elm.data().xuData.xu_id).length) {
-              if ($elm && $(`[xu-ui-id="${$elm.attr('xu-ui-id')}"]`).length) {
-                if (new_$div.data().xuData.paramsP) {
-                  return await replace();
-                }
 
-                func.events.delete_job(SESSION_ID, jobNoP);
+              if ($elm && $(`[xu-ui-id="${$elm.attr('xu-ui-id')}"]`).length && new_$div.data().xuData.paramsP) {
+                return await replace();
               }
+              func.events.delete_job(SESSION_ID, jobNoP);
             } catch (error) {
               func.events.delete_job(SESSION_ID, jobNoP);
             }
             return;
           }
-          // if (!value) {
+
           if ($elm.prop('tagName') === 'XURENDER') {
             func.events.delete_job(SESSION_ID, jobNoP);
             return;
           }
 
-          let tmp_$div = $('<div>');
+          const $xurender = $('<xurender>').attr('xu-ui-id', $elm.attr('xu-ui-id'));
 
-          let $xurender = $('<xurender>').attr('xu-ui-id', $elm.attr('xu-ui-id')).appendTo(tmp_$div); //.hide();
-          // was true before
           if ($elm.data().xuData.xurender_node) {
             $xurender.data({
               xuAttributes: $elm.data().xuData.xurender_node.data().xuAttributes || {},
               xuData: $elm.data().xuData.xurender_node.data().xuData || {},
             });
           } else {
-            // default new state
-
             $xurender.data({
               xuAttributes: $elm.data().xuAttributes || {},
               xuData: $elm.data().xuData || {},
             });
-            const original_data_obj = {
+            $xurender.data().xuData.original_data_obj = {
               nodeP: _.cloneDeep($elm.data().xuData.node_org),
               paramsP: $elm.data().xuData.paramsP,
               $container: $elm.clone(true),
               parent_infoP: parent_infoP,
             };
-
-            $xurender.data().xuData.original_data_obj = original_data_obj;
           }
 
-          //remove xu-teleport trace
           $.each($elm.find('xu-teleport'), (key, val) => {
             const xuTeleportData = $(val).data().xuTeleportData || [];
-            for (const teleported_elm_id of xuTeleportData) {
-              $(`[xu-ui-id="${teleported_elm_id}"]`).remove();
-            }
+            xuTeleportData.forEach((id) => $(`[xu-ui-id="${id}"]`).remove());
           });
 
-          $elm.replaceWith(tmp_$div.children());
+          $elm.replaceWith($xurender);
           func.events.delete_job(SESSION_ID, jobNoP);
-          // }
         };
-        if (is_init) {
-          return init_render();
-        }
-        return await post_render();
-      };
 
-      const new_render = async function () {
-        var value = await func.common.get_cast_val(SESSION_ID, 'common fx', 'xu-render', 'bool', val.value);
-        const has_xu_render_attribute = true;
-        const has_xu_exp_render_attribute = $elm.data()?.xuData?.attr_exp_info?.['xu-render'] ? true : false;
-        const init_render = async function () {
-          nodeP.xu_render_made = value;
-          if (!value) {
-            if (has_xu_exp_render_attribute) {
-              return { has_xu_exp_render_attribute, has_xu_render_attribute, xu_render_background_processing: true };
-            }
-            return { has_xu_render_attribute, abort: true };
-          }
-          return { has_xu_exp_render_attribute, has_xu_render_attribute };
-        };
+        return is_init ? init_render() : await post_render();
+      }
 
-        const post_render = async function () {
-          // always come from refresh
-          let nodeP = $container.data().xuData.node.children[keyP];
-          nodeP.xu_render_made = value;
-          if (value) {
-            try {
-              const xu_render_cache_id = await get_xu_render_cache_str(SESSION_ID, paramsP.dsSessionP, Object.keys($elm.data()?.xuData?.attr_exp_info?.['xu-render']?.fields || {}));
-              const xu_ui_id = $elm.attr('xu-ui-id');
-              let new_$div = UI_WORKER_OBJ?.xu_render_cache?.[xu_ui_id + xu_render_cache_id]?.$div.clone(true);
-              let found_parent_vars = false;
-              if (new_$div) {
-                // validate if $div contains fields from parent ds
-                const parent_data = get_parent_ds_fields(SESSION_ID, paramsP.dsSessionP);
-                const parent_fields = Object.keys(parent_data);
-
-                $.each(new_$div.find('*'), (key, val) => {
-                  const _xuAttributes = $(val)?.data()?.xuAttributes;
-                  if (found_parent_vars || !_xuAttributes) return;
-                  for (const [attr_key, attr_val] of Object.entries(_xuAttributes)) {
-                    if (found_parent_vars) break;
-                    for (const [key, val] of Object.entries(parent_fields)) {
-                      if (attr_val.includes('@' + key)) {
-                        found_parent_vars = true;
-                        break;
-                      }
-                    }
-                  }
-                });
-              }
+      // New render logic
+      const has_xu_render_attribute = true;
+      const has_xu_exp_render_attribute = !!xuData?.attr_exp_info?.['xu-render'];
 
-              if (!new_$div || found_parent_vars) {
-                UI_WORKER_OBJ.xu_render_cache[xu_ui_id + xu_render_cache_id] = { paramsP };
-                nodeP.xu_render_xu_ui_id = xu_ui_id;
-                nodeP.xu_render_cache_id = xu_render_cache_id;
-                new_$div = await func.UI.screen.render_ui_tree(SESSION_ID, $container, nodeP, parent_infoP, paramsP, jobNoP, null, keyP, null, parent_nodeP, null, $root_container);
-                const _$div = new_$div.clone(true);
-                UI_WORKER_OBJ.xu_render_cache[xu_ui_id + xu_render_cache_id].$div = _$div;
-                UI_WORKER_OBJ.xu_render_cache[xu_ui_id + xu_render_cache_id].data = _$div.data();
-              }
-              // append order handling
+      const init_render = async function () {
+        nodeP.xu_render_made = value;
+        if (!value) {
+          return has_xu_exp_render_attribute ? { has_xu_exp_render_attribute, has_xu_render_attribute, xu_render_background_processing: true } : { has_xu_render_attribute, abort: true };
+        }
+        return { has_xu_exp_render_attribute, has_xu_render_attribute };
+      };
 
-              if (!$container.children().length) {
-                new_$div.appendTo($container);
-              } else {
-                // iterate the container node
-                let $last_elm_found = [];
-                $.each($container.data().xuData.node.children, (item_key, item_val) => {
-                  // const $elm = $(`[xu-node-id="${item_val.id}"]`);
-                  const $elm = func.UI.utils.find_in_element_data('xuData', $(SESSION_OBJ[SESSION_ID].root_element), 'nodeid', item_val.id);
-                  if ($elm.length) {
-                    $last_elm_found = $elm;
-                  }
-                  if (keyP == item_key) {
-                    if ($last_elm_found.length) {
-                      new_$div.after($last_elm_found);
-                    } else {
-                      $container.prepend(new_$div);
-                    }
+      const post_render = async function () {
+        const containerNodeP = $container.data().xuData.node.children[keyP];
+        containerNodeP.xu_render_made = value;
+
+        if (value) {
+          try {
+            const xu_render_cache_id = await get_xu_render_cache_str(SESSION_ID, paramsP.dsSessionP, Object.keys(xuData?.attr_exp_info?.['xu-render']?.fields || {}));
+            const xu_ui_id = $elm.attr('xu-ui-id');
+            const cache_key = xu_ui_id + xu_render_cache_id;
+            let new_$div = UI_WORKER_OBJ?.xu_render_cache?.[cache_key]?.$div?.clone(true);
+            let found_parent_vars = false;
+
+            if (new_$div) {
+              const parent_data = get_parent_ds_fields(SESSION_ID, paramsP.dsSessionP);
+              const parent_fields = Object.keys(parent_data);
+
+              $.each(new_$div.find('*'), (key, val) => {
+                if (found_parent_vars) return;
+                const _xuAttributes = $(val)?.data()?.xuAttributes;
+                if (!_xuAttributes) return;
+
+                for (const attr_val of Object.values(_xuAttributes)) {
+                  if (parent_fields.some((field) => attr_val.includes('@' + field))) {
+                    found_parent_vars = true;
+                    break;
                   }
-                });
-              }
-            } catch (error) {
-              func.events.delete_job(SESSION_ID, jobNoP);
+                }
+              });
             }
-            return;
-          }
 
-          /////////// !value ///////////
+            if (!new_$div || found_parent_vars) {
+              UI_WORKER_OBJ.xu_render_cache[cache_key] = { paramsP };
+              containerNodeP.xu_render_xu_ui_id = xu_ui_id;
+              containerNodeP.xu_render_cache_id = xu_render_cache_id;
 
-          const xu_ui_id = $elm.attr('xu-ui-id');
+              new_$div = await func.UI.screen.render_ui_tree(SESSION_ID, $container, containerNodeP, parent_infoP, paramsP, jobNoP, null, keyP, null, parent_nodeP, null, $root_container);
 
-          const cache_str = await get_xu_render_cache_str(SESSION_ID, paramsP.dsSessionP, Object.keys($elm.data()?.xuData?.attr_exp_info?.['xu-render']?.fields || {}));
-          const _$div = $elm.clone(true);
-          UI_WORKER_OBJ.xu_render_cache[xu_ui_id + cache_str] = { $div: _$div, data: _$div.data(), paramsP };
-          $elm.remove();
-          func.events.delete_job(SESSION_ID, jobNoP);
-        };
-        if (is_init) {
-          return await init_render();
+              const _$div = new_$div.clone(true);
+              UI_WORKER_OBJ.xu_render_cache[cache_key] = { $div: _$div, data: _$div.data(), paramsP };
+            }
+
+            // Append order handling
+            if (!$container.children().length) {
+              new_$div.appendTo($container);
+            } else {
+              let $last_elm_found = [];
+              $.each($container.data().xuData.node.children, (item_key, item_val) => {
+                const $elm = func.UI.utils.find_in_element_data('xuData', $(_session.root_element), 'nodeid', item_val.id);
+                if ($elm.length) $last_elm_found = $elm;
+                if (keyP == item_key) {
+                  $last_elm_found.length ? new_$div.after($last_elm_found) : $container.prepend(new_$div);
+                }
+              });
+            }
+          } catch (error) {
+            func.events.delete_job(SESSION_ID, jobNoP);
+          }
+          return;
         }
-        return await post_render();
+
+        // !value
+        const xu_ui_id = $elm.attr('xu-ui-id');
+        const cache_str = await get_xu_render_cache_str(SESSION_ID, paramsP.dsSessionP, Object.keys(xuData?.attr_exp_info?.['xu-render']?.fields || {}));
+        const _$div = $elm.clone(true);
+        UI_WORKER_OBJ.xu_render_cache[xu_ui_id + cache_str] = { $div: _$div, data: _$div.data(), paramsP };
+        $elm.remove();
+        func.events.delete_job(SESSION_ID, jobNoP);
       };
 
-      if (glb.new_xu_render) {
-        return new_render();
-      }
-      return old_render();
+      return is_init ? await init_render() : await post_render();
     },
+
     'xu-show': async function ($elm, val) {
-      var value = await func.common.get_cast_val(SESSION_ID, 'common fx', 'xu-show', 'bool', val.value);
-      if (value) {
-        $elm.show();
-      }
-      if (!value) {
-        $elm.hide();
-      }
+      const value = await func.common.get_cast_val(SESSION_ID, 'common fx', 'xu-show', 'bool', val.value);
+      $elm.toggle(value);
       return {};
     },
+
     'xu-content': async function ($elm, val) {
       try {
         $elm.html(val.value);
       } catch (error) {
-        console.warn(e);
+        console.warn(error);
       }
-      return;
     },
+
     'xu-text': async function ($elm, val) {
       try {
         $elm.text(val.value);
       } catch (error) {
-        console.warn(e);
+        console.warn(error);
       }
-      return;
     },
+
     'xu-html': async function ($elm, val) {
       try {
         $elm.html(val.value);
       } catch (error) {
-        console.warn(e);
+        console.warn(error);
       }
-      return;
     },
+
     'xu-for': async function ($elm, data) {
-      // exit if call from rendered xu-for item to prevent infante loop (parent_infoP?.iterate_info indicate call from rendered item)
-      if (parent_infoP?.iterate_info) return {};
-      if (!data.value) return {};
+      if (parent_infoP?.iterate_info || !data.value) return {};
+
       try {
-        // data.value (xu-for) can store actual values such as an array, a CSV, or a field_id that references a specific field within the dataset, initialized with values for the iteration.
         let arr = data.value;
-
-        // find reference source field
         let reference_source_obj;
-
         const _progFields = await func.datasource.get_progFields(SESSION_ID, paramsP.dsSessionP);
+        const view_field_obj = func.common.find_item_by_key(_progFields, 'field_id', data.value);
 
-        let view_field_obj = func.common.find_item_by_key(_progFields, 'field_id', data.value);
-        // detect if data.value (xu-for) is reference field_id  by checking if exist in the dataset
         if (view_field_obj) {
-          // xu-for is reference field_id
           reference_source_obj = await func.datasource.get_value(SESSION_ID, data.value, paramsP.dsSessionP);
           arr = reference_source_obj?.ret?.value;
         } else {
-          // xu-for is actual data
           if (typeof data.value === 'string') {
             arr = eval(data.value.replaceAll('\\', ''));
           }
@@ -32654,59 +33471,44 @@ func.UI.screen.execute_xu_functions = async function (SESSION_ID, is_skeleton, $
           }
         }
 
-        const custom_iterator_key = $elm.data().xuData.iterator_key;
-        const custom_iterator_val = $elm.data().xuData.iterator_val;
-
-        let iterator_key = custom_iterator_key;
-        let iterator_val = custom_iterator_val;
-        let is_key_dynamic_field, is_val_dynamic_field;
+        const custom_iterator_key = xuData.iterator_key;
+        const custom_iterator_val = xuData.iterator_val;
+        const iterator_key = custom_iterator_key || '_FOR_KEY';
+        const iterator_val = custom_iterator_val || '_FOR_VAL';
+        const is_key_dynamic_field = !custom_iterator_key;
+        const is_val_dynamic_field = !custom_iterator_val;
 
-        // custom FOR_VAL name or namespaced default name
-        if (!custom_iterator_key) {
-          is_key_dynamic_field = true;
-
-          iterator_key = '_FOR_KEY';
-        }
-
-        if (!custom_iterator_val) {
-          is_val_dynamic_field = true;
-
-          iterator_val = '_FOR_VAL';
-        }
-
-        var i = 0;
-        for await (let [_key, _val] of Object.entries(arr)) {
-          if (_.isArray(arr)) {
-            _key = Number(_key);
-          }
-
-          const set_value = async function (is_dynamic_field, currentRecordId, field_id, value) {
-            if (is_dynamic_field) {
-              func.datasource.add_dynamic_field_to_ds(SESSION_ID, paramsP.dsSessionP, field_id, value);
-            } else {
-              const _progFields = await func.datasource.get_progFields(SESSION_ID, paramsP.dsSessionP);
+        const set_value = async function (is_dynamic_field, currentRecordId, field_id, value) {
+          if (is_dynamic_field) {
+            func.datasource.add_dynamic_field_to_ds(SESSION_ID, paramsP.dsSessionP, field_id, value);
+          } else {
+            const _progFields = await func.datasource.get_progFields(SESSION_ID, paramsP.dsSessionP);
+            const view_field_obj = func.common.find_item_by_key(_progFields, 'field_id', field_id);
 
-              let view_field_obj = func.common.find_item_by_key(_progFields, 'field_id', field_id);
-              if (view_field_obj) {
-                let _ds = SESSION_OBJ[SESSION_ID].DS_GLB[paramsP.dsSessionP];
-                try {
-                  const row_idx = func.common.find_ROWID_idx(_ds, currentRecordId);
-                  _ds.data_feed.rows[row_idx][field_id] = value;
-                } catch (err) {
-                  console.error(err);
-                }
-              } else {
-                console.error('field not exist in dataset for xu-for method');
+            if (view_field_obj) {
+              const ds = _session.DS_GLB[paramsP.dsSessionP];
+              try {
+                const row_idx = func.common.find_ROWID_idx(ds, currentRecordId);
+                ds.data_feed.rows[row_idx][field_id] = value;
+              } catch (err) {
+                console.error(err);
               }
+            } else {
+              console.error('field not exist in dataset for xu-for method');
             }
-          };
+          }
+        };
 
-          var currentRecordId = SESSION_OBJ[SESSION_ID].DS_GLB[paramsP.dsSessionP].currentRecordId.toString();
+        const currentRecordId = _ds.currentRecordId.toString();
+        let i = 0;
+
+        for (let [_key, _val] of Object.entries(arr)) {
+          if (_.isArray(arr)) _key = Number(_key);
 
           await set_value(is_key_dynamic_field, currentRecordId, iterator_key, _key);
           await set_value(is_val_dynamic_field, currentRecordId, iterator_val, _val);
 
-          var iterate_info = {
+          const iterate_info = {
             _val,
             _key,
             iterator_key,
@@ -32715,26 +33517,13 @@ func.UI.screen.execute_xu_functions = async function (SESSION_ID, is_skeleton, $
             is_val_dynamic_field,
             reference_source_obj,
           };
-          // let _parent_info = _.cloneDeep(parent_infoP) || {};
-          let _parent_info = klona.klona(parent_infoP) || {};
+
+          const _parent_info = klona.klona(parent_infoP) || {};
           _parent_info.iterate_info = iterate_info;
 
-          const $divP = await func.UI.screen.render_ui_tree(
-            SESSION_ID,
-            $container,
-            nodeP,
-            _parent_info, //parent_infoP ? _.cloneDeep(_parent_info) : null,
-            paramsP,
-            jobNoP,
-            null,
-            i,
-            null,
-            nodeP,
-            null,
-            $root_container,
-          );
+          const $divP = await func.UI.screen.render_ui_tree(SESSION_ID, $container, nodeP, _parent_info, paramsP, jobNoP, null, i, null, nodeP, null, $root_container);
 
-          $.each($divP.children(), function (key, val) {
+          $.each($divP.children(), (key, val) => {
             if ($(val)?.data()?.xuData) {
               $(val).data().xuData.iterate_info = iterate_info;
             }
@@ -32742,106 +33531,87 @@ func.UI.screen.execute_xu_functions = async function (SESSION_ID, is_skeleton, $
 
           i++;
         }
+
         $elm.remove();
         return { abort: true };
       } catch (e) {
-        console.error(' Iterator Arr parse error');
+        console.error('Iterator Arr parse error', e);
         return { abort: true };
       }
     },
+
     'xu-for-key': async function ($elm, val) {
-      $elm.data().xuData.iterator_key = val.value;
+      xuData.iterator_key = val.value;
       return {};
     },
+
     'xu-for-val': async function ($elm, val) {
-      $elm.data().xuData.iterator_val = val.value;
+      xuData.iterator_val = val.value;
       return {};
     },
+
     'xu-class': async function ($elm, val) {
       try {
-        const classes_string = val.value;
-        // let obj = _.isString(classes_string) ? JSON.parse(classes_string) : _.defaults(classes_string, {});
-
-        const classes_obj = _.isString(classes_string) ? JSON.parse(classes_string) : _.defaults(classes_string, {});
-        for await (const [cla, cond] of Object.entries(classes_obj)) {
-          let res = await func.expression.get(
-            SESSION_ID,
-            cond,
-            paramsP.dsSessionP,
-            'UI Attr EXP',
-            $elm.data().xuData.currentRecordId, // SESSION_OBJ[SESSION_ID].DS_GLB[paramsP.dsSessionP].currentRecordId
-            null,
-            null,
-            null,
-            null,
-            null,
-            $elm.data().xuData.iterate_info,
-          );
+        const classes_obj = _.isString(val.value) ? JSON.parse(val.value) : _.defaults(val.value, {});
 
-          if (res.result) {
-            $elm.addClass(cla);
-          } else {
-            $elm.removeClass(cla);
-          }
+        for (const [cla, cond] of Object.entries(classes_obj)) {
+          const res = await func.expression.get(SESSION_ID, cond, paramsP.dsSessionP, 'UI Attr EXP', xuData.currentRecordId, null, null, null, null, null, xuData.iterate_info);
 
-          $elm.data().xuData.debug_info.attribute_stat['xu-class'] = $elm.attr('class');
+          $elm.toggleClass(cla, res.result);
         }
+
+        xuData.debug_info.attribute_stat['xu-class'] = $elm.attr('class');
         return {};
       } catch (e) {
         console.warn('parse error:' + val.value);
         return { abort: true };
       }
     },
-    'xu-exp': async function ($elm, val) {
-      let exp = val.value === null ? true : val.value;
 
-      let exp_ret = await func.expression.get(SESSION_ID, exp, paramsP.dsSessionP, 'UI Attr EXP', SESSION_OBJ[SESSION_ID].DS_GLB[paramsP.dsSessionP].currentRecordId, null, null, null, null, null, $elm.data().xuData.iterate_info);
-
-      let value = func.UI.screen.fix_val_defaults(val.key, exp_ret.result);
+    'xu-exp': async function ($elm, val) {
+      const exp = val.value === null ? true : val.value;
+      const exp_ret = await func.expression.get(SESSION_ID, exp, paramsP.dsSessionP, 'UI Attr EXP', _ds.currentRecordId, null, null, null, null, null, xuData.iterate_info);
 
-      var new_val = {
-        key: val.key,
-        value,
-      };
+      const value = func.UI.screen.fix_val_defaults(val.key, exp_ret.result);
+      const new_val = { key: val.key, value };
 
-      if (nodeP.tagName.substr(0, 3) === 'xu-') {
-        if (tag_fx[nodeP.tagName][new_val.key]) {
-          return await tag_fx[nodeP.tagName][new_val.key]($elm, new_val);
+      if (isXuTag) {
+        if (tag_fx[nodeTag]?.[new_val.key]) {
+          return await tag_fx[nodeTag][new_val.key]($elm, new_val);
         }
-        console.warn(`attribute ${new_val.key} not found for ${nodeP.tagName}`);
+        console.warn(`attribute ${new_val.key} not found for ${nodeTag}`);
         return {};
       }
-      if (!$elm.data().xuData) return;
 
-      $elm.data().xuData.debug_info.attribute_stat[new_val.key] = new_val.value;
+      if (!xuData) return {};
+      xuData.debug_info.attribute_stat[new_val.key] = new_val.value;
 
-      // IGNORE UNDEFINED or NULL ATTRIBUTES
-      if (typeof new_val.value === 'undefined' || new_val.value === null) {
-        return {};
-      }
+      if (new_val.value === undefined || new_val.value === null) return {};
+      if (glb.solid_attributes.includes(new_val.key) && !new_val.value) return {};
 
-      // IGNORE ATTRIBUTES WITH EMPTY VALUES
-      if (glb.solid_attributes.includes(new_val.key) && !new_val.value) {
-        return {};
-      }
-
-      if (new_val.key.substr(0, 2) === 'xu') {
+      if (new_val.key.startsWith('xu')) {
         return await common_fx[new_val.key]($elm, new_val);
       }
 
       $elm.attr(new_val.key, ($elm.attr(new_val.key) || '') + new_val.value);
       return {};
     },
+
     'xu-on': async function ($elm, val) {
       CLIENT_ACTIVITY_TS = Date.now();
       const trigger = val.key.split('xu-on:')[1].toLowerCase();
+
       $elm.on(trigger, async function (evt) {
         const _$elm = $(evt.currentTarget);
-        if (_.isEmpty(_$elm.data().xuAttributes)) return;
+        const xuAttributes = _$elm.data().xuAttributes;
+        if (_.isEmpty(xuAttributes)) return;
 
-        for await (const [key, val] of Object.entries(_$elm.data().xuAttributes['xu-on:' + evt.type])) {
+        const handlers = xuAttributes['xu-on:' + evt.type];
+        if (!handlers) return;
+
+        for (const [key, val] of Object.entries(handlers)) {
           if (!_.isEmpty(val.props.condition)) {
-            const expCond = await func.expression.get(SESSION_ID, val.props.condition, paramsP.dsSessionP, 'condition', paramsP.recordid); // execute expression
+            const expCond = await func.expression.get(SESSION_ID, val.props.condition, paramsP.dsSessionP, 'condition', paramsP.recordid);
             if (!expCond.result) continue;
           }
 
@@ -32849,18 +33619,9 @@ func.UI.screen.execute_xu_functions = async function (SESSION_ID, is_skeleton, $
             evt[val.event_modifiers]();
           }
 
-          // if (val.handler === 'custom') {
           if (val.workflow) {
-            // do BL
-            for await (const [key2, val2] of Object.entries(val.workflow)) {
-              // var cond = val2.data.enabled;
-              // if (val2.data.enabled && val2.props.condition) {
-              // expCond = await func.expression.get(SESSION_ID, val2.props.condition, paramsP.dsSessionP, 'condition', paramsP.recordid); // execute expression
-              // cond = expCond.result;
-              // }
-              // if (!cond) continue;
-
-              if (!val2.data.enabled) continue; // added Jul 3, 25 - condition validate on execution
+            for (const [key2, val2] of Object.entries(val.workflow)) {
+              if (!val2.data.enabled) continue;
 
               func.events.add_to_queue(SESSION_ID, 'element event', val2.id, evt.type, val2.data.action, val2.data.name, null, _$elm.attr('xu-ui-id'), null, evt, null, null, null, paramsP.dsSessionP, null, null, null, evt.type, val2.data.name, null, null, val2, null, null, null, null, null, null);
             }
@@ -32869,111 +33630,91 @@ func.UI.screen.execute_xu_functions = async function (SESSION_ID, is_skeleton, $
       });
       return {};
     },
+
     'xu-script': async function ($elm, val) {
-      var checkExist = setInterval(async function () {
+      const checkExist = setInterval(async function () {
         if ($elm.is(':visible')) {
           try {
-            // var res = eval('(' + val.value + ')');
-            // const fn = `(function(el) {
-            //  ${val.value}
-            //  })(document.querySelector(\`[xu-ui-id="${$elm.attr('xu-ui-id')}"]\`));`;
-
-            const fn = `async (el)=>{${val.value} };`;
-
-            var res = eval(fn);
-            await res($elm[0]);
-            // if (typeof res === 'function') {
-            //   res($elm[0]);
-            // }
+            const fn = eval(`async (el)=>{${val.value}}`);
+            await fn($elm[0]);
           } catch (e) {
             eval(val.value);
           }
-
           clearInterval(checkExist);
         }
-      }, 100); // check every 100ms
-
+      }, 100);
       return {};
     },
+
     'xu-style-global': async function ($elm, val) {
       $('head').append(`<style>${val.value}</style>`);
       return {};
     },
-    'xu-style': async function ($elm, val) {
-      var cssString = val.value;
-
-      var parser = new cssjs();
-
-      var parsed = parser.parseCSS(cssString);
-      var xuUiId = `[xu-ui-id="${$elm.attr('xu-ui-id')}"]`;
 
-      $.each(parsed, function (key, val) {
-        var selectors_arr = val.selector.split(',');
-
-        $.each(selectors_arr, function (key2, val2) {
-          selectors_arr[key2] = `${xuUiId} ${val2}, ${xuUiId}${val2}`;
-          // console.log(new_selector);
-        });
-
-        val.selector = selectors_arr.join(',');
-        // console.log(parsed);
+    'xu-style': async function ($elm, val) {
+      const parser = new cssjs();
+      const parsed = parser.parseCSS(val.value);
+      const xuUiId = `[xu-ui-id="${$elm.attr('xu-ui-id')}"]`;
+
+      parsed.forEach((rule) => {
+        rule.selector = rule.selector
+          .split(',')
+          .map((sel) => `${xuUiId} ${sel}, ${xuUiId}${sel}`)
+          .join(',');
       });
 
-      var newCSSString = parser.getCSSForEditor(parsed);
-
-      $('head').append(`<style>${newCSSString}</style>`);
+      $('head').append(`<style>${parser.getCSSForEditor(parsed)}</style>`);
       return {};
     },
+
     'xu-cdn': async function ($elm, val) {
-      for await (const [key, resource] of Object.entries(val.value)) {
+      for (const resource of Object.values(val.value)) {
         await load_cdn(resource);
       }
-
       return {};
     },
-    'xu-ui-plugin': async function ($elm, val) {
-      var _session = SESSION_OBJ[SESSION_ID];
 
-      for await (const [plugin_name, value] of Object.entries(val.value)) {
+    'xu-ui-plugin': async function ($elm, val) {
+      for (const [plugin_name, value] of Object.entries(val.value)) {
         const _plugin = APP_OBJ[_session.app_id]?.app_plugins_purchased?.[plugin_name];
-        if (_plugin?.installed && _plugin?.manifest?.['runtime.mjs']?.exist && _plugin?.manifest?.['index.mjs']?.exist && value.enabled) {
-          if (_plugin?.manifest?.['runtime.mjs'].dist && _plugin?.manifest?.['runtime.mjs']?.css) {
-            const plugin_runtime_css_url = await func.utils.get_plugin_npm_cdn(SESSION_ID, plugin_name, 'dist/runtime.css');
-            func.utils.load_css_on_demand(plugin_runtime_css_url);
-          }
 
-          const plugin_index_src = await func.utils.get_plugin_npm_cdn(SESSION_ID, plugin_name, `${_plugin.manifest['index.mjs'].dist ? 'dist/' : ''}index.mjs`);
+        if (!_plugin?.installed || !_plugin?.manifest?.['runtime.mjs']?.exist || !_plugin?.manifest?.['index.mjs']?.exist || !value.enabled) continue;
 
-          const plugin_index_resources = await import(plugin_index_src);
+        if (_plugin.manifest['runtime.mjs'].dist && _plugin.manifest['runtime.mjs'].css) {
+          const css_url = await func.utils.get_plugin_npm_cdn(SESSION_ID, plugin_name, 'dist/runtime.css');
+          func.utils.load_css_on_demand(css_url);
+        }
 
-          let properties = _.cloneDeep(plugin_index_resources.properties);
-          for await (let [prop_name, prop_val] of Object.entries(properties)) {
-            prop_val.value = value?.attributes?.[prop_name];
-            if (value?.attributes?.[`xu-exp:${prop_name}`]) {
-              const res = await func.expression.get(SESSION_ID, value?.attributes?.[`xu-exp:${prop_name}`], paramsP.dsSessionP, 'UI Attr EXP');
-              prop_val.value = res.result;
-            }
-          }
-          // $elm.data().xu_ui_plugin = { properties };
-          const plugin_runtime_src = await func.utils.get_plugin_npm_cdn(SESSION_ID, plugin_name, `${_plugin.manifest['runtime.mjs'].dist ? 'dist/' : ''}runtime.mjs`);
+        const plugin_index_src = await func.utils.get_plugin_npm_cdn(SESSION_ID, plugin_name, `${_plugin.manifest['index.mjs'].dist ? 'dist/' : ''}index.mjs`);
 
-          const plugin_runtime_resources = await import(plugin_runtime_src);
+        const plugin_index_resources = await import(plugin_index_src);
+        const properties = _.cloneDeep(plugin_index_resources.properties);
 
-          if (plugin_runtime_resources.cdn && typeof _.isArray(plugin_runtime_resources.cdn)) {
-            for await (const resource of plugin_runtime_resources.cdn) {
-              await load_cdn(resource);
-            }
+        for (const [prop_name, prop_val] of Object.entries(properties)) {
+          prop_val.value = value?.attributes?.[prop_name];
+          if (value?.attributes?.[`xu-exp:${prop_name}`]) {
+            const res = await func.expression.get(SESSION_ID, value.attributes[`xu-exp:${prop_name}`], paramsP.dsSessionP, 'UI Attr EXP');
+            prop_val.value = res.result;
           }
+        }
+
+        const plugin_runtime_src = await func.utils.get_plugin_npm_cdn(SESSION_ID, plugin_name, `${_plugin.manifest['runtime.mjs'].dist ? 'dist/' : ''}runtime.mjs`);
 
-          if (plugin_runtime_resources.fn) {
-            await plugin_runtime_resources.fn(plugin_name, $elm?.[0], properties);
-            // await plugin_runtime_resources.fn(plugin_name, $elm?.[0], $elm.data().xu_ui_plugin.properties);
+        const plugin_runtime_resources = await import(plugin_runtime_src);
+
+        if (plugin_runtime_resources.cdn && _.isArray(plugin_runtime_resources.cdn)) {
+          for (const resource of plugin_runtime_resources.cdn) {
+            await load_cdn(resource);
           }
         }
-      }
 
+        if (plugin_runtime_resources.fn) {
+          await plugin_runtime_resources.fn(plugin_name, $elm?.[0], properties);
+        }
+      }
       return {};
     },
+
     'xu-store': async function ($elm, val) {
       try {
         const fields_obj = JSON5.parse(val.value);
@@ -32985,43 +33726,135 @@ func.UI.screen.execute_xu_functions = async function (SESSION_ID, is_skeleton, $
       }
       return {};
     },
+
     'xu-viewport': async function ($elm, val) {
-      // functionality in draw_html_element
       return {};
     },
   };
 
-  if (nodeP.tagName.substr(0, 3) === 'xu-') {
+  const tag_fx = {
+    'xu-panel': {
+      program: async function ($elm, val) {
+        const init_program = async function () {
+          async function render_panel() {
+            const prog_id = val.value?.prog || val.value;
+            const params_obj = await get_params_obj_new(SESSION_ID, prog_id, nodeP, paramsP.dsSessionP);
+            const ret_panel = await func.UI.screen.init(SESSION_ID, prog_id, paramsP.screenId, _ds, $elm, null, _ds.currentRecordId, null, true, params_obj.params_res, 'initXu_panel', undefined, prog_id !== _ds.prog_id ? null : refreshed_ds, params_obj.params_raw);
+
+            const containerData = $container.data();
+            if (containerData.xuData) {
+              containerData.xuData.xuPanelProps = elmData.xuAttributes;
+              containerData.xuData.xuPanelData = ret_panel.data();
+            }
+            return { $new_div: ret_panel };
+          }
+
+          if (!val.value) val.value = '_empty_panel_program';
+          return await render_panel();
+        };
+
+        const alter_program = async function () {
+          async function render_panel() {
+            const program = val.value?.prog || val.value;
+            const $wrapper = $('<div>');
+            const $div = await func.UI.screen.create_container(SESSION_ID, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, nodeP.attributes, null, null, null, $wrapper, '');
+
+            const params_obj = await get_params_obj_new(SESSION_ID, program, nodeP, paramsP.dsSessionP);
+            const ret_init = await func.UI.screen.init(SESSION_ID, program, paramsP.screenId, _ds, $div, null, _ds.currentRecordId, jobNoP, true, params_obj.params_res, 'alterXu_panel', undefined, undefined, params_obj.params_raw);
+
+            await func.UI.screen.panel_post_render_handler(SESSION_ID, $elm, ret_init, nodeP, $div.clone(true), jobNoP);
+
+            return { $new_div: ret_init, abort: true };
+          }
+
+          if (!val.value) return { abort: true };
+          await render_panel();
+          return { abort: true };
+        };
+
+        return is_init ? await init_program() : await alter_program();
+      },
+
+      'xu-render': async function ($elm, val) {
+        return await common_fx['xu-render']($elm, val, true);
+      },
+
+      'xu-ref': async function ($elm, val) {
+        return await common_fx['xu-ref']($container, val, $container.data().xuData.xuPanelData.xuData.paramsP.dsSessionP);
+      },
+    },
+
+    'xu-teleport': {
+      to: async function ($elm, val) {
+        if (!glb.new_xu_render && val.value) {
+          if ($elm?.parent()?.data()?.xuData?.length) {
+            $elm.parent().data('xuTeleportData', []);
+            for (const [key, node] of Object.entries(nodeP.children)) {
+              const $teleport_elm = await func.UI.screen.render_ui_tree(SESSION_ID, $(val.value), node, parent_infoP, paramsP, jobNoP, is_skeleton, Number(key), null, node, null, $root_container);
+              $elm.parent().data().xuTeleportData.push($teleport_elm.attr('xu-ui-id'));
+              $teleport_elm.attr('xu-teleport-parent-id', $elm.parent().attr('xu-ui-id'));
+            }
+            $elm.remove();
+          } else {
+            $elm.data('xuTeleportData', []).attr('hidden', true);
+            for (const [key, node] of Object.entries(nodeP.children)) {
+              const $to_container = $(val.value);
+              if (!$to_container?.length) {
+                return console.error(`container ${val.value} for xuTeleportData not found`);
+              }
+              const $teleport_elm = await func.UI.screen.render_ui_tree(SESSION_ID, $to_container, node, parent_infoP, paramsP, jobNoP, is_skeleton, Number(key), null, node, null, $root_container);
+              $elm.data().xuTeleportData.push($teleport_elm.attr('xu-ui-id'));
+              $teleport_elm.attr('xu-teleport-parent-id', $elm.attr('xu-ui-id'));
+            }
+          }
+          return { abort: true };
+        }
+        return {};
+      },
+
+      'xu-render': async function ($elm, val) {
+        return await common_fx['xu-render']($elm, val, true);
+      },
+
+      'xu-show': async function ($elm, val) {
+        return await common_fx['xu-show']($elm, val, true);
+      },
+    },
+  };
+
+  // Main execution logic
+  if (isXuTag) {
     if (xu_func === 'xu-exp') {
       return common_fx[xu_func]($elm, val);
     }
 
-    if (tag_fx?.[nodeP.tagName]?.[xu_func]) {
-      let ret = await tag_fx[nodeP.tagName][xu_func]($elm, val);
-      return ret;
+    if (tag_fx?.[nodeTag]?.[xu_func]) {
+      return await tag_fx[nodeTag][xu_func]($elm, val);
     }
-    // if (xu_func !== "tree_id")
-    console.warn(`attribute ${xu_func} not found for ${nodeP.tagName}`);
-    return {};
-  }
-  if (_.isEmpty($elm.data())) {
+
+    console.warn(`attribute ${xu_func} not found for ${nodeTag}`);
     return {};
   }
-  if (!$elm.data().xuData.debug_info.attribute_stat) {
-    $elm.data().xuData.debug_info.attribute_stat = {};
+
+  if (_.isEmpty(elmData)) return {};
+
+  if (!xuData.debug_info.attribute_stat) {
+    xuData.debug_info.attribute_stat = {};
   }
+
   if (xu_func !== 'xu-exp') {
-    $elm.data().xuData.debug_info.attribute_stat[xu_func] = val.value;
+    xuData.debug_info.attribute_stat[xu_func] = val.value;
   }
+
   try {
     if (!common_fx[xu_func]) {
-      console.warn('invalid xu-tag', xu_func, error);
+      console.warn('invalid xu-tag', xu_func);
       return {};
     }
-
     return await common_fx[xu_func]($elm, val);
   } catch (error) {
-    debugger;
+    console.error('execute_xu_functions error:', error);
+    return {};
   }
 };
 
@@ -33044,62 +33877,408 @@ func.UI.screen.fix_val_defaults = function (key, val) {
   return ret;
 };
 
+// func.UI.screen.set_attributes_new = async function (SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, $elm, is_init, execute_attributes = [], refreshed_ds) {
+//   var done_exp = [];
+
+//   const _ds = SESSION_OBJ[SESSION_ID].DS_GLB[paramsP.dsSessionP];
+//   if (!_ds) return { abort: true };
+
+//   const get_attr_value = async function (key) {
+//     let ret = func.UI.screen.fix_val_defaults(key, nodeP.attributes[key]);
+//     if (nodeP?.attributes?.hasOwnProperty(`xu-exp:${key}`)) {
+//       ret = await get_xuExp(key);
+//     }
+//     return ret;
+//   };
+
+//   const get_xuExp = async function (attrib) {
+//     if (is_skeleton) return;
+//     if (glb.new_xu_render) {
+//       let _xuData = $elm.data().xuData;
+//       if (!_xuData.attr_exp_info) {
+//         _xuData.attr_exp_info = {};
+//       }
+//     }
+//     const attr = `xu-exp:${attrib}`;
+
+//     if (!nodeP?.attributes?.hasOwnProperty(attr)) return;
+//     // const attr = `xu-exp-${attrib}`;
+//     var exp = nodeP.attributes[attr];
+//     // if (!value) return func.UI.screen.fix_val_defaults(attrib, exp || nodeP.attributes[attrib]);
+
+//     var res = await func.expression.get(SESSION_ID, exp, paramsP.dsSessionP, 'UI Attr EXP', _ds.currentRecordId);
+//     if (glb.new_xu_render) {
+//       _xuData.attr_exp_info[attrib] = res;
+//     }
+//     // nodeP.attributes[attr] = value; //{ value: value, res: res };
+//     done_exp.push(attr);
+//     return res.result; //func.UI.screen.fix_val_defaults(attrib, res.result);
+//   };
+
+//   var _ret = {};
+//   if (nodeP.type !== 'element' || !nodeP.attributes) return _ret;
+
+//   for (let [key, val] of Object.entries(nodeP.attributes)) {
+//     // REMOVE STATIC ATTRIBUTES IF EXP EXISTS to avoid dup
+//     if (key.substring(0, 6) === 'xu-exp') {
+//       if (_.isEmpty(val)) {
+//         delete nodeP.attributes[key];
+//         continue;
+//       }
+//       const clean_key = key.split(':')[1];
+//       if (typeof nodeP.attributes[clean_key] !== 'undefined') {
+//         delete nodeP.attributes[clean_key];
+//       }
+//     }
+//     // FIX abbreviations
+//     if (glb.attr_abbreviations_arr.includes(key)) {
+//       nodeP.attributes[`xu-on:${key.substring(3)}`] = [
+//         {
+//           handler: 'custom',
+//           props: {},
+//           event: [
+//             {
+//               id: Date.now(),
+//               data: {
+//                 action: 'update',
+//                 name: { value: val },
+//                 enabled: true,
+//               },
+//               props: {},
+//             },
+//           ],
+//         },
+//       ];
+//       delete nodeP.attributes[key];
+//     }
+//   }
+
+//   for (let [key, val] of Object.entries(nodeP.attributes)) {
+//     // FIX STATIC DEFAULTS
+//     val = func.UI.screen.fix_val_defaults(key, val);
+
+//     // REMOVE UNDEFINED or NULL ATTRIBUTES
+//     if (typeof val === 'undefined' || val === null) {
+//       delete nodeP.attributes[key];
+//     }
+
+//     // REMOVE ATTRIBUTES WITH EMPTY VALUES
+//     if (glb.solid_attributes.includes(key) && !val) {
+//       delete nodeP.attributes[key];
+//     }
+//   }
+
+//   // XU-ATTRS
+//   if (nodeP?.attributes?.['xu-attrs'] || nodeP?.attributes?.['xu-exp:xu-attrs']) {
+//     const attr = 'xu-attrs';
+//     let ret = await func.UI.screen.execute_xu_functions(
+//       SESSION_ID,
+//       is_skeleton,
+//       $root_container,
+//       nodeP,
+//       $container,
+//       paramsP,
+//       parent_infoP,
+//       jobNoP,
+//       keyP,
+//       parent_nodeP,
+//       attr,
+//       $elm,
+//       {
+//         key: attr,
+//         value: await get_attr_value(attr),
+//       },
+//       is_init,
+//     );
+//   }
+
+//   // BEFORE
+//   if (!_.isEmpty(nodeP.attributes)) {
+//     for await (const [key, attr] of Object.entries(glb.run_xu_before)) {
+//       if (_ret.abort || $container?.data()?.xuData?.pending_to_delete) break;
+//       if (glb.html5_events_handler.includes(attr) || execute_attributes.includes(attr)) {
+//         continue;
+//       }
+
+//       if (!nodeP?.attributes?.hasOwnProperty(attr) && !nodeP?.attributes?.hasOwnProperty(`xu-exp:${attr}`)) {
+//         continue;
+//       }
+
+//       if (!nodeP.attributes[`xu-exp:${attr}`] && nodeP?.attributes?.hasOwnProperty(attr) && typeof func.UI.screen.fix_val_defaults(attr, nodeP.attributes[attr]) === 'undefined') {
+//         continue;
+//       }
+
+//       let ret = await func.UI.screen.execute_xu_functions(
+//         SESSION_ID,
+//         is_skeleton,
+//         $root_container,
+//         nodeP,
+//         $container,
+//         paramsP,
+//         parent_infoP,
+//         jobNoP,
+//         keyP,
+//         parent_nodeP,
+//         attr,
+//         $elm,
+//         {
+//           key: attr,
+
+//           value: await get_attr_value(attr),
+//         },
+//         is_init,
+//       );
+//       _ret = _.assignIn(_ret, ret);
+//     }
+//   }
+
+//   // ALL
+
+//   for await (const [key, val] of Object.entries(nodeP.attributes)) {
+//     if (_ret.abort || $container?.data()?.xuData?.pending_to_delete) break;
+//     if (glb.html5_events_handler.includes(key) || execute_attributes.includes(key)) {
+//       continue;
+//     }
+
+//     const new_key = key.split(':')[0]; // break expression
+//     if (
+//       nodeP.tagName !== 'xu-panel' &&
+//       nodeP.tagName !== 'xu-teleport' && //  nodeP.tagName.substr(0, 3) !== "xu-" &&
+//       (new_key.substr(0, 2) !== 'xu' || new_key.substr(2, 1) !== '-')
+//     ) {
+//       // handle common html attributes
+//       try {
+//         $elm.get(0).setAttribute(key, val);
+//       } catch (err) {
+//         console.error(err.message);
+//       }
+
+//       continue;
+//     }
+//     // handle xu attributes
+//     try {
+//       if ($elm?.data()?.xuAttributes) {
+//         // in some cases xu data delete in purpose when refreshing the screen
+//         $elm.data().xuAttributes[key] = val;
+//       }
+//     } catch (error) {
+//       debugger;
+//       console.error(error);
+//     }
+
+//     if (new_key === 'xu-exp' || nodeP.attributes['xu-exp:' + new_key] || glb.run_xu_before.includes(new_key) || glb.run_xu_after.includes(new_key)) {
+//       continue;
+//     }
+
+//     if (new_key === 'xu-on') {
+//       let ret = await func.UI.screen.execute_xu_functions(
+//         SESSION_ID,
+//         is_skeleton,
+//         $root_container,
+//         nodeP,
+//         $container,
+//         paramsP,
+//         parent_infoP,
+//         jobNoP,
+//         keyP,
+//         parent_nodeP,
+//         'xu-on',
+//         $elm,
+//         {
+//           key: key,
+//           // value: (await get_xuExp(new_key)) || func.UI.screen.fix_val_defaults(key, val),
+//           value: await get_attr_value(key),
+//         },
+//         is_init,
+//         refreshed_ds,
+//       );
+//       _ret = _.assignIn(_ret, ret);
+//       continue;
+//     }
+
+//     let ret = await func.UI.screen.execute_xu_functions(
+//       SESSION_ID,
+//       is_skeleton,
+//       $root_container,
+//       nodeP,
+//       $container,
+//       paramsP,
+//       parent_infoP,
+//       jobNoP,
+//       keyP,
+//       parent_nodeP,
+//       new_key,
+//       $elm,
+//       {
+//         key: key,
+//         // value: (await get_xuExp(new_key)) || func.UI.screen.fix_val_defaults(key, val),
+//         value: await get_attr_value(key),
+//       },
+//       is_init,
+//       refreshed_ds,
+//     );
+
+//     _ret = _.assignIn(_ret, ret);
+//   }
+
+//   // EXP for
+
+//   for await (const [key, val] of Object.entries(nodeP.attributes)) {
+//     if (_ret.abort || $container?.data()?.xuData?.pending_to_delete) break;
+
+//     const attr = key.split('xu-exp:')[1];
+
+//     if (!attr) {
+//       continue;
+//     }
+
+//     if (glb.html5_events_handler.includes(attr) || execute_attributes.includes(attr)) continue;
+
+//     if (done_exp.includes(key)) {
+//       continue;
+//     }
+//     let ret = await func.UI.screen.execute_xu_functions(
+//       SESSION_ID,
+//       is_skeleton,
+//       $root_container,
+//       nodeP,
+//       $container,
+//       paramsP,
+//       parent_infoP,
+//       jobNoP,
+//       keyP,
+//       parent_nodeP,
+//       'xu-exp',
+//       $elm,
+//       {
+//         key: attr,
+//         value: val,
+//       },
+//       true,
+//       refreshed_ds,
+//     );
+//     _ret = _.assignIn(_ret, ret);
+//   }
+
+//   // AFTER
+
+//   for await (const [key, attr] of Object.entries(glb.run_xu_after)) {
+//     if ($container?.data()?.xuData?.pending_to_delete) break;
+
+//     if (glb.html5_events_handler.includes(attr) || execute_attributes.includes(attr)) continue;
+
+//     if (!nodeP.attributes || !nodeP.attributes[attr] & !nodeP.attributes[`xu-exp:${attr}`]) continue;
+
+//     let ret = await func.UI.screen.execute_xu_functions(
+//       SESSION_ID,
+//       is_skeleton,
+//       $root_container,
+//       nodeP,
+//       $container,
+//       paramsP,
+//       parent_infoP,
+//       jobNoP,
+//       keyP,
+//       parent_nodeP,
+//       attr,
+//       $elm,
+//       {
+//         key: attr,
+//         // value: (await get_xuExp(attr)) || func.UI.screen.fix_val_defaults(attr, nodeP.attributes[attr]),
+//         value: await get_attr_value(attr),
+//       },
+//       is_init,
+//       refreshed_ds,
+//     );
+//     _ret = _.assignIn(_ret, ret);
+//   }
+
+//   // REGISTER EVENTS ATTRIBUTES
+
+//   for await (const [key, val] of Object.entries(nodeP.attributes)) {
+//     if ($container?.data()?.xuData?.pending_to_delete) break;
+//     if (!glb.html5_events_handler.includes(key)) break;
+//     // $elm.attr(key, await get_xuExp(key)) || val;
+//     $elm.attr(key, await get_xuExp(key)) || val;
+//   }
+
+//   return _ret;
+// };
+
 func.UI.screen.set_attributes_new = async function (SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, $elm, is_init, execute_attributes = [], refreshed_ds) {
-  var done_exp = [];
+  const done_exp = new Set(); // Use Set for O(1) lookups instead of array
 
   const _ds = SESSION_OBJ[SESSION_ID].DS_GLB[paramsP.dsSessionP];
   if (!_ds) return { abort: true };
 
+  // Early return if not an element or no attributes
+  if (nodeP.type !== 'element' || !nodeP.attributes) return {};
+
+  // Cache frequently accessed values
+  const nodeAttrs = nodeP.attributes;
+  const elmData = $elm.data();
+  const xuData = elmData.xuData;
+  const containerData = $container?.data();
+  const containerXuData = containerData?.xuData;
+
   const get_attr_value = async function (key) {
-    let ret = func.UI.screen.fix_val_defaults(key, nodeP.attributes[key]);
-    if (nodeP?.attributes?.hasOwnProperty(`xu-exp:${key}`)) {
-      ret = await get_xuExp(key);
+    const expKey = `xu-exp:${key}`;
+    if (nodeAttrs.hasOwnProperty(expKey)) {
+      return await get_xuExp(key);
     }
-    return ret;
+    return func.UI.screen.fix_val_defaults(key, nodeAttrs[key]);
   };
 
   const get_xuExp = async function (attrib) {
     if (is_skeleton) return;
+
+    const attr = `xu-exp:${attrib}`;
+    if (!nodeAttrs.hasOwnProperty(attr)) return;
+
     if (glb.new_xu_render) {
-      let _xuData = $elm.data().xuData;
-      if (!_xuData.attr_exp_info) {
-        _xuData.attr_exp_info = {};
+      if (!xuData.attr_exp_info) {
+        xuData.attr_exp_info = {};
       }
     }
-    const attr = `xu-exp:${attrib}`;
 
-    if (!nodeP?.attributes?.hasOwnProperty(attr)) return;
-    // const attr = `xu-exp-${attrib}`;
-    var exp = nodeP.attributes[attr];
-    // if (!value) return func.UI.screen.fix_val_defaults(attrib, exp || nodeP.attributes[attrib]);
+    const exp = nodeAttrs[attr];
+    const res = await func.expression.get(SESSION_ID, exp, paramsP.dsSessionP, 'UI Attr EXP', _ds.currentRecordId);
 
-    var res = await func.expression.get(SESSION_ID, exp, paramsP.dsSessionP, 'UI Attr EXP', _ds.currentRecordId);
     if (glb.new_xu_render) {
-      _xuData.attr_exp_info[attrib] = res;
+      xuData.attr_exp_info[attrib] = res;
     }
-    // nodeP.attributes[attr] = value; //{ value: value, res: res };
-    done_exp.push(attr);
-    return res.result; //func.UI.screen.fix_val_defaults(attrib, res.result);
-  };
 
-  var _ret = {};
-  if (nodeP.type !== 'element' || !nodeP.attributes) return _ret;
+    done_exp.add(attr);
+    return res.result;
+  };
 
-  for (let [key, val] of Object.entries(nodeP.attributes)) {
-    // REMOVE STATIC ATTRIBUTES IF EXP EXISTS to avoid dup
-    if (key.substring(0, 6) === 'xu-exp') {
+  // Create Sets for O(1) lookups
+  const html5EventsSet = new Set(glb.html5_events_handler);
+  const executeAttrsSet = new Set(execute_attributes);
+  const solidAttrsSet = new Set(glb.solid_attributes);
+  const abbreviationsSet = new Set(glb.attr_abbreviations_arr);
+  const runXuBeforeSet = new Set(Object.values(glb.run_xu_before));
+  const runXuAfterSet = new Set(Object.values(glb.run_xu_after));
+
+  // Process attributes in a single pass where possible
+  const attrsToDelete = [];
+  const xuOnAttrs = {};
+
+  for (const [key, val] of Object.entries(nodeAttrs)) {
+    // Handle xu-exp attributes
+    if (key.startsWith('xu-exp:')) {
       if (_.isEmpty(val)) {
-        delete nodeP.attributes[key];
+        attrsToDelete.push(key);
         continue;
       }
-      const clean_key = key.split(':')[1];
-      if (typeof nodeP.attributes[clean_key] !== 'undefined') {
-        delete nodeP.attributes[clean_key];
+      const clean_key = key.slice(7); // 'xu-exp:'.length = 7
+      if (nodeAttrs[clean_key] !== undefined) {
+        attrsToDelete.push(clean_key);
       }
     }
-    // FIX abbreviations
-    if (glb.attr_abbreviations_arr.includes(key)) {
-      nodeP.attributes[`xu-on:${key.substring(3)}`] = [
+    // Handle abbreviations
+    else if (abbreviationsSet.has(key)) {
+      xuOnAttrs[`xu-on:${key.slice(3)}`] = [
         {
           handler: 'custom',
           props: {},
@@ -33116,257 +34295,131 @@ func.UI.screen.set_attributes_new = async function (SESSION_ID, is_skeleton, $ro
           ],
         },
       ];
-      delete nodeP.attributes[key];
+      attrsToDelete.push(key);
     }
   }
 
-  for (let [key, val] of Object.entries(nodeP.attributes)) {
-    // FIX STATIC DEFAULTS
-    val = func.UI.screen.fix_val_defaults(key, val);
+  // Delete marked attributes
+  for (const key of attrsToDelete) {
+    delete nodeAttrs[key];
+  }
 
-    // REMOVE UNDEFINED or NULL ATTRIBUTES
-    if (typeof val === 'undefined' || val === null) {
-      delete nodeP.attributes[key];
-    }
+  // Add xu-on attributes
+  Object.assign(nodeAttrs, xuOnAttrs);
 
-    // REMOVE ATTRIBUTES WITH EMPTY VALUES
-    if (glb.solid_attributes.includes(key) && !val) {
-      delete nodeP.attributes[key];
+  // Clean up attributes
+  for (const [key, val] of Object.entries(nodeAttrs)) {
+    const fixedVal = func.UI.screen.fix_val_defaults(key, val);
+
+    if (fixedVal === undefined || fixedVal === null) {
+      delete nodeAttrs[key];
+    } else if (solidAttrsSet.has(key) && !fixedVal) {
+      delete nodeAttrs[key];
+    } else {
+      nodeAttrs[key] = fixedVal;
     }
   }
 
+  const _ret = {};
+
+  // Helper to check abort condition
+  const shouldAbort = () => _ret.abort || containerXuData?.pending_to_delete;
+
   // XU-ATTRS
-  if (nodeP?.attributes?.['xu-attrs'] || nodeP?.attributes?.['xu-exp:xu-attrs']) {
+  if (nodeAttrs['xu-attrs'] || nodeAttrs['xu-exp:xu-attrs']) {
     const attr = 'xu-attrs';
-    let ret = await func.UI.screen.execute_xu_functions(
-      SESSION_ID,
-      is_skeleton,
-      $root_container,
-      nodeP,
-      $container,
-      paramsP,
-      parent_infoP,
-      jobNoP,
-      keyP,
-      parent_nodeP,
-      attr,
-      $elm,
-      {
-        key: attr,
-        value: await get_attr_value(attr),
-      },
-      is_init,
-    );
+    await func.UI.screen.execute_xu_functions(SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, attr, $elm, { key: attr, value: await get_attr_value(attr) }, is_init);
   }
 
   // BEFORE
-  if (!_.isEmpty(nodeP.attributes)) {
-    for await (const [key, attr] of Object.entries(glb.run_xu_before)) {
-      if (_ret.abort || $container?.data()?.xuData?.pending_to_delete) break;
-      if (glb.html5_events_handler.includes(attr) || execute_attributes.includes(attr)) {
-        continue;
-      }
-
-      if (!nodeP?.attributes?.hasOwnProperty(attr) && !nodeP?.attributes?.hasOwnProperty(`xu-exp:${attr}`)) {
-        continue;
-      }
+  if (!_.isEmpty(nodeAttrs)) {
+    for (const [key, attr] of Object.entries(glb.run_xu_before)) {
+      if (shouldAbort()) break;
+      if (html5EventsSet.has(attr) || executeAttrsSet.has(attr)) continue;
 
-      if (!nodeP.attributes[`xu-exp:${attr}`] && nodeP?.attributes?.hasOwnProperty(attr) && typeof func.UI.screen.fix_val_defaults(attr, nodeP.attributes[attr]) === 'undefined') {
-        continue;
-      }
-
-      let ret = await func.UI.screen.execute_xu_functions(
-        SESSION_ID,
-        is_skeleton,
-        $root_container,
-        nodeP,
-        $container,
-        paramsP,
-        parent_infoP,
-        jobNoP,
-        keyP,
-        parent_nodeP,
-        attr,
-        $elm,
-        {
-          key: attr,
+      const expKey = `xu-exp:${attr}`;
+      if (!nodeAttrs.hasOwnProperty(attr) && !nodeAttrs.hasOwnProperty(expKey)) continue;
+      if (!nodeAttrs[expKey] && nodeAttrs.hasOwnProperty(attr) && func.UI.screen.fix_val_defaults(attr, nodeAttrs[attr]) === undefined) continue;
 
-          value: await get_attr_value(attr),
-        },
-        is_init,
-      );
-      _ret = _.assignIn(_ret, ret);
+      const ret = await func.UI.screen.execute_xu_functions(SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, attr, $elm, { key: attr, value: await get_attr_value(attr) }, is_init);
+      Object.assign(_ret, ret);
     }
   }
 
-  // ALL
+  // ALL - Process attributes
+  const isXuPanel = nodeP.tagName === 'xu-panel';
+  const isXuTeleport = nodeP.tagName === 'xu-teleport';
+  const elmElement = $elm.get(0);
 
-  for await (const [key, val] of Object.entries(nodeP.attributes)) {
-    if (_ret.abort || $container?.data()?.xuData?.pending_to_delete) break;
-    if (glb.html5_events_handler.includes(key) || execute_attributes.includes(key)) {
-      continue;
-    }
+  for (const [key, val] of Object.entries(nodeAttrs)) {
+    if (shouldAbort()) break;
+    if (html5EventsSet.has(key) || executeAttrsSet.has(key)) continue;
 
-    const new_key = key.split(':')[0]; // break expression
-    if (
-      nodeP.tagName !== 'xu-panel' &&
-      nodeP.tagName !== 'xu-teleport' && //  nodeP.tagName.substr(0, 3) !== "xu-" &&
-      (new_key.substr(0, 2) !== 'xu' || new_key.substr(2, 1) !== '-')
-    ) {
-      // handle common html attributes
+    const colonIndex = key.indexOf(':');
+    const new_key = colonIndex > -1 ? key.slice(0, colonIndex) : key;
+
+    if (!isXuPanel && !isXuTeleport && (!new_key.startsWith('xu-') || new_key.length < 3 || new_key[2] !== '-')) {
       try {
-        $elm.get(0).setAttribute(key, val);
+        elmElement.setAttribute(key, val);
       } catch (err) {
         console.error(err.message);
       }
-
       continue;
     }
-    // handle xu attributes
-    try {
-      if ($elm?.data()?.xuAttributes) {
-        // in some cases xu data delete in purpose when refreshing the screen
-        $elm.data().xuAttributes[key] = val;
-      }
-    } catch (error) {
-      debugger;
-      console.error(error);
+
+    // Store xu attributes
+    if (elmData.xuAttributes) {
+      elmData.xuAttributes[key] = val;
     }
 
-    if (new_key === 'xu-exp' || nodeP.attributes['xu-exp:' + new_key] || glb.run_xu_before.includes(new_key) || glb.run_xu_after.includes(new_key)) {
+    const expKey = `xu-exp:${new_key}`;
+    if (new_key === 'xu-exp' || nodeAttrs[expKey] || runXuBeforeSet.has(new_key) || runXuAfterSet.has(new_key)) {
       continue;
     }
 
     if (new_key === 'xu-on') {
-      let ret = await func.UI.screen.execute_xu_functions(
-        SESSION_ID,
-        is_skeleton,
-        $root_container,
-        nodeP,
-        $container,
-        paramsP,
-        parent_infoP,
-        jobNoP,
-        keyP,
-        parent_nodeP,
-        'xu-on',
-        $elm,
-        {
-          key: key,
-          // value: (await get_xuExp(new_key)) || func.UI.screen.fix_val_defaults(key, val),
-          value: await get_attr_value(key),
-        },
-        is_init,
-        refreshed_ds,
-      );
-      _ret = _.assignIn(_ret, ret);
+      const ret = await func.UI.screen.execute_xu_functions(SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, 'xu-on', $elm, { key: key, value: await get_attr_value(key) }, is_init, refreshed_ds);
+      Object.assign(_ret, ret);
       continue;
     }
 
-    let ret = await func.UI.screen.execute_xu_functions(
-      SESSION_ID,
-      is_skeleton,
-      $root_container,
-      nodeP,
-      $container,
-      paramsP,
-      parent_infoP,
-      jobNoP,
-      keyP,
-      parent_nodeP,
-      new_key,
-      $elm,
-      {
-        key: key,
-        // value: (await get_xuExp(new_key)) || func.UI.screen.fix_val_defaults(key, val),
-        value: await get_attr_value(key),
-      },
-      is_init,
-      refreshed_ds,
-    );
-
-    _ret = _.assignIn(_ret, ret);
+    const ret = await func.UI.screen.execute_xu_functions(SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, new_key, $elm, { key: key, value: await get_attr_value(key) }, is_init, refreshed_ds);
+    Object.assign(_ret, ret);
   }
 
-  // EXP for
-
-  for await (const [key, val] of Object.entries(nodeP.attributes)) {
-    if (_ret.abort || $container?.data()?.xuData?.pending_to_delete) break;
-
-    const attr = key.split('xu-exp:')[1];
+  // EXP - Process expressions
+  for (const [key, val] of Object.entries(nodeAttrs)) {
+    if (shouldAbort()) break;
 
-    if (!attr) {
-      continue;
-    }
+    if (!key.startsWith('xu-exp:')) continue;
+    const attr = key.slice(7);
 
-    if (glb.html5_events_handler.includes(attr) || execute_attributes.includes(attr)) continue;
+    if (html5EventsSet.has(attr) || executeAttrsSet.has(attr)) continue;
+    if (done_exp.has(key)) continue;
 
-    if (done_exp.includes(key)) {
-      continue;
-    }
-    let ret = await func.UI.screen.execute_xu_functions(
-      SESSION_ID,
-      is_skeleton,
-      $root_container,
-      nodeP,
-      $container,
-      paramsP,
-      parent_infoP,
-      jobNoP,
-      keyP,
-      parent_nodeP,
-      'xu-exp',
-      $elm,
-      {
-        key: attr,
-        value: val,
-      },
-      true,
-      refreshed_ds,
-    );
-    _ret = _.assignIn(_ret, ret);
+    const ret = await func.UI.screen.execute_xu_functions(SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, 'xu-exp', $elm, { key: attr, value: val }, true, refreshed_ds);
+    Object.assign(_ret, ret);
   }
 
   // AFTER
+  for (const [key, attr] of Object.entries(glb.run_xu_after)) {
+    if (containerXuData?.pending_to_delete) break;
+    if (html5EventsSet.has(attr) || executeAttrsSet.has(attr)) continue;
 
-  for await (const [key, attr] of Object.entries(glb.run_xu_after)) {
-    if ($container?.data()?.xuData?.pending_to_delete) break;
-
-    if (glb.html5_events_handler.includes(attr) || execute_attributes.includes(attr)) continue;
+    const expKey = `xu-exp:${attr}`;
+    if (!nodeAttrs || (!nodeAttrs[attr] && !nodeAttrs[expKey])) continue;
 
-    if (!nodeP.attributes || !nodeP.attributes[attr] & !nodeP.attributes[`xu-exp:${attr}`]) continue;
-
-    let ret = await func.UI.screen.execute_xu_functions(
-      SESSION_ID,
-      is_skeleton,
-      $root_container,
-      nodeP,
-      $container,
-      paramsP,
-      parent_infoP,
-      jobNoP,
-      keyP,
-      parent_nodeP,
-      attr,
-      $elm,
-      {
-        key: attr,
-        // value: (await get_xuExp(attr)) || func.UI.screen.fix_val_defaults(attr, nodeP.attributes[attr]),
-        value: await get_attr_value(attr),
-      },
-      is_init,
-      refreshed_ds,
-    );
-    _ret = _.assignIn(_ret, ret);
+    const ret = await func.UI.screen.execute_xu_functions(SESSION_ID, is_skeleton, $root_container, nodeP, $container, paramsP, parent_infoP, jobNoP, keyP, parent_nodeP, attr, $elm, { key: attr, value: await get_attr_value(attr) }, is_init, refreshed_ds);
+    Object.assign(_ret, ret);
   }
 
   // REGISTER EVENTS ATTRIBUTES
+  for (const [key, val] of Object.entries(nodeAttrs)) {
+    if (containerXuData?.pending_to_delete) break;
+    if (!html5EventsSet.has(key)) break;
 
-  for await (const [key, val] of Object.entries(nodeP.attributes)) {
-    if ($container?.data()?.xuData?.pending_to_delete) break;
-    if (!glb.html5_events_handler.includes(key)) break;
-    // $elm.attr(key, await get_xuExp(key)) || val;
-    $elm.attr(key, await get_xuExp(key)) || val;
+    const expVal = await get_xuExp(key);
+    $elm.attr(key, expVal || val);
   }
 
   return _ret;