@xuda.io/runtime-bundle 1.0.1406 → 1.0.1407

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

@@ -1635,6 +1635,10 @@ var func = {};
 func.UI = {};
 func.GLB = {};
 func.mobile = {};
+func.runtime = {};
+func.runtime.session = {};
+func.runtime.workers = {};
+func.runtime.ui = {};
 glb.IS_STUDIO = null;
 
 var PROJECT_OBJ = {};
@@ -1648,6 +1652,537 @@ glb.PROTECTED_VARS = ['_NULL', '_THIS', '_FOR_KEY', '_FOR_VAL', '_ROWNO', '_ROWI
 // glb.newRecord = 999999;
 
 func.common = {};
+func.runtime.platform = {
+  has_window: function () {
+    return typeof window !== 'undefined';
+  },
+  has_document: function () {
+    return typeof document !== 'undefined';
+  },
+  get_window: function () {
+    if (func.runtime.platform.has_window()) {
+      return window;
+    }
+    return null;
+  },
+  get_document: function () {
+    if (func.runtime.platform.has_document()) {
+      return document;
+    }
+    return null;
+  },
+  get_location: function () {
+    const win = func.runtime.platform.get_window();
+    return win?.location || null;
+  },
+  get_navigator: function () {
+    const win = func.runtime.platform.get_window();
+    if (win?.navigator) {
+      return win.navigator;
+    }
+    if (typeof navigator !== 'undefined') {
+      return navigator;
+    }
+    return null;
+  },
+  is_html_element: function (value) {
+    if (typeof HTMLElement === 'undefined') {
+      return false;
+    }
+    return value instanceof HTMLElement;
+  },
+  get_storage: function (type) {
+    const win = func.runtime.platform.get_window();
+    try {
+      if (!win) {
+        return null;
+      }
+      if (type === 'session') {
+        return win.sessionStorage || null;
+      }
+      return win.localStorage || null;
+    } catch (error) {
+      return null;
+    }
+  },
+  get_storage_item: function (key, type) {
+    const storage = func.runtime.platform.get_storage(type);
+    if (!storage) {
+      return null;
+    }
+    try {
+      return storage.getItem(key);
+    } catch (error) {
+      return null;
+    }
+  },
+  set_storage_item: function (key, value, type) {
+    const storage = func.runtime.platform.get_storage(type);
+    if (!storage) {
+      return false;
+    }
+    try {
+      storage.setItem(key, value);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  },
+  get_url_href: function () {
+    return func.runtime.platform.get_location()?.href || '';
+  },
+  get_url_search: function () {
+    return func.runtime.platform.get_location()?.search || '';
+  },
+  get_url_hash: function () {
+    return func.runtime.platform.get_location()?.hash || '';
+  },
+  get_host: function () {
+    return func.runtime.platform.get_location()?.host || '';
+  },
+  get_hostname: function () {
+    return func.runtime.platform.get_location()?.hostname || '';
+  },
+  get_device_uuid: function () {
+    const win = func.runtime.platform.get_window();
+    return win?.device?.uuid || null;
+  },
+  get_device_name: function () {
+    const win = func.runtime.platform.get_window();
+    return win?.device?.name || null;
+  },
+  get_inner_size: function () {
+    const win = func.runtime.platform.get_window();
+    return {
+      width: win?.innerWidth || 0,
+      height: win?.innerHeight || 0,
+    };
+  },
+  add_window_listener: function (name, handler) {
+    const win = func.runtime.platform.get_window();
+    if (!win?.addEventListener) {
+      return false;
+    }
+    win.addEventListener(name, handler);
+    return true;
+  },
+  dispatch_body_event: function (event) {
+    const doc = func.runtime.platform.get_document();
+    if (!doc?.body?.dispatchEvent) {
+      return false;
+    }
+    doc.body.dispatchEvent(event);
+    return true;
+  },
+  reload_top_window: function () {
+    const win = func.runtime.platform.get_window();
+    if (!win?.top?.location?.reload) {
+      return false;
+    }
+    win.top.location.reload();
+    return true;
+  },
+  get_service_worker: function () {
+    const nav = func.runtime.platform.get_navigator();
+    return nav?.serviceWorker || null;
+  },
+  has_service_worker: function () {
+    return !!func.runtime.platform.get_service_worker();
+  },
+  register_service_worker: function (script_url) {
+    const service_worker = func.runtime.platform.get_service_worker();
+    if (!service_worker?.register) {
+      return Promise.reject(new Error('serviceWorker is not available'));
+    }
+    return service_worker.register(script_url);
+  },
+  add_service_worker_listener: function (name, handler) {
+    const service_worker = func.runtime.platform.get_service_worker();
+    if (!service_worker?.addEventListener) {
+      return false;
+    }
+    service_worker.addEventListener(name, handler);
+    return true;
+  },
+};
+func.runtime.env = {
+  get_url_params: function () {
+    const search = func.runtime.platform.get_url_search();
+    return new URLSearchParams(search);
+  },
+  get_url_parameters_object: function () {
+    const search_params = func.runtime.env.get_url_params();
+    const parameters = {};
+    for (const [key, value] of search_params.entries()) {
+      parameters[key] = value;
+    }
+    return parameters;
+  },
+  get_default_session_value: function (key) {
+    switch (key) {
+      case 'domain':
+        return func.runtime.platform.get_host();
+      case 'engine_mode':
+        return 'miniapp';
+      case 'app_id':
+        return 'unknown';
+      default:
+        return null;
+    }
+  },
+};
+func.runtime.session.create_tab_id = function () {
+  const session_storage = func.runtime.platform.get_storage('session');
+  const local_storage = func.runtime.platform.get_storage('local');
+  var page_tab_id = session_storage?.getItem('tabID');
+  if (page_tab_id == null) {
+    var local_tab_id = local_storage?.getItem('tabID');
+    page_tab_id = local_tab_id == null ? 1 : Number(local_tab_id) + 1;
+    func.runtime.platform.set_storage_item('tabID', page_tab_id, 'local');
+    func.runtime.platform.set_storage_item('tabID', page_tab_id, 'session');
+  }
+  return page_tab_id;
+};
+func.runtime.session.get_fingerprint = function (components, instance_id) {
+  const device_uuid = func.runtime.platform.get_device_uuid();
+  if (func.utils.get_device() && device_uuid) {
+    if (instance_id) {
+      return instance_id + device_uuid;
+    }
+    return device_uuid;
+  }
+  const fingerprint_id = Fingerprint2.x64hash128(
+    components
+      .map(function (pair) {
+        return pair.value;
+      })
+      .join(),
+    31,
+  );
+
+  if (instance_id) {
+    return instance_id + fingerprint_id + func.runtime.session.create_tab_id();
+  }
+  return fingerprint_id;
+};
+func.runtime.session.create_state = function (SESSION_ID, options) {
+  const runtime_host = func.runtime.platform.get_host();
+  SESSION_OBJ[SESSION_ID] = {
+    JOB_NO: 1000,
+    opt: options.opt,
+    root_element: options.root_element,
+    worker_type: options.worker_type,
+    api_callback: options.api_callback,
+    CODE_BUNDLE: options.code_bundle,
+    SLIM_BUNDLE: options.slim_bundle,
+    WORKER_OBJ: {
+      jobs: [],
+      num: 1000,
+      stat: null,
+    },
+    DS_GLB: {},
+    SYS_GLOBAL_OBJ_FIREBASE_AUTH_INFO: {
+      token: '',
+      first_name: '',
+      last_name: '',
+      email: '',
+      user_id: '',
+      picture: '',
+      verified_email: '',
+      locale: '',
+      error_code: '',
+      error_msg: '',
+    },
+    SYS_GLOBAL_OBJ_CLIENT_INFO: {
+      fingerprint: '',
+      device: '',
+      user_agent: '',
+      browser_version: '',
+      browser_name: '',
+      engine_version: '',
+      client_ip: '',
+      engine_name: '',
+      os_name: '',
+      os_version: '',
+      device_model: '',
+      device_vendor: '',
+      device_type: '',
+      screen_current_resolution_x: '',
+      screen_current_resolution_y: '',
+      screen_available_resolution_x: '',
+      screen_available_resolution_y: '',
+      language: '',
+      time_zone: '',
+      cpu_architecture: '',
+      uuid: '',
+    },
+    PUSH_NOTIFICATION_GRANTED: null,
+    FIREBASE_TOKEN_ID: null,
+    USR_OBJ: {},
+    debug_js: null,
+    DS_UI_EVENTS_GLB: {},
+    host: runtime_host,
+    req_id: 0,
+    build_info: {},
+    CACHE_REQ: {},
+    url_params: {
+      ...func.common.getParametersFromUrl(),
+      ...options.url_params,
+    },
+  };
+  func.runtime.workers.ensure_registry(SESSION_ID);
+  return SESSION_OBJ[SESSION_ID];
+};
+func.runtime.session.set_default_value = function (_session, key, value) {
+  _session[key] = value || func.runtime.env.get_default_session_value(key);
+  return _session[key];
+};
+func.runtime.session.populate_client_info = function (_session, components) {
+  const _client_info = _session.SYS_GLOBAL_OBJ_CLIENT_INFO;
+  const platform = func.runtime.platform;
+  const { engine_mode } = _session;
+
+  _client_info.fingerprint = func.runtime.session.get_fingerprint(components);
+
+  if (engine_mode === 'live_preview') {
+    const inner_size = platform.get_inner_size();
+    _client_info.screen_current_resolution_x = inner_size.width;
+    _client_info.screen_current_resolution_y = inner_size.height;
+    _client_info.screen_available_resolution_x = inner_size.width;
+    _client_info.screen_available_resolution_y = inner_size.height;
+  } else {
+    _client_info.screen_current_resolution_x = components[6].value[0];
+    _client_info.screen_current_resolution_y = components[6].value[1];
+    _client_info.screen_available_resolution_x = components[7].value[0];
+    _client_info.screen_available_resolution_y = components[7].value[1];
+  }
+
+  const client = new ClientJS();
+  _client_info.device = func.utils.get_device();
+
+  const browser_data = client.getBrowserData();
+  _client_info.user_agent = browser_data.ua;
+  _client_info.browser_version = browser_data.browser.name;
+  _client_info.browser_name = browser_data.browser.version;
+  _client_info.engine_version = browser_data.engine.name;
+  _client_info.engine_name = browser_data.engine.version;
+  _client_info.os_name = browser_data.os.name;
+  _client_info.os_version = browser_data.os.version;
+  _client_info.device_model = browser_data.device.name;
+  _client_info.device_vendor = browser_data.device.name;
+  _client_info.device_type = browser_data.device.name;
+  _client_info.language = client.getLanguage();
+  _client_info.time_zone = client.getTimeZone();
+  _client_info.cpu_architecture = browser_data.cpu.architecture;
+
+  if (['android', 'ios', 'windows', 'macos', 'linux', 'live_preview'].includes(engine_mode) && func.utils.get_device()) {
+    _client_info.uuid = platform.get_device_uuid();
+    const device_name = platform.get_device_name();
+    if (device_name) {
+      _client_info.device_name = device_name;
+    }
+  }
+  return _client_info;
+};
+func.runtime.workers.ensure_registry = function (SESSION_ID) {
+  if (!WEB_WORKER[SESSION_ID]) {
+    WEB_WORKER[SESSION_ID] = {};
+  }
+  return WEB_WORKER[SESSION_ID];
+};
+func.runtime.workers.get_registry_entry = function (SESSION_ID, worker_id) {
+  return func.runtime.workers.ensure_registry(SESSION_ID)?.[worker_id] || null;
+};
+func.runtime.workers.set_registry_entry = function (SESSION_ID, worker_id, entry) {
+  const worker_registry = func.runtime.workers.ensure_registry(SESSION_ID);
+  worker_registry[worker_id] = entry;
+  return worker_registry[worker_id];
+};
+func.runtime.workers.build_worker_name = function (glb_worker_type, session, prog_obj, worker_id, build_id) {
+  return (
+    `${typeof session.SLIM_BUNDLE === 'undefined' || !session.SLIM_BUNDLE ? '' : 'Slim '}${prog_obj.menuName} worker` +
+    ' ' +
+    glb_worker_type +
+    ': #' +
+    worker_id.toString() +
+    ' ' +
+    (build_id || '') +
+    ' ' +
+    session.domain
+  );
+};
+func.runtime.workers.is_server_transport = function (session) {
+  return !!(RUNTIME_SERVER_WEBSOCKET && RUNTIME_SERVER_WEBSOCKET_CONNECTED && (!session.opt.app_computing_mode || session.opt.app_computing_mode === 'server'));
+};
+func.runtime.workers.send_message = function (SESSION_ID, worker_id, session, msg, process_pid) {
+  const registry_entry = func.runtime.workers.get_registry_entry(SESSION_ID, worker_id);
+  if (!registry_entry?.worker) {
+    return false;
+  }
+
+  if (func.runtime.workers.is_server_transport(session)) {
+    if (process_pid) {
+      msg.process_pid = process_pid;
+    }
+    registry_entry.worker.emit('message', msg);
+    return true;
+  }
+
+  registry_entry.worker.postMessage(msg);
+  return true;
+};
+func.runtime.workers.set_promise = function (SESSION_ID, worker_id, promise_queue_id, value) {
+  const registry_entry = func.runtime.workers.get_registry_entry(SESSION_ID, worker_id);
+  if (!registry_entry) {
+    return null;
+  }
+  registry_entry.promise_queue[promise_queue_id] = value;
+  return registry_entry.promise_queue[promise_queue_id];
+};
+func.runtime.workers.get_promise = function (SESSION_ID, worker_id, promise_queue_id) {
+  const registry_entry = func.runtime.workers.get_registry_entry(SESSION_ID, worker_id);
+  if (!registry_entry) {
+    return null;
+  }
+  return registry_entry.promise_queue[promise_queue_id];
+};
+func.runtime.workers.delete_promise = function (SESSION_ID, worker_id, promise_queue_id) {
+  const registry_entry = func.runtime.workers.get_registry_entry(SESSION_ID, worker_id);
+  if (!registry_entry?.promise_queue) {
+    return false;
+  }
+  delete registry_entry.promise_queue[promise_queue_id];
+  return true;
+};
+func.runtime.ui.get_root_element = function (SESSION_ID) {
+  return $(SESSION_OBJ[SESSION_ID].root_element);
+};
+func.runtime.ui.show_root_element = function (SESSION_ID) {
+  const $root_element = func.runtime.ui.get_root_element(SESSION_ID);
+  $root_element.show();
+  return $root_element;
+};
+func.runtime.ui.ensure_app_shell = function (SESSION_ID, domain) {
+  const $root_element = func.runtime.ui.get_root_element(SESSION_ID);
+  $root_element.css('position', 'relative');
+
+  if (!$root_element.find('.loader').length) {
+    $root_element.append(`
+      
+          <style>
+          .loader {
+            position: absolute;
+            background: rgb(0 0 0 / 30%);
+            z-index: 10;
+            overflow-y: auto;
+            top: 0;
+            right: 0;
+            bottom: 0;
+            left: 0;
+            display: flex;
+            flex-direction: column;
+            justify-content: center;
+            align-items: center;
+          }
+
+          .loader .loader_logo {
+
+            width: 43px;
+            height: 43px;
+            border-radius: 50%;
+            background-size: cover;
+          }
+
+          .loader .loader_msg {
+            padding-top: 10px;
+            text-align: center;
+            min-height: 20px;
+            font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+          }
+    
+          .loader .loader_rotate {
+            padding: 20px;
+            border: 2px solid #fff;
+            border-right-color: #898989;
+            border-radius: 22px;
+            -webkit-animation: rotate 0.8s infinite linear;
+            position: absolute;
+          }
+    
+          @-webkit-keyframes rotate {
+            100% {
+              -webkit-transform: rotate(360deg);
+            }
+          }
+      </style>
+      
+      <div class="loader">
+      <div class="loader_logo">
+        <div class="loader_rotate"></div> 
+      </div>
+      <div class="loader_msg"> </div>
+    </div>
+  
+      
+      <div class="progressLoader"></div>
+      
+      `);
+  }
+
+  if (!$root_element.find('#tailwind_toast_controller').length) {
+    $root_element.append(
+      `<div aria-live="assertive"
+          class="fixed inset-0 flex items-end px-4 py-6 pointer-events-none sm:p-6 sm:items-start z-[999]">
+          <div id="tailwind_toast_controller" class="w-full flex flex-col items-center space-y-4 sm:items-end">
+  
+          </div>
+       </div>`,
+    );
+  }
+
+  if (!$root_element.find('#progressScreen2').length) {
+    $root_element.append(
+      `
+        <div id="progressScreen2" style="display: none">
+          <div id="progressScreen2_text"></div>
+        </div>`,
+    );
+  }
+
+  const get_url = function (domain, method, path) {
+    return `https://${domain}/${method}${path ? '/' + path : '/'}`;
+  };
+
+  func.utils.load_css_on_demand(get_url(domain, 'dist', 'runtime/css/mobile.css'));
+  return $root_element;
+};
+func.runtime.ui.ensure_embed_container = function (SESSION_ID) {
+  const $root_element = func.runtime.ui.get_root_element(SESSION_ID);
+  let $embed_container = $root_element.find(`#embed_${SESSION_ID}`);
+
+  if (!$embed_container.length) {
+    $embed_container = $('<div>')
+      .attr('id', 'embed_' + SESSION_ID)
+      .addClass('xu_embed_div')
+      .data({ xuData: {} })
+      .appendTo($root_element);
+  }
+
+  return $embed_container;
+};
+func.runtime.ui.get_embed_container = function (SESSION_ID) {
+  return func.runtime.ui.get_root_element(SESSION_ID).find(`#embed_${SESSION_ID}`);
+};
+func.runtime.ui.get_embed_screen_containers = function () {
+  return $('.xu_embed_container');
+};
+func.runtime.ui.append_to_body = function ($element) {
+  $element.appendTo('body');
+  return $element;
+};
+func.runtime.ui.find_in_root = function (SESSION_ID, selector) {
+  return func.runtime.ui.get_root_element(SESSION_ID).find(selector);
+};
 func.common.find_item_by_key = function (arr, key, val) {
   return _.find(arr, function (e) {
     return e.data[key] === val;
@@ -2036,19 +2571,10 @@ func.common.db = async function (SESSION_ID, serviceP, dataP, opt = {}, dsSessio
 };
 
 func.common.getJsonFromUrl = function () {
-  const queryString = window.location.search;
-  const urlParams = new URLSearchParams(queryString);
-  return urlParams;
+  return func.runtime.env.get_url_params();
 };
 func.common.getParametersFromUrl = function () {
-  const searchParams = new URLSearchParams(window.location.search);
-  const parameters = {};
-
-  for (const [key, value] of searchParams.entries()) {
-    parameters[key] = value;
-  }
-
-  return parameters;
+  return func.runtime.env.get_url_parameters_object();
 };
 
 func.common.getObjectFromUrl = function (url, element_attributes_obj, embed_params_obj) {
@@ -8089,10 +8615,16 @@ func.UI.utils.live_preview_show_selected_element = function (nodeid) {
 };
 
 func.UI.utils.get_url_attribute = function (SESSION_ID, key) {
-  var ret = glb.URL_PARAMS.get(key);
-
   const _session = SESSION_OBJ[SESSION_ID];
-  return glb.URL_PARAMS.get(key) || $(_session.root_element).attr(key) || _session.opt?.params?.[key] || _session.opt[key] || $.cookie(key) || window.localStorage.getItem(key);
+  const platform = func.runtime.platform;
+  const url_param = glb.URL_PARAMS?.get?.(key);
+  const root_attribute = $(_session.root_element).attr(key);
+  const option_param = _session.opt?.params?.[key];
+  const option_value = _session.opt?.[key];
+  const cookie_value = typeof $.cookie === 'function' ? $.cookie(key) : null;
+  const storage_value = platform.get_storage_item(key, 'local');
+
+  return url_param || root_attribute || option_param || option_value || cookie_value || storage_value;
 };
 
 func.UI.utils.get_root_element_attributes = function (SESSION_ID) {
@@ -9456,7 +9988,7 @@ func.UI.screen.init = async function (SESSION_ID, prog_id, sourceScreenP, callin
     case 'popover':
       $dialogDiv = $('<div>');
       $rootFrame = $('<div>').appendTo($dialogDiv);
-      $dialogDiv.appendTo('body');
+      func.runtime.ui.append_to_body($dialogDiv);
       break;
 
     default:
@@ -9581,7 +10113,8 @@ func.UI.screen.validate_exit_events = async function (SESSION_ID, div_data_param
 };
 
 func.UI.screen.call_embed = function (SESSION_ID, prog) {
-  $('#embed_' + SESSION_ID)
+  func.runtime.ui
+    .get_embed_container(SESSION_ID)
     .empty()
     .data().xuData.screenInfo = null;
 
@@ -9952,7 +10485,7 @@ func.UI.screen.refresh_xu_attributes = async function (SESSION_ID, fields_arr, j
     return found;
   };
 
-  const $xu_embed_container = $('.xu_embed_container');
+  const $xu_embed_container = func.runtime.ui.get_embed_screen_containers();
   const panels_obj = await func.UI.utils.get_panels_wrapper_from_dom(SESSION_ID, $xu_embed_container, true);
 
   for await (const field_id of fields_arr) {
@@ -10112,7 +10645,7 @@ func.UI.screen.refresh_screen = async function (SESSION_ID, fields_changed_arr,
     }
   }
 
-  const panels_obj = await func.UI.utils.get_panels_wrapper_from_dom(SESSION_ID, $(SESSION_OBJ[SESSION_ID].root_element), false);
+  const panels_obj = await func.UI.utils.get_panels_wrapper_from_dom(SESSION_ID, func.runtime.ui.get_root_element(SESSION_ID), false);
   found = false;
   for await (const [parent_element_ui_id, panel_val] of Object.entries(panels_obj)) {
     // const progDataSource_str = JSON.stringify(panel_val.prog_doc.progDataSource);
@@ -18373,7 +18906,10 @@ func.UI.main.embed_prog_execute = async function (SESSION_ID, prog) {
   let screen_ret = await func.utils.get_screen_obj(SESSION_ID, prog);
   if (screen_ret) {
     let ret_init = await func.UI.screen.init(SESSION_ID, prog, null, null, $('#embed_' + SESSION_ID), null, null, null, null, get_params_obj(), 'call_embed');
-    document.title = screen_ret.properties.menuTitle;
+    const runtime_document = func.runtime.platform.get_document();
+    if (runtime_document) {
+      runtime_document.title = screen_ret.properties.menuTitle;
+    }
 
     return;
   }
@@ -18385,10 +18921,12 @@ func.UI.main.embed_prog_execute = async function (SESSION_ID, prog) {
 
 func.UI.main.embed_loader = async function (SESSION_ID) {
   var _session = SESSION_OBJ[SESSION_ID];
+  const platform = func.runtime.platform;
+  const browser_hash = platform.get_url_hash();
   var hash = '';
-  if (window.location.hash) hash = window.location.hash.substr(1);
+  if (browser_hash) hash = browser_hash.substr(1);
   _session.SYS_GLOBAL_STR_BROWSER_HASH_ID = hash;
-  _session.SYS_GLOBAL_STR_BROWSER_TITLE = document.title;
+  _session.SYS_GLOBAL_STR_BROWSER_TITLE = platform.get_document()?.title || '';
 
   const init_system_ds = async function () {
     if (!['main'].includes(_session.opt.app_computing_mode)) {
@@ -18448,12 +18986,7 @@ func.UI.main.embed_loader = async function (SESSION_ID) {
     _session.WORKER_OBJ.fx.init();
   };
   const create_embed_container = async function () {
-    $('<div>')
-      .attr('id', 'embed_' + SESSION_ID)
-
-      .addClass('xu_embed_div')
-      .data({ xuData: {} })
-      .appendTo($(_session.root_element));
+    func.runtime.ui.ensure_embed_container(SESSION_ID);
   };
   const execute_PENDING_OPEN_URL_EVENTS = async function () {
     if (typeof func.events.execute_PENDING_OPEN_URL_EVENTS !== 'undefined' && glb.is_cordova) {
@@ -18583,7 +19116,7 @@ func.UI.main.embed_loader = async function (SESSION_ID) {
 
   await register_run_background_plugins();
 
-  $(_session.root_element).show();
+  func.runtime.ui.show_root_element(SESSION_ID);
   func.UI.component.create_app_root_component(SESSION_ID);
   await glb.lifecycle.execute(SESSION_ID, 'beforeInit');
   await start_workers();
@@ -18608,11 +19141,11 @@ func.UI.main.embed_loader = async function (SESSION_ID) {
   });
 
   await updateOnlineStatus();
-  window.addEventListener('online', updateOnlineStatus);
-  window.addEventListener('offline', updateOnlineStatus);
+  platform.add_window_listener('online', updateOnlineStatus);
+  platform.add_window_listener('offline', updateOnlineStatus);
 
   console.log('xuda.ai system ready.');
-  $('body')[0].dispatchEvent(glb.system_ready_event);
+  platform.dispatch_body_event(glb.system_ready_event);
 };
 func.UI.main.set_custom_css = function (SESSION_ID, callbackP) {
   if (SESSION_OBJ[SESSION_ID].DS_GLB[0].data_system?.['SYS_GLOBAL_STR_SITE_CSS']) $("<style type='text/css'> " + SESSION_OBJ[SESSION_ID].DS_GLB[0].data_system['SYS_GLOBAL_STR_SITE_CSS'] + ' </style>').appendTo('head');
@@ -18628,12 +19161,14 @@ $(document).ready(function () {
 });
 
 function xuda(...args) {
+  const platform = func.runtime.platform;
+  const runtime_location = platform.get_location();
   let element = null;
   let opt = {};
   let callback = null;
 
   for (const arg of args) {
-    if (arg instanceof HTMLElement) {
+    if (platform.is_html_element(arg)) {
       // Detect the element (e.g., <div>, <span>, etc.)
       element = arg;
     } else if (typeof arg === 'object' && arg !== null && !Array.isArray(arg)) {
@@ -18662,13 +19197,13 @@ function xuda(...args) {
   if (typeof opt !== 'object') {
     return console.error('Xuda Error - opt argument is not an object');
   }
-  glb.URL_PARAMS = func.common.getJsonFromUrl(window.location.href);
+  glb.URL_PARAMS = func.common.getJsonFromUrl(platform.get_url_href());
 
   glb.worker_type = 'Worker';
   if (opt.debug_js) {
     glb.debug_js = true;
 
-    if ((location.host.includes('localhost') || location.host.includes('127.0.0.1')) && typeof glb.SLIM_BUNDLE === 'undefined' && typeof glb.CODE_BUNDLE === 'undefined') {
+    if ((runtime_location?.host?.includes('localhost') || runtime_location?.host?.includes('127.0.0.1')) && typeof glb.SLIM_BUNDLE === 'undefined' && typeof glb.CODE_BUNDLE === 'undefined') {
       glb.worker_type = 'Dev';
     } else {
       glb.worker_type = 'Debug';
@@ -18681,91 +19216,7 @@ function xuda(...args) {
     const _api_callback = callback;
 
     const create_index_html = function () {
-      const { root_element, domain } = _session;
-      $(root_element).css('position', 'relative');
-
-      $(root_element).append(`
-      
-          <style>
-          .loader {
-            position: absolute;
-            background: rgb(0 0 0 / 30%);
-            z-index: 10;
-            overflow-y: auto;
-            top: 0;
-            right: 0;
-            bottom: 0;
-            left: 0;
-            display: flex;
-            flex-direction: column;
-            justify-content: center;
-            align-items: center;
-          }
-
-          .loader .loader_logo {
-
-            width: 43px;
-            height: 43px;
-            border-radius: 50%;
-            background-size: cover;
-          }
-
-          .loader .loader_msg {
-            padding-top: 10px;
-            text-align: center;
-            min-height: 20px;
-            font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
-          }
-    
-          .loader .loader_rotate {
-            padding: 20px;
-            border: 2px solid #fff;
-            border-right-color: #898989;
-            border-radius: 22px;
-            -webkit-animation: rotate 0.8s infinite linear;
-            position: absolute;
-          }
-    
-          @-webkit-keyframes rotate {
-            100% {
-              -webkit-transform: rotate(360deg);
-            }
-          }
-      </style>
-      
-      <div class="loader">
-      <div class="loader_logo">
-        <div class="loader_rotate"></div> 
-      </div>
-      <div class="loader_msg"> </div>
-    </div>
-  
-      
-      <div class="progressLoader"></div>
-      
-      `);
-
-      $(root_element).append(
-        `<div aria-live="assertive"
-          class="fixed inset-0 flex items-end px-4 py-6 pointer-events-none sm:p-6 sm:items-start z-[999]">
-          <div id="tailwind_toast_controller" class="w-full flex flex-col items-center space-y-4 sm:items-end">
-  
-          </div>
-       </div>`,
-      );
-
-      $(root_element).append(
-        `
-        <div id="progressScreen2" style="display: none">
-          <div id="progressScreen2_text"></div>
-        </div>`,
-      );
-
-      const get_url = function (domain, method, path) {
-        return `https://${domain}/${method}${path ? '/' + path : '/'}`;
-      };
-
-      func.utils.load_css_on_demand(get_url(domain, 'dist', 'runtime/css/mobile.css'));
+      func.runtime.ui.ensure_app_shell(SESSION_ID, _session.domain);
     };
     const device_ready = async function () {
       return new Promise(function (resolve, reject) {
@@ -18773,7 +19224,7 @@ function xuda(...args) {
           return resolve();
         }
 
-        document.addEventListener(
+        platform.get_document().addEventListener(
           'deviceready',
           function () {
             glb.is_cordova = true;
@@ -18791,119 +19242,21 @@ function xuda(...args) {
       });
     };
     const get_session_id = function () {
-      function defineTabID() {
-        var iPageTabID = sessionStorage.getItem('tabID');
-        // if it is the first time that this page is loaded
-        if (iPageTabID == null) {
-          var iLocalTabID = localStorage.getItem('tabID');
-          // if tabID is not yet defined in localStorage it is initialized to 1
-          // else tabId counter is increment by 1
-          var iPageTabID = iLocalTabID == null ? 1 : Number(iLocalTabID) + 1;
-          // new computed value are saved in localStorage and in sessionStorage
-          localStorage.setItem('tabID', iPageTabID);
-          sessionStorage.setItem('tabID', iPageTabID);
-        }
-
-        return iPageTabID;
-      }
-      if (func.utils.get_device()) {
-        return _instance_id + window.device.uuid;
-      }
-      var fingerprint_id = Fingerprint2.x64hash128(
-        components
-          .map(function (pair) {
-            return pair.value;
-          })
-          .join(),
-        31,
-      );
-
-      return _instance_id + fingerprint_id + defineTabID();
+      return func.runtime.session.get_fingerprint(components, _instance_id);
     };
     const get_fingerprint = function () {
-      if (func.utils.get_device()) {
-        return window.device.uuid;
-      }
-      return Fingerprint2.x64hash128(
-        components
-          .map(function (pair) {
-            return pair.value;
-          })
-          .join(),
-        31,
-      );
+      return func.runtime.session.get_fingerprint(components);
     };
     const init_SESSION = function () {
-      SESSION_OBJ[SESSION_ID] = {
-        JOB_NO: 1000,
-
+      return func.runtime.session.create_state(SESSION_ID, {
         opt,
         root_element: $(element)[0],
         worker_type: glb.worker_type,
         api_callback: _api_callback,
-        CODE_BUNDLE: glb.CODE_BUNDLE,
-        SLIM_BUNDLE: glb.SLIM_BUNDLE,
-        WORKER_OBJ: {
-          jobs: [],
-          num: 1000,
-          stat: null,
-        },
-        DS_GLB: {},
-
-        SYS_GLOBAL_OBJ_FIREBASE_AUTH_INFO: {
-          token: '',
-          first_name: '',
-          last_name: '',
-          email: '',
-          user_id: '',
-          picture: '',
-          verified_email: '',
-          locale: '',
-          error_code: '',
-          error_msg: '',
-        },
-        SYS_GLOBAL_OBJ_CLIENT_INFO: {
-          fingerprint: '',
-          device: '',
-
-          user_agent: '',
-          browser_version: '',
-          browser_name: '',
-          engine_version: '',
-          client_ip: '',
-          engine_name: '',
-          os_name: '',
-          os_version: '',
-          device_model: '',
-          device_vendor: '',
-          device_type: '',
-          screen_current_resolution_x: '',
-          screen_current_resolution_y: '',
-          screen_available_resolution_x: '',
-          screen_available_resolution_y: '',
-          language: '',
-          time_zone: '',
-          cpu_architecture: '',
-          uuid: '',
-        },
-        PUSH_NOTIFICATION_GRANTED: null,
-        FIREBASE_TOKEN_ID: null,
-
-        USR_OBJ: {},
-
-        debug_js: null,
-        DS_UI_EVENTS_GLB: {},
-        host: location.host,
-        req_id: 0,
-        build_info: {},
-        CACHE_REQ: {},
-        url_params: {
-          ...func.common.getParametersFromUrl(),
-          ...opt.url_params,
-        },
-      };
-      WEB_WORKER[SESSION_ID] = {};
-      return SESSION_OBJ[SESSION_ID];
+        code_bundle: glb.CODE_BUNDLE,
+        slim_bundle: glb.SLIM_BUNDLE,
+        url_params: opt.url_params,
+      });
     };
     const set_SESSION = async function () {
       for await (const key of ['gtp_token', 'app_token', 'prog_id', 'domain', 'engine_mode', 'crawler', 'app_id', 'route_id', 'menu_id', 'local_live_preview', 'project_data']) {
@@ -18911,22 +19264,7 @@ function xuda(...args) {
 
         // set defaults
         if (!_session[key]) {
-          var val = _session[key];
-          switch (key) {
-            case 'domain':
-              val = window.location.host;
-              break;
-            case 'engine_mode':
-              val = 'miniapp'; //was 'run'
-              break;
-            case 'app_id':
-              val = 'unknown';
-              break;
-
-            default:
-              break;
-          }
-          _session[key] = val;
+          func.runtime.session.set_default_value(_session, key);
         }
 
         // set exceptions
@@ -19042,51 +19380,7 @@ function xuda(...args) {
       _session.crawler = opt.crawler;
     };
     const set_SYS_GLOBAL_OBJ_CLIENT_INFO = function () {
-      const { engine_mode } = _session;
-      var _client_info = _session.SYS_GLOBAL_OBJ_CLIENT_INFO;
-
-      _client_info.fingerprint = get_fingerprint();
-
-      if (engine_mode === 'live_preview') {
-        _client_info.screen_current_resolution_x = window.innerWidth;
-        _client_info.screen_current_resolution_y = window.innerHeight;
-        _client_info.screen_available_resolution_x = window.innerWidth;
-        _client_info.screen_available_resolution_y = window.innerHeight;
-      } else {
-        _client_info.screen_current_resolution_x = components[6].value[0];
-        _client_info.screen_current_resolution_y = components[6].value[1];
-        _client_info.screen_available_resolution_x = components[7].value[0];
-        _client_info.screen_available_resolution_y = components[7].value[1];
-      }
-
-      const client = new ClientJS();
-
-      _client_info.device = func.utils.get_device();
-
-      const browser_data = client.getBrowserData();
-
-      _client_info.user_agent = browser_data.ua;
-
-      _client_info.browser_version = browser_data.browser.name;
-      _client_info.browser_name = browser_data.browser.version;
-      _client_info.engine_version = browser_data.engine.name;
-      _client_info.engine_name = browser_data.engine.version;
-      _client_info.os_name = browser_data.os.name;
-      _client_info.os_version = browser_data.os.version;
-      _client_info.device_model = browser_data.device.name;
-      _client_info.device_vendor = browser_data.device.name;
-      _client_info.device_type = browser_data.device.name;
-
-      _client_info.language = client.getLanguage();
-      _client_info.time_zone = client.getTimeZone();
-      _client_info.cpu_architecture = browser_data.cpu.architecture;
-
-      if (['android', 'ios', 'windows', 'macos', 'linux', 'live_preview'].includes(engine_mode) && func.utils.get_device()) {
-        _client_info.uuid = window.device.uuid;
-        if (window.device) {
-          _client_info.device_name = window.device.name;
-        }
-      }
+      func.runtime.session.populate_client_info(_session, components);
     };
     const init_globals = function () {
       const { app_id, worker_type } = _session;
@@ -19255,11 +19549,11 @@ func.index.call_worker = async function (SESSION_ID, obj, params, promiseP) {
     const set_promise_queue = function (worker_id) {
       var t = glb.worker_queue_num++;
       try {
-        WEB_WORKER[SESSION_ID][worker_id].promise_queue[t] = {
+        func.runtime.workers.set_promise(SESSION_ID, worker_id, t, {
           resolve: promiseP ? promiseP.resolve : resolve,
           reject: promiseP ? promiseP.reject : reject,
           worker_id,
-        };
+        });
       } catch (e) {
         console.log(worker_id);
       }
@@ -19350,17 +19644,12 @@ func.index.call_worker = async function (SESSION_ID, obj, params, promiseP) {
         return resolve();
       }
 
-      if (RUNTIME_SERVER_WEBSOCKET && RUNTIME_SERVER_WEBSOCKET_CONNECTED && (!_session.opt.app_computing_mode || _session.opt.app_computing_mode === 'server')) {
-        msg.process_pid = WEBSOCKET_PROCESS_PID;
-        msg = JSON.stringify(obj, func.utils.clean_stringify_null, '\t');
-        let msg_obj = JSON.parse(msg);
-        WEB_WORKER[SESSION_ID][worker_id].worker.emit('message', msg_obj);
-      } else {
-        msg = JSON.stringify(obj, func.utils.clean_stringify_null, '\t');
-        let msg_obj = JSON.parse(msg);
+      msg = JSON.stringify(obj, func.utils.clean_stringify_null, '\t');
+      let msg_obj = JSON.parse(msg);
+      if (!func.runtime.workers.is_server_transport(_session)) {
         msg_obj.data = JSON.stringify(msg_obj.data);
-        WEB_WORKER[SESSION_ID][worker_id].worker.postMessage(msg_obj);
       }
+      func.runtime.workers.send_message(SESSION_ID, worker_id, _session, msg_obj, WEBSOCKET_PROCESS_PID);
     } catch (e) {
       console.error(e);
       return reject(e);
@@ -19638,7 +19927,7 @@ func.index.init_document_listeners = function () {
     if (ret?.session_stat === 3) {
       await func.index.delete_pouch();
       // window.location.href = `https://${_session.domain}/error?error_code=408`;
-      window.top.location.reload(); //href = `https://${_session.domain}?ts=${Date.now()}`;
+      platform.reload_top_window(); //href = `https://${_session.domain}?ts=${Date.now()}`;
     }
     $('body').removeClass('get_support_request');
     $('body').find('.get_support_request_title').remove();
@@ -19659,9 +19948,10 @@ func.index.init_document_listeners = function () {
     _session.res_token = ret.res_token;
   }, 30000);
 
-  glb.WINDOW_LOCATION_SEARCH = window.location.search;
+  glb.WINDOW_LOCATION_SEARCH = platform.get_url_search();
 };
 func.index.checkConnectivity = async function () {
+  const platform = func.runtime.platform;
   const endpoints = ['https://xuda.ai/favicon.ico']; //'https://www.cloudflare.com/favicon.ico',
 
   const promises = endpoints.map((url) =>
@@ -19674,23 +19964,24 @@ func.index.checkConnectivity = async function () {
   IS_ONLINE = results.some((result) => result === true);
 
   // Add event listeners for online/offline events
-  window.addEventListener('online', function () {
+  platform.add_window_listener('online', function () {
     IS_ONLINE = true;
     $('body').trigger('set_db_replication_from_server');
   });
 
-  window.addEventListener('offline', function () {
+  platform.add_window_listener('offline', function () {
     IS_ONLINE = false;
   });
 };
 
 func.index.init_service_workers = function () {
-  if ('serviceWorker' in navigator) {
-    navigator.serviceWorker.addEventListener('message', function (event) {
+  const platform = func.runtime.platform;
+  if (platform.has_service_worker()) {
+    platform.add_service_worker_listener('message', function (event) {
       console.log('serviceWorker message:', event);
     });
 
-    navigator.serviceWorker.register('xuda-sw.js').then(
+    platform.register_service_worker('xuda-sw.js').then(
       function (registration) {
         // Registration was successful
         console.log('ServiceWorker registration successful with scope: ', registration.scope);
@@ -19715,7 +20006,8 @@ func.index.delete_pouch = async function (SESSION_ID = Object.keys(SESSION_OBJ)[
 };
 
 func.index.new_webworker = async function (SESSION_ID, prog_obj, obj) {
-  var worker_id = Object.keys(WEB_WORKER[SESSION_ID]).length + 1;
+  const worker_registry = func.runtime.workers.ensure_registry(SESSION_ID);
+  var worker_id = Object.keys(worker_registry).length + 1;
 
   var _session = SESSION_OBJ[SESSION_ID];
   if (!_session.engine_mode === 'docker') {
@@ -19727,17 +20019,7 @@ func.index.new_webworker = async function (SESSION_ID, prog_obj, obj) {
     build_id = XUDA_BUILD_ID;
   }
 
-  const worker_name =
-    `${typeof _session.SLIM_BUNDLE === 'undefined' || !_session.SLIM_BUNDLE ? '' : 'Slim '}${prog_obj.menuName} worker` +
-    // (prog_obj.menuName || "xuda.ai worker") +
-    ' ' +
-    glb.worker_type +
-    ': #' +
-    worker_id.toString() +
-    ' ' +
-    (build_id || '') +
-    ' ' +
-    _session.domain;
+  const worker_name = func.runtime.workers.build_worker_name(glb.worker_type, _session, prog_obj, worker_id, build_id);
 
   const init_worker_session = function (worker_id) {
     var _session = _.cloneDeep(SESSION_OBJ[SESSION_ID]);
@@ -19796,33 +20078,31 @@ func.index.new_webworker = async function (SESSION_ID, prog_obj, obj) {
     $.map(_session.DS_GLB, function (val, i) {
       ds_arr.push(i);
     });
-    WEB_WORKER[SESSION_ID][worker_id].ds_arr = ds_arr;
+    worker_registry[worker_id].ds_arr = ds_arr;
 
     delete data.SESSION_INFO.DS_UI_EVENTS_GLB; // contains function produce error
 
-    if (RUNTIME_SERVER_WEBSOCKET && RUNTIME_SERVER_WEBSOCKET_CONNECTED && (!_session.opt.app_computing_mode || _session.opt.app_computing_mode === 'server')) {
-      WEB_WORKER[SESSION_ID][worker_id].worker.emit('message', {
-        service: 'init',
-        data: data, //JSON.stringify(data),
-        worker_id: worker_id,
-      });
-    } else {
-      WEB_WORKER[SESSION_ID][worker_id].worker.postMessage({
+    func.runtime.workers.send_message(
+      SESSION_ID,
+      worker_id,
+      _session,
+      {
         service: 'init',
-        data: JSON.stringify(data),
+        data: func.runtime.workers.is_server_transport(_session) ? data : JSON.stringify(data),
         worker_id: worker_id,
-      });
-    }
+      },
+      WEBSOCKET_PROCESS_PID,
+    );
   };
   const create_worker = async function () {
     return new Promise((resolve, reject) => {
       if (glb.worker_type === 'Dev') {
-        WEB_WORKER[SESSION_ID][worker_id] = {
+        func.runtime.workers.set_registry_entry(SESSION_ID, worker_id, {
           worker: new Worker('js/xuda_worker.js', {
             name: worker_name,
           }),
           promise_queue: {},
-        };
+        });
       } else {
         function getWorkerURL(url) {
           const content = `importScripts( "${url}" );`;
@@ -19830,14 +20110,14 @@ func.index.new_webworker = async function (SESSION_ID, prog_obj, obj) {
         }
         const _session = SESSION_OBJ[SESSION_ID];
         let blob = getWorkerURL(func.common.get_url(SESSION_ID, 'dist', func.utils.get_resource_filename(['live_preview', 'miniapp'].includes(_session.engine_mode) ? '' : _session?.opt?.app_build_id, 'runtime/js/xuda_worker.js')));
-        WEB_WORKER[SESSION_ID][worker_id] = {
+        func.runtime.workers.set_registry_entry(SESSION_ID, worker_id, {
           worker: new Worker(blob, {
             name: worker_name,
           }),
           promise_queue: {},
-        };
+        });
       }
-      WEB_WORKER[SESSION_ID][worker_id].worker.addEventListener(
+      func.runtime.workers.get_registry_entry(SESSION_ID, worker_id).worker.addEventListener(
         'message',
         function (e) {
           if (e.data.service === 'worker_ready') {
@@ -19851,12 +20131,12 @@ func.index.new_webworker = async function (SESSION_ID, prog_obj, obj) {
   };
   const create_websocket = async function () {
     return new Promise((resolve, reject) => {
-      WEB_WORKER[SESSION_ID][worker_id] = {
+      func.runtime.workers.set_registry_entry(SESSION_ID, worker_id, {
         worker: RUNTIME_SERVER_WEBSOCKET,
         promise_queue: {},
-      };
+      });
 
-      WEB_WORKER[SESSION_ID][worker_id].worker.on('message', async (e) => {
+      func.runtime.workers.get_registry_entry(SESSION_ID, worker_id).worker.on('message', async (e) => {
         if (['deployment_server', 'http_call'].includes(e.source)) return;
         worker_functions({ data: e });
       });
@@ -20061,13 +20341,7 @@ func.index.new_webworker = async function (SESSION_ID, prog_obj, obj) {
           msg.data.session_id = SESSION_ID;
           msg.data.data = data;
 
-          if (RUNTIME_SERVER_WEBSOCKET && RUNTIME_SERVER_WEBSOCKET_CONNECTED && (!_session.opt.app_computing_mode || _session.opt.app_computing_mode === 'server')) {
-            msg.process_pid = WEBSOCKET_PROCESS_PID;
-            WEB_WORKER[SESSION_ID][worker_id].worker.emit('message', msg);
-            // WEB_WORKER[SESSION_ID][worker_id].worker.send(JSON.stringify(msg));
-          } else {
-            WEB_WORKER[SESSION_ID][worker_id].worker.postMessage(msg);
-          }
+          func.runtime.workers.send_message(SESSION_ID, worker_id, _session, msg, WEBSOCKET_PROCESS_PID);
           _resolve();
         },
         execute_local_sava_data: async function () {
@@ -20084,12 +20358,7 @@ func.index.new_webworker = async function (SESSION_ID, prog_obj, obj) {
           msg.data.session_id = SESSION_ID;
           msg.data.data = data;
 
-          if (RUNTIME_SERVER_WEBSOCKET && RUNTIME_SERVER_WEBSOCKET_CONNECTED && (!_session.opt.app_computing_mode || _session.opt.app_computing_mode === 'server')) {
-            msg.process_pid = WEBSOCKET_PROCESS_PID;
-            WEB_WORKER[SESSION_ID][worker_id].worker.emit('message', msg);
-          } else {
-            WEB_WORKER[SESSION_ID][worker_id].worker.postMessage(msg);
-          }
+          func.runtime.workers.send_message(SESSION_ID, worker_id, _session, msg, WEBSOCKET_PROCESS_PID);
           _resolve();
         },
         write_debug_log: function (params) {
@@ -20172,12 +20441,12 @@ func.index.new_webworker = async function (SESSION_ID, prog_obj, obj) {
       };
 
       const get_promise_queue = function (t, worker_id) {
-        if (!WEB_WORKER[SESSION_ID][worker_id]) {
+        if (!func.runtime.workers.get_registry_entry(SESSION_ID, worker_id)) {
           console.warn('worker job not found');
           return;
         }
 
-        return WEB_WORKER[SESSION_ID][worker_id].promise_queue[t];
+        return func.runtime.workers.get_promise(SESSION_ID, worker_id, t);
       };
 
       const promise_ret = await get_promise_queue(e.data.promise_queue_id, e.data.worker_id);
@@ -20186,7 +20455,7 @@ func.index.new_webworker = async function (SESSION_ID, prog_obj, obj) {
         if (!promise_ret) return resolve();
         promise_ret.resolve(params);
         setTimeout(function () {
-          if (WEB_WORKER[SESSION_ID][e.data.worker_id]) delete WEB_WORKER[SESSION_ID][e.data.worker_id].promise_queue[e.data.promise_queue_id];
+          func.runtime.workers.delete_promise(SESSION_ID, e.data.worker_id, e.data.promise_queue_id);
         }, 1000);
       };