@xuda.io/runtime-bundle 1.0.1412 → 1.0.1414

package/js/xuda-runtime-slim.min.es.js

@@ -2188,7 +2188,7 @@ func.runtime.bind.build_datasource_changes = function (dsSessionP, currentRecord
     },
   };
 };
-func.runtime.bind.resolve_field = async function (SESSION_ID, prog_id, dsSessionP, field_id) {
+func.runtime.bind.resolve_field = async function (SESSION_ID, prog_id, dsSessionP, field_id, iterate_info) {
   let _prog_id = prog_id;
   let _dsP = dsSessionP;
   let is_dynamic_field = false;
@@ -2204,7 +2204,20 @@ func.runtime.bind.resolve_field = async function (SESSION_ID, prog_id, dsSession
 
   if (['_FOR_VAL', '_FOR_KEY'].includes(field_id)) {
     is_dynamic_field = true;
-    field_prop = SESSION_OBJ[SESSION_ID]?.DS_GLB?.[_dsP]?.dynamic_fields?.[field_id];
+    if (iterate_info && (iterate_info.iterator_val === field_id || iterate_info.iterator_key === field_id)) {
+      const iter_value = iterate_info.iterator_val === field_id ? iterate_info._val : iterate_info._key;
+      const toType = function (obj) {
+        return {}.toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase();
+      };
+      field_prop = {
+        id: field_id,
+        data: { type: 'virtual', field_id },
+        props: { fieldType: typeof iter_value !== 'undefined' ? toType(iter_value) : 'string' },
+        value: iter_value,
+      };
+    } else {
+      field_prop = SESSION_OBJ[SESSION_ID]?.DS_GLB?.[_dsP]?.dynamic_fields?.[field_id];
+    }
   } else {
     field_prop = await find_in_view(field_id, _prog_id);
     if (!field_prop) {
@@ -2288,7 +2301,7 @@ func.runtime.bind.update_reference_source_array = async function (options) {
   if (field_type === 'object' && options.val_is_reference_field) {
     let obj_item = new_arr[arr_idx];
     let e_exp = options.expression_value.replace(options.bind_field_id, 'obj_item');
-    eval(e_exp + (options.input_field_type === 'string' ? `="${options.value}"` : `=${options.value}`));
+    eval(e_exp + `=${JSON.stringify(options.value)}`);
     new_arr[arr_idx] = obj_item;
   } else {
     new_arr[arr_idx] = options.value;
@@ -4282,6 +4295,23 @@ func.datasource.execute = async function (SESSION_ID, dataSourceSession, IS_DATA
   let prog_obj = await func.utils.VIEWS_OBJ.get(SESSION_ID, _ds.prog_id);
 
   const callback_datasource = async function () {
+    const run_on_load_events = async function () {
+      if (!(await func.datasource.get_view_events_count(SESSION_ID, dataSourceSession, 'on_load'))) {
+        return false;
+      }
+      await func.datasource.execute_view_events(SESSION_ID, dataSourceSession, 'on_load');
+      return true;
+    };
+    const schedule_panel_on_load_events = function () {
+      setTimeout(async function () {
+        try {
+          await run_on_load_events();
+        } catch (error) {
+          console.error(error);
+        }
+      }, 0);
+    };
+
     if (typeof IS_WORKER === 'undefined' && typeof IS_DOCKER === 'undefined' && typeof IS_PROCESS_SERVER === 'undefined' && _ds.viewSourceProp === 'globals') {
       if (!['main'].includes(_session.opt.app_computing_mode)) {
         await func.index.call_worker(SESSION_ID, {
@@ -4291,10 +4321,13 @@ func.datasource.execute = async function (SESSION_ID, dataSourceSession, IS_DATA
       }
     }
 
-    if (await func.datasource.get_view_events_count(SESSION_ID, dataSourceSession, 'on_load')) {
-      await func.datasource.execute_view_events(SESSION_ID, dataSourceSession, 'on_load');
+    if (args.is_panelP) {
+      const callback_ret = await func.datasource.callback(SESSION_ID, dataSourceSession, args.rowIdP, args.jobNoP, _ds.prog_id);
+      schedule_panel_on_load_events();
+      return callback_ret;
     }
-    // }
+
+    await run_on_load_events();
     return await func.datasource.callback(SESSION_ID, dataSourceSession, args.rowIdP, args.jobNoP, _ds.prog_id);
   };
 
@@ -5832,6 +5865,7 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
           dsSession_changed: findMin(datasource_changed),
           avoid_xu_for_refresh,
           trigger,
+          ignore_screen_blocker: true,
         });
         // await removed from the below function cause to dead lock Mar 3 25
         await func.runtime.ui.refresh_screen({
@@ -10131,7 +10165,7 @@ func.UI.utils.get_panels_wrapper_from_dom = async function (SESSION_ID, $xu_embe
     const panel_keys = Object.keys(refresh_state?.panel_wrappers_cache || {});
     for (let index = 0; index < panel_keys.length; index++) {
       const panel_entry = refresh_state.panel_wrappers_cache[panel_keys[index]];
-      if (!$panel_entry?.$panel_div?.length || !$panel_entry.$panel_div[0]?.isConnected) {
+      if (!panel_entry?.$panel_div?.length || !panel_entry.$panel_div[0]?.isConnected) {
         requires_rebuild = true;
         break;
       }
@@ -10584,15 +10618,52 @@ func.UI.worker.init = async function (SESSION_ID) {
     return elementBottom > viewportTop && elementTop < viewportBottom;
   };
 
-  const job_iterator = async function (run_mode = 'data') {
-    const contains_job_element = function ($parent, $child) {
-      const parent_node = $parent?.[0];
-      const child_node = $child?.[0];
-      if (!parent_node || !child_node) {
-        return false;
+  if (!UI_WORKER_OBJ.in_flight_job_elements) {
+    UI_WORKER_OBJ.in_flight_job_elements = [];
+  }
+
+  const contains_job_element = function ($parent, $child) {
+    const parent_node = $parent?.[0];
+    const child_node = $child?.[0];
+    if (!parent_node || !child_node) {
+      return false;
+    }
+    return parent_node.contains(child_node);
+  };
+
+  // Cancel in-flight child jobs when a parent element is being removed/hidden.
+  // This prevents orphaned jobs whose DOM elements no longer exist.
+  func.UI.worker.cancel_child_in_flight_jobs = function ($parent_element) {
+    if (!$parent_element?.length || !UI_WORKER_OBJ.in_flight_job_elements.length) return;
+    const parent_node = $parent_element[0];
+    if (!parent_node) return;
+    for (let i = UI_WORKER_OBJ.in_flight_job_elements.length - 1; i >= 0; i--) {
+      const child_el = UI_WORKER_OBJ.in_flight_job_elements[i];
+      const child_node = child_el?.[0];
+      if (child_node && parent_node.contains(child_node)) {
+        UI_WORKER_OBJ.in_flight_job_elements.splice(i, 1);
       }
-      return parent_node.contains(child_node);
-    };
+    }
+  };
+
+  const overlaps_any_in_flight = function (job) {
+    if (!job?.elementP) {
+      return false;
+    }
+    for (let index = 0; index < UI_WORKER_OBJ.in_flight_job_elements.length; index++) {
+      const active_el = UI_WORKER_OBJ.in_flight_job_elements[index];
+      if (!active_el) continue;
+      // Block only when the new job is a CHILD of an in-flight element.
+      // If the new job is a PARENT of an in-flight element, allow it to run
+      // (e.g. xu-render hiding a container while a child panel's on_load is still running).
+      if (contains_job_element(active_el, job.elementP)) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  const job_iterator = async function (run_mode = 'data') {
     const mark_pending_delete_on_descendants = function ($element) {
       if (!$element?.length) {
         return;
@@ -10611,6 +10682,7 @@ func.UI.worker.init = async function (SESSION_ID) {
     };
     const dom_job_budget = run_mode === 'dom' ? UI_WORKER_OBJ.dom_jobs_per_frame : Number.POSITIVE_INFINITY;
     let dom_jobs_processed = 0;
+    const dispatched_jobs = [];
 
     if (UI_WORKER_OBJ.active_jobs_count) {
       func.UI.worker.idle = 0;
@@ -10624,9 +10696,15 @@ func.UI.worker.init = async function (SESSION_ID) {
 
           if (run_mode === 'data' && job_lane !== 'data') continue;
           if (job_lane === 'dom' && dom_jobs_processed >= dom_job_budget) continue;
+          // skip jobs whose element overlaps with any currently in-flight job (parent/child)
+          // sibling containers can run in parallel
+          if (overlaps_any_in_flight(val)) continue;
 
           if (!val.elementP) {
-            await func.UI.worker.execute(val.SESSION_ID, val);
+            const job_promise = func.UI.worker.execute(val.SESSION_ID, val).catch(function (err) {
+              console.error(err);
+            });
+            dispatched_jobs.push(job_promise);
             if (job_lane === 'dom') {
               dom_jobs_processed++;
             }
@@ -10646,67 +10724,48 @@ func.UI.worker.init = async function (SESSION_ID) {
               continue;
             }
 
-            // abort - if active job element exist in the current job ui (parent element changed)
+            // keep overlapping parent/child jobs serialized; siblings can run in-flight together
             if (contains_job_element(val.elementP, running_job_obj.elementP)) {
-              if (val.functionP === 'execute_xu_render_attributes') {
-                mark_pending_delete_on_descendants(val.elementP);
-                func.UI.worker.mark_pending_delete_session(SESSION_ID);
-                await func.UI.worker.delete_job(SESSION_ID, running_job_obj.job_num);
-                break;
-              }
+              continue;
             }
           }
 
-          // execute - if active job element not exist the current job ui and not detected as parent element
-          await func.UI.worker.execute(val.SESSION_ID, val);
+          // Track this element as in-flight so future schedule_run passes skip overlapping jobs
+          const in_flight_entry = val.elementP;
+          UI_WORKER_OBJ.in_flight_job_elements.push(in_flight_entry);
+
+          // execute siblings/non-overlapping jobs — fire and forget, re-trigger scheduler on completion
+          const job_promise = func.UI.worker.execute(val.SESSION_ID, val).catch(function (err) {
+            console.error(err);
+          }).finally(function () {
+            // remove this element from in-flight tracking
+            const idx = UI_WORKER_OBJ.in_flight_job_elements.indexOf(in_flight_entry);
+            if (idx !== -1) {
+              UI_WORKER_OBJ.in_flight_job_elements.splice(idx, 1);
+            }
+            // re-trigger scheduler so blocked sibling jobs can now run
+            func.UI.worker.schedule_run(0);
+          });
+          dispatched_jobs.push(job_promise);
           if (job_lane === 'dom') {
             dom_jobs_processed++;
           }
           continue;
-
-          // active_job_children_elements = [];
-          // if (val.elementP) {
-          //   // get active_job children elements only if job handle ui job (not update)
-          //   $.each(val.elementP.find('*'), function (key, val) {
-          //     const xu_ui_id = val.elementP.attr('xu-ui-id');
-          //     if (!xu_ui_id) return true;
-          //     active_job_children_elements.push(xu_ui_id);
-          //   });
-          //   func.UI.worker.execute(val.SESSION_ID, val);
-          //   continue;
-          // } else {
-          //   // non ui job
-          //   await func.UI.worker.execute(val.SESSION_ID, val);
-          //   break;
-          // }
-
-          // if (UI_WORKER_OBJ.jobs.length > 1 && val.elementP) {
-          //   const xu_ui_id = val.elementP.attr('xu-ui-id');
-          //   if (!xu_ui_id) continue;
-          //   // skip - if job element exist in the active job ui as child element
-          //   if (active_job_children_elements.includes(xu_ui_id)) {
-          //     continue;
-          //   }
-          //   // abort - if active job element exist in the current job ui (parent element changed)
-          //   $.each(val.elementP.find('*'), function (key, val) {
-          //     const xu_ui_id = val.elementP.attr('xu-ui-id');
-          //     if (!xu_ui_id) return true;
-          //     active_job_children_elements.push(xu_ui_id);
-          //   });
-          //   // execute - if active job element not exist the current job ui and not detected as parent element
-          //   const active_job = UI_WORKER_OBJ.jobs[0];
-          // }
-
-          // break;
         } catch (err) {
           console.error(err);
         }
       }
+
+      // Only await jobs that have no element (data jobs) — don't block on long-running UI jobs
+      // UI jobs with elements will re-trigger schedule_run when they complete
     }
   };
   func.UI.worker.schedule_run = function (delay = 0, preferred_mode) {
     func.UI.worker.ensure_runtime_indexes();
     if (UI_WORKER_OBJ.run_in_progress) {
+      // Allow re-entry: even though a scan is in progress, mark run_again
+      // so the scheduler re-scans after the current pass. This lets sibling
+      // jobs that were queued after the scan started get picked up quickly.
       UI_WORKER_OBJ.run_again = true;
       return;
     }
@@ -10952,8 +11011,69 @@ func.UI.worker.execute = async function (SESSION_ID, queue_obj) {
       }
       return $root.find(`[xu-ui-id="${xu_ui_id}"]`);
     },
-    get_live_element_context: function (elem_key, fallback_$elm) {
-      const $elm = elem_key ? fx.get_element_by_ui_id(elem_key) : fallback_$elm;
+    get_live_element_context: function (elem_key, fallback_$elm, context = {}) {
+      let raw_$elm = elem_key ? fx.get_element_by_ui_id(elem_key) : fallback_$elm;
+      let $elm = func.runtime?.ui?.get_preferred_live_element ? func.runtime.ui.get_preferred_live_element(raw_$elm) : raw_$elm;
+
+      if (context.node_id) {
+        const $root = func.UI.worker.get_session_root(SESSION_ID);
+        const runtime_nodes = func.runtime?.ui?.get_refresh_index_elements
+          ? func.runtime.ui.get_refresh_index_elements(SESSION_ID, $root).toArray()
+          : $root.find('[xu-ui-id]').toArray();
+        let matching_nodes = [];
+
+        for (let index = 0; index < runtime_nodes.length; index++) {
+          const node = runtime_nodes[index];
+          const node_data = func.runtime.ui.get_data(node);
+          const node_xu_data = node_data?.xuData;
+          if (!node_xu_data) {
+            continue;
+          }
+          if (node_xu_data.nodeid !== context.node_id) {
+            continue;
+          }
+          if (context.recordid && node_xu_data.recordid !== context.recordid) {
+            continue;
+          }
+          if (context.prog_id && node_xu_data.paramsP?.prog_id !== context.prog_id) {
+            continue;
+          }
+          if (context.parent_element_ui_id && node_xu_data.parent_element_ui_id !== context.parent_element_ui_id) {
+            continue;
+          }
+          if (node_xu_data.pending_to_delete) {
+            continue;
+          }
+          matching_nodes.push(node);
+        }
+
+        if (!matching_nodes.length) {
+          for (let index = 0; index < runtime_nodes.length; index++) {
+            const node = runtime_nodes[index];
+            const node_data = func.runtime.ui.get_data(node);
+            const node_xu_data = node_data?.xuData;
+            if (!node_xu_data) {
+              continue;
+            }
+            if (node_xu_data.nodeid !== context.node_id) {
+              continue;
+            }
+            if (context.recordid && node_xu_data.recordid !== context.recordid) {
+              continue;
+            }
+            if (node_xu_data.pending_to_delete) {
+              continue;
+            }
+            matching_nodes.push(node);
+          }
+        }
+
+        if (matching_nodes.length) {
+          raw_$elm = $(matching_nodes);
+          $elm = func.runtime?.ui?.get_preferred_live_element ? func.runtime.ui.get_preferred_live_element(raw_$elm) : raw_$elm;
+        }
+      }
+
       if (!$elm?.length) {
         return {
           $elm: $(),
@@ -11008,6 +11128,13 @@ func.UI.worker.execute = async function (SESSION_ID, queue_obj) {
         'xu-for': true,
         'xu-exp:xu-bind': true,
       };
+      const raw_value_attributes = {
+        'xu-bind': true,
+        'xu-ref': true,
+        'xu-on': true,
+        'xu-for-key': true,
+        'xu-for-val': true,
+      };
 
       const execution_plan = [];
       for (let index = 0; index < (refresh_attributes || []).length; index++) {
@@ -11023,7 +11150,7 @@ func.UI.worker.execute = async function (SESSION_ID, queue_obj) {
           attr_new,
           xu_func,
           is_regular_attribute: !!(attr_new && attr_new.substr(0, 2) !== 'xu'),
-          requires_expression: attr !== 'xu-class' && attr !== 'xu-ui-plugin',
+          requires_expression: !raw_value_attributes[attr] && attr !== 'xu-class' && attr !== 'xu-ui-plugin',
           regular_attr_name: attr_new ? (attr_new !== 'viewBox' ? attr_new.toLowerCase() : attr_new) : null,
         });
       }
@@ -11099,23 +11226,25 @@ func.UI.worker.execute = async function (SESSION_ID, queue_obj) {
     },
     execute_xu_render_attributes: async function () {
       const perf_end = func.runtime?.perf?.start?.(SESSION_ID, 'execute_xu_render_attributes');
-      const live_context = fx.get_live_element_context(queue_obj.paramsP?.elem_key, queue_obj.elementP || queue_obj.paramsP?.elem_val?.$elm);
+      const live_context = fx.get_live_element_context(queue_obj.paramsP?.elem_key, queue_obj.elementP || queue_obj.paramsP?.elem_val?.$elm, queue_obj.paramsP);
       const _data = live_context.data;
       try {
         if (_data?.xuData?.paramsP) {
+          const live_xu_data = _data.xuData;
           await func.runtime.render.execute_xu_function({
             SESSION_ID,
             is_skeleton: null,
-            $root_container: _data.xuData.$root_container,
-            nodeP: _data.xuData.node,
-            $container: fx.get_element_by_ui_id(_data.xuData.parent_element_ui_id),
-            paramsP: _data.xuData.paramsP,
-            parent_infoP: {},
+            $root_container: live_xu_data.$root_container,
+            nodeP: live_xu_data.node,
+            $container: fx.get_element_by_ui_id(live_xu_data.parent_element_ui_id) || live_xu_data.$container,
+            paramsP: live_xu_data.paramsP,
+            parent_infoP: live_xu_data.iterate_info ? { iterate_info: live_xu_data.iterate_info } : {},
             jobNoP: queue_obj.jobNoP,
-            keyP: _data.xuData.key,
-            parent_nodeP: _data.xuData.parent_node,
+            keyP: live_xu_data.key,
+            parent_nodeP: live_xu_data.parent_node,
             xu_func: 'xu-render',
             $elm: live_context.$elm,
+            $live_elm: live_context.$elm,
             val: {
               key: 'xu-render',
               value: queue_obj.paramsP.attr_value,
@@ -11138,7 +11267,7 @@ func.UI.worker.execute = async function (SESSION_ID, queue_obj) {
       };
 
       try {
-        const live_context = fx.get_live_element_context(queue_obj.paramsP?.elem_key, queue_obj.elementP || queue_obj.paramsP?.elem_val?.$elm);
+        const live_context = fx.get_live_element_context(queue_obj.paramsP?.elem_key, queue_obj.elementP || queue_obj.paramsP?.elem_val?.$elm, queue_obj.paramsP);
         const $elm = live_context.$elm;
         const live_data = live_context.data;
         const elm_node = $elm?.[0];
@@ -11151,18 +11280,20 @@ func.UI.worker.execute = async function (SESSION_ID, queue_obj) {
         const refresh_attributes = queue_obj.paramsP?.elem_val?.attributes || [];
         const execution_plan = fx.get_refresh_execution_plan(live_data, refresh_attributes);
         const expression_results_cache = {};
+        const live_parent_container = fx.get_element_by_ui_id(live_xu_data.parent_element_ui_id);
         const xu_execution_context = {
           SESSION_ID,
           is_skeleton: null,
           $root_container: live_xu_data.$root_container,
           nodeP: live_xu_data.node,
-          $container: live_xu_data.$container,
+          $container: live_parent_container?.length ? live_parent_container : live_xu_data.$container,
           paramsP: live_xu_data.paramsP,
-          parent_infoP: {},
+          parent_infoP: live_xu_data.iterate_info ? { iterate_info: live_xu_data.iterate_info } : {},
           jobNoP: queue_obj.jobNoP,
-          keyP: null,
-          parent_nodeP: null,
+          keyP: live_xu_data.key,
+          parent_nodeP: live_xu_data.parent_node,
           $elm,
+          $live_elm: $elm,
           get_params_obj_new: func.runtime.program.get_params_obj,
         };
         const handler_bundle = func.runtime.render.build_xu_handlers(xu_execution_context, SESSION_OBJ[SESSION_ID].DS_GLB[live_xu_data.paramsP.dsSessionP]);
@@ -11217,7 +11348,7 @@ func.UI.worker.execute = async function (SESSION_ID, queue_obj) {
     execute_xu_for: async function () {
       const perf_end = func.runtime?.perf?.start?.(SESSION_ID, 'execute_xu_for');
       try {
-        const live_context = fx.get_live_element_context(queue_obj.paramsP?.elem_key, queue_obj.elementP || queue_obj?.paramsP?.elem_val?.$elm);
+        const live_context = fx.get_live_element_context(queue_obj.paramsP?.elem_key, queue_obj.elementP || queue_obj?.paramsP?.elem_val?.$elm, queue_obj.paramsP);
         var $elm = live_context.$elm; // $(SESSION_OBJ[SESSION_ID].root_element).find(`[xu-ui-id=${queue_obj.paramsP.elem_key}]`)
 
         if (!$elm?.length) {
@@ -11294,7 +11425,7 @@ func.UI.worker.execute = async function (SESSION_ID, queue_obj) {
     },
     execute_xu_widget: async function () {
       try {
-        const live_context = fx.get_live_element_context(queue_obj.paramsP?.elem_key, queue_obj.elementP || queue_obj?.paramsP?.elem_val?.$elm);
+        const live_context = fx.get_live_element_context(queue_obj.paramsP?.elem_key, queue_obj.elementP || queue_obj?.paramsP?.elem_val?.$elm, queue_obj.paramsP);
         var $elm = live_context.$elm; // $(SESSION_OBJ[SESSION_ID].root_element).find(`[xu-ui-id=${queue_obj.paramsP.elem_key}]`)
 
         if (!$elm?.length) {
@@ -11323,7 +11454,16 @@ func.UI.worker.execute = async function (SESSION_ID, queue_obj) {
     },
   };
 
-  return await fx[queue_obj.functionP]();
+  try {
+    return await fx[queue_obj.functionP]();
+  } catch (error) {
+    console.error(error);
+    const failed_job_index = func.UI.worker.find_job_index(SESSION_ID, queue_obj.job_num);
+    if (failed_job_index !== null && typeof failed_job_index !== 'undefined' && UI_WORKER_OBJ.jobs[failed_job_index]) {
+      await func.UI.worker.delete_job(SESSION_ID, queue_obj.job_num);
+    }
+    return null;
+  }
 };
 func.UI.worker.find_job_index = function (SESSION_ID, jobNoP) {
   var ret = null;
@@ -12027,7 +12167,7 @@ func.runtime.ui.init_screen = async function (options) {
     $rootFrame.css('display', 'contents');
   }
 
-  func.UI.utils.indicator.screen.busy();
+  if (!is_panelP) func.UI.utils.indicator.screen.busy();
 
   const ret = await func.datasource.create(
     SESSION_ID,
@@ -12043,7 +12183,7 @@ func.runtime.ui.init_screen = async function (options) {
     null,
     null,
     null,
-    null,
+    is_panelP,
     parameters_obj_inP,
   );
 
@@ -12070,7 +12210,7 @@ func.runtime.ui.init_screen = async function (options) {
   if (!node.length) return console.warn('ui node empty');
   const ret_render_$container = await func.runtime.render.render_ui_tree(SESSION_ID, $rootFrame, node[0], null, params, jobNoP, null, null, null, null, null, $rootFrame);
 
-  func.UI.utils.indicator.screen.normal();
+  if (!is_panelP) func.UI.utils.indicator.screen.normal();
 
   return await func.runtime.ui.screen_loading_done({
     SESSION_ID,
@@ -12595,6 +12735,7 @@ func.runtime.render = func.runtime.render || {};
 // Browser-only panel rendering helpers live here so generic view rendering can stay focused.
 
 func.runtime.ui.render_panel_node = async function (options) {
+
   const $wrapper = $('<div>');
   const $div = await func.runtime.ui.create_container({
     SESSION_ID: options.SESSION_ID,
@@ -13168,7 +13309,7 @@ func.runtime.ui.normalize_refresh_field_reference = function (field_ref) {
 
   return [...normalized].filter(Boolean);
 };
-func.runtime.ui.extract_expression_refresh_fields = function (elm_data, expression_text, without_var) {
+func.runtime.ui.extract_expression_refresh_fields = function (elm_data, expression_text, without_var, _visited) {
   const fields = new Set();
   if (!expression_text) {
     return fields;
@@ -13199,8 +13340,12 @@ func.runtime.ui.extract_expression_refresh_fields = function (elm_data, expressi
 
   const parameters_raw_obj = elm_data?.xuData?.paramsP?.parameters_raw_obj || {};
   const parameter_keys = Object.keys(parameters_raw_obj);
+  const visited = _visited || new Set();
   for (let index = 0; index < parameter_keys.length; index++) {
     const param_key = parameter_keys[index];
+    if (visited.has(param_key)) {
+      continue;
+    }
     const param_val = parameters_raw_obj[param_key];
     if (!param_val?.includes?.('@')) {
       continue;
@@ -13209,7 +13354,8 @@ func.runtime.ui.extract_expression_refresh_fields = function (elm_data, expressi
     if (!text.includes(param_token)) {
       continue;
     }
-    const nested_fields = func.runtime.ui.extract_expression_refresh_fields(elm_data, param_val, false);
+    visited.add(param_key);
+    const nested_fields = func.runtime.ui.extract_expression_refresh_fields(elm_data, param_val, false, visited);
     nested_fields.forEach(function (field_id) {
       add_field(field_id);
     });
@@ -13509,6 +13655,41 @@ func.runtime.ui.find_refresh_elements_by_attr = function ($root, attr_name, attr
 
   return $(elements);
 };
+func.runtime.ui.get_preferred_live_element = function (target) {
+  const elements = func.runtime.ui.as_jquery(target).toArray();
+  if (!elements.length) {
+    return $();
+  }
+
+  let best_node = null;
+  let best_score = -Infinity;
+  for (let index = 0; index < elements.length; index++) {
+    const node = elements[index];
+    if (!node) {
+      continue;
+    }
+    const node_data = func.runtime.ui.get_data(node);
+    let score = 0;
+    if (node.isConnected) {
+      score += 100;
+    }
+    if (!node_data?.xuData?.pending_to_delete) {
+      score += 50;
+    }
+    if (node.getClientRects?.().length) {
+      score += 25;
+    }
+    if (!node.hidden) {
+      score += 10;
+    }
+    if (score >= best_score) {
+      best_score = score;
+      best_node = node;
+    }
+  }
+
+  return best_node ? $(best_node) : $(elements[elements.length - 1]);
+};
 func.runtime.ui.get_refresh_indexed_element_by_ui_id = function (SESSION_ID, selector_id) {
   const state = func.runtime.ui.ensure_refresh_dependency_state(SESSION_ID);
   if (!state) {
@@ -13519,12 +13700,14 @@ func.runtime.ui.get_refresh_indexed_element_by_ui_id = function (SESSION_ID, sel
   }
 
   let $elm = state.elements_by_ui_id?.[selector_id];
+  $elm = func.runtime.ui.get_preferred_live_element($elm);
   if ($elm?.length && $elm[0]?.isConnected) {
+    state.elements_by_ui_id[selector_id] = $elm;
     return $elm;
   }
 
   const $root = func.runtime.ui.get_refresh_index_root(SESSION_ID);
-  $elm = func.runtime.ui.find_refresh_elements_by_attr($root, 'xu-ui-id', selector_id, true);
+  $elm = func.runtime.ui.get_preferred_live_element(func.runtime.ui.find_refresh_elements_by_attr($root, 'xu-ui-id', selector_id));
   if ($elm?.length) {
     state.elements_by_ui_id[selector_id] = $elm;
     state.runtime_elements_cache = null;
@@ -13628,12 +13811,14 @@ func.runtime.ui.get_refresh_indexed_panel_wrapper_by_id = function (SESSION_ID,
   }
 
   let $elm = state.panel_wrappers_by_id?.[wrapper_id];
+  $elm = func.runtime.ui.get_preferred_live_element($elm);
   if ($elm?.length && $elm[0]?.isConnected) {
+    state.panel_wrappers_by_id[wrapper_id] = $elm;
     return $elm;
   }
 
   const $root = func.runtime.ui.get_refresh_index_root(SESSION_ID);
-  $elm = func.runtime.ui.find_refresh_elements_by_attr($root, 'xu-panel-wrapper-id', wrapper_id, true);
+  $elm = func.runtime.ui.get_preferred_live_element(func.runtime.ui.find_refresh_elements_by_attr($root, 'xu-panel-wrapper-id', wrapper_id));
   if ($elm?.length) {
     state.panel_wrappers_by_id[wrapper_id] = $elm;
     state.panel_wrapper_elements_cache = null;
@@ -13865,6 +14050,10 @@ func.runtime.ui.build_refresh_job_obj = function (options, elem_key, elem_val, e
     SESSION_ID: options.SESSION_ID,
     fields_arr: options.fields_arr,
     elem_key,
+    node_id: elm_data?.xuData?.nodeid,
+    recordid: elm_data?.xuData?.recordid,
+    parent_element_ui_id: elm_data?.xuData?.parent_element_ui_id,
+    prog_id: elm_data?.xuData?.paramsP?.prog_id,
     elem_val: {
       attributes: [...(elem_val.attributes || [])],
     },
@@ -14189,7 +14378,7 @@ func.runtime.render = func.runtime.render || {};
 // Browser-only xu-attribute refresh helpers live here so screen refresh orchestration can stay focused.
 
 func.runtime.ui.refresh_xu_attributes = async function (options) {
-  if (options.trigger !== 'click' && !_.isEmpty(SCREEN_BLOCKER_OBJ)) {
+  if (!options.ignore_screen_blocker && options.trigger !== 'click' && !_.isEmpty(SCREEN_BLOCKER_OBJ)) {
     setTimeout(() => {
       func.runtime.ui.refresh_xu_attributes(options);
     }, 100);
@@ -16710,11 +16899,19 @@ func.runtime.render.handle_xu_ref = async function (options) {
 func.runtime.render.handle_xu_bind = async function (options) {
   if (options.is_skeleton) return {};
 
-  const elm_data = func.runtime.ui.get_data(options.$elm);
+  const $elm = func.runtime?.ui?.get_preferred_live_element ? func.runtime.ui.get_preferred_live_element(options.$elm) : func.runtime.ui.as_jquery(options.$elm);
+  const elm_data = func.runtime.ui.get_data($elm);
   const xuData = elm_data?.xuData;
+  const bind_expression =
+    typeof options?.val?.value === 'string'
+      ? options.val.value
+      : elm_data?.xuAttributes?.['xu-bind'] || func.runtime.ui.get_attr($elm, 'xu-bind');
   if (!xuData?.paramsP) {
     return {};
   }
+  if (!bind_expression) {
+    return {};
+  }
 
   let val_is_reference_field = false;
   let _prog_id = xuData.paramsP.prog_id;
@@ -16722,10 +16919,94 @@ func.runtime.render.handle_xu_bind = async function (options) {
   let is_dynamic_field = false;
   let field_prop;
   let bind_field_id;
-  const input_field_type = options.$elm?.[0]?.type || func.runtime.ui.get_attr(options.$elm, 'type');
+  const input_field_type = $elm?.[0]?.type || func.runtime.ui.get_attr($elm, 'type');
+  const bind_ui_id = xuData.ui_id || func.runtime.ui.get_attr($elm, 'xu-ui-id');
+  const get_bind_targets = function () {
+    const $root = func.runtime.ui.get_refresh_index_root?.(options.SESSION_ID) || func.runtime.ui.get_root_element?.(options.SESSION_ID) || $('body');
+    const live_targets = [];
+    const seen_nodes = new Set();
+    const add_candidate = function (node) {
+      if (!node || seen_nodes.has(node)) {
+        return;
+      }
+      const target_data = func.runtime.ui.get_data(node);
+      if (!node.isConnected || target_data?.xuData?.pending_to_delete) {
+        return;
+      }
+      seen_nodes.add(node);
+      live_targets.push(node);
+    };
+
+    if (bind_ui_id && options.SESSION_ID && func.runtime?.ui?.find_refresh_elements_by_attr) {
+      const ui_id_targets = func.runtime.ui.find_refresh_elements_by_attr($root, 'xu-ui-id', bind_ui_id).toArray();
+      for (let index = 0; index < ui_id_targets.length; index++) {
+        add_candidate(ui_id_targets[index]);
+      }
+    }
+
+    const runtime_nodes = func.runtime?.ui?.get_refresh_index_elements
+      ? func.runtime.ui.get_refresh_index_elements(options.SESSION_ID, $root).toArray()
+      : $root.find('[xu-ui-id]').toArray();
+    const target_parent_ui_id = xuData.parent_element_ui_id;
+    const target_node_id = xuData.nodeid;
+    const target_recordid = xuData.recordid;
+    const target_prog_id = xuData.paramsP?.prog_id;
+    for (let index = 0; index < runtime_nodes.length; index++) {
+      const node = runtime_nodes[index];
+      const node_data = func.runtime.ui.get_data(node);
+      const node_xu_data = node_data?.xuData;
+      if (!node_xu_data) {
+        continue;
+      }
+      if (target_node_id && node_xu_data.nodeid !== target_node_id) {
+        continue;
+      }
+      if (target_parent_ui_id && node_xu_data.parent_element_ui_id !== target_parent_ui_id) {
+        continue;
+      }
+      if (target_prog_id && node_xu_data.paramsP?.prog_id !== target_prog_id) {
+        continue;
+      }
+      if (typeof target_recordid !== 'undefined' && target_recordid !== null && node_xu_data.recordid !== target_recordid) {
+        continue;
+      }
+      const node_bind_expression = node_data?.xuAttributes?.['xu-bind'] || func.runtime.ui.get_attr(node, 'xu-bind');
+      if (node_bind_expression !== bind_expression) {
+        continue;
+      }
+      add_candidate(node);
+    }
+
+    if (!live_targets.length) {
+      return $elm;
+    }
+
+    for (let index = 0; index < live_targets.length; index++) {
+      const node = live_targets[index];
+      const target_data = func.runtime.ui.get_data(node);
+      if (!node?.isConnected || target_data?.xuData?.pending_to_delete) {
+        continue;
+      }
+      add_candidate(node);
+    }
+
+    if (!live_targets.length) {
+      return $elm;
+    }
+
+    const target_nodes = live_targets;
+    const visible_targets = [];
+    for (let index = 0; index < target_nodes.length; index++) {
+      const node = target_nodes[index];
+      if (node.getClientRects?.().length && !node.hidden) {
+        visible_targets.push(node);
+      }
+    }
+    return $(visible_targets.length ? visible_targets : live_targets);
+  };
 
   try {
-    const bind_field = await func.runtime.bind.resolve_field(options.SESSION_ID, _prog_id, _dsP, options.val.value.split('.')[0]);
+    const bind_field = await func.runtime.bind.resolve_field(options.SESSION_ID, _prog_id, _dsP, bind_expression.split('.')[0], xuData.iterate_info);
     bind_field_id = bind_field.bind_field_id;
     field_prop = bind_field.field_prop;
     is_dynamic_field = bind_field.is_dynamic_field;
@@ -16774,38 +17055,85 @@ func.runtime.render.handle_xu_bind = async function (options) {
       field_prop,
       val_is_reference_field,
       input_field_type,
-      expression_value: options.val.value,
+      expression_value: bind_expression,
       value,
     });
 
     await func.datasource.update_changes_for_out_parameter(options.SESSION_ID, _dsP, _ds.parentDataSourceNo);
   };
 
-  bind.listener(options.$elm[0], field_changed);
+  const bind_targets = get_bind_targets();
+  const target_nodes = bind_targets.toArray();
+  for (let index = 0; index < target_nodes.length; index++) {
+    const target = target_nodes[index];
+    const target_data = func.runtime.ui.get_data(target);
+    if (!target_data?.xuData || target_data.xuData.bind_listener_attached) {
+      continue;
+    }
+    bind.listener(target, field_changed);
+    target_data.xuData.bind_listener_attached = true;
+  }
 
-  const set_value = function () {
-    const _ds = SESSION_OBJ[options.SESSION_ID].DS_GLB[options.paramsP.dsSessionP];
-    if (!_ds.currentRecordId) return;
+  const set_value = async function () {
+    const _ds = SESSION_OBJ[options.SESSION_ID].DS_GLB[_dsP];
+    if (!_ds) return;
+    const target_record_id = xuData.recordid || _ds.currentRecordId;
+    if (!target_record_id) return;
     let value;
     try {
       if (val_is_reference_field) {
-        value = func.runtime.bind.get_source_value(_ds, bind_field_id, is_dynamic_field);
-        value = func.runtime.bind.format_display_value(options.$elm, field_prop, bind_field_id, options.val.value, value, input_field_type);
+        const iter = xuData.iterate_info;
+        if (iter && is_dynamic_field && (iter.iterator_val === bind_field_id || iter.iterator_key === bind_field_id)) {
+          value = iter.iterator_val === bind_field_id ? iter._val : iter._key;
+        } else {
+          const resolved_value = await func.datasource.get_value(options.SESSION_ID, bind_field_id, _dsP, target_record_id);
+          if (resolved_value?.found) {
+            value = resolved_value.ret.value;
+          } else {
+            value = func.runtime.bind.get_source_value(_ds, bind_field_id, is_dynamic_field);
+          }
+        }
+        value = func.runtime.bind.format_display_value($elm, field_prop, bind_field_id, bind_expression, value, input_field_type);
       } else {
-        value = options.val.value;
+        value = bind_expression;
       }
       if (typeof value === 'undefined') return;
-      bind.setter(options.$elm[0], value);
+
+      const live_bind_targets = get_bind_targets().toArray();
+      for (let index = 0; index < live_bind_targets.length; index++) {
+        const elm = live_bind_targets[index];
+        if (!elm) {
+          continue;
+        }
+
+        bind.setter(elm, value);
+        const target_input_type = elm.type || input_field_type;
+        switch (target_input_type) {
+          case 'radio':
+            elm.checked = elm.value === _.toString(value);
+            break;
+          case 'checkbox':
+            elm.checked = !!value;
+            break;
+          default:
+            if (typeof elm.value !== 'undefined') {
+              elm.value = value === null ? '' : _.toString(value);
+            }
+            break;
+        }
+      }
     } catch (err) {
       console.error(err);
     }
   };
 
-  $('body').on('xu-bind-refresh.' + options.ds.dsSession.toString(), () => {
-    set_value();
+  const bind_refresh_event = 'xu-bind-refresh.' + _dsP.toString();
+  const bind_refresh_namespace = `.ui${bind_ui_id || bind_field_id || 'bind'}`;
+  $('body').off(bind_refresh_namespace).on(bind_refresh_event + bind_refresh_namespace, async () => {
+    await set_value();
   });
 
-  set_value();
+  await set_value();
   return {};
 };
 func.runtime.render.apply_xu_class = async function (options) {
@@ -17117,7 +17445,11 @@ func.runtime.render.handle_modern_xu_render = async function (options) {
   };
 
   const post_render = async function () {
-    const nodeP = func.runtime.ui.get_data(options.$container).xuData.node.children[options.keyP];
+    const container_data = func.runtime.ui.get_data(options.$container);
+    if (!container_data?.xuData?.node?.children?.[options.keyP]) {
+      return;
+    }
+    const nodeP = container_data.xuData.node.children[options.keyP];
     nodeP.xu_render_made = value;
     if (value) {
       try {
@@ -17163,12 +17495,23 @@ func.runtime.render.handle_modern_xu_render = async function (options) {
         }
 
         func.runtime.render.insert_ordered_child(options.$container, new_$div, options.keyP);
+        // Remove the XURENDER placeholder now that the real content has been inserted.
+        if (options.$elm?.[0]?.tagName === 'XURENDER') {
+          func.runtime.ui.remove(options.$elm);
+        }
       } catch (error) {
         func.events.delete_job(options.SESSION_ID, options.jobNoP);
       }
       return;
     }
 
+    // Cancel any in-flight child jobs before removing the element.
+    // This prevents orphaned jobs (e.g. a child panel's long-running on_load delay)
+    // from blocking future scheduler passes after the parent element is gone.
+    if (func.UI?.worker?.cancel_child_in_flight_jobs) {
+      func.UI.worker.cancel_child_in_flight_jobs(options.$elm);
+    }
+
     const xu_ui_id = func.runtime.ui.get_attr(options.$elm, 'xu-ui-id');
     const exclude_fields = func.runtime.render.get_xu_render_exclude_fields(options.$elm);
     const cache_str = await func.runtime.render.get_xu_render_cache_str(