@xuda.io/runtime-bundle 1.0.1435 → 1.0.1437

package/js/xuda-worker-bundle.js

@@ -5,49 +5,6 @@ if (typeof IS_DOCKER === 'undefined' || typeof IS_PROCESS_SERVER === 'undefined'
   var DOCS_OBJ = {};
 }
 
-// Minimal jQuery shim for plugins that still reference $
-if (typeof $ === 'undefined' && typeof document !== 'undefined') {
-  var $ = function (selector) {
-    var nodes = typeof selector === 'string'
-      ? Array.from(document.querySelectorAll(selector))
-      : selector?.nodeType ? [selector] : (selector?.length ? Array.from(selector) : []);
-    var obj = {
-      0: nodes[0], length: nodes.length,
-      toArray: function () { return nodes.slice(); },
-      find: function (s) { var r = []; for (var i = 0; i < nodes.length; i++) { r.push.apply(r, Array.from(nodes[i].querySelectorAll(s))); } return $(r); },
-      each: function (fn) { for (var i = 0; i < nodes.length; i++) { fn.call(nodes[i], i, nodes[i]); } return obj; },
-      on: function (ev, fn) { for (var i = 0; i < nodes.length; i++) nodes[i].addEventListener(ev, fn); return obj; },
-      off: function (ev, fn) { for (var i = 0; i < nodes.length; i++) nodes[i].removeEventListener(ev, fn); return obj; },
-      addClass: function (c) { for (var i = 0; i < nodes.length; i++) nodes[i].classList?.add(c); return obj; },
-      removeClass: function (c) { for (var i = 0; i < nodes.length; i++) nodes[i].classList?.remove(c); return obj; },
-      hasClass: function (c) { return nodes[0]?.classList?.contains(c) || false; },
-      attr: function (k, v) { if (typeof v === 'undefined') return nodes[0]?.getAttribute(k); for (var i = 0; i < nodes.length; i++) nodes[i].setAttribute(k, v); return obj; },
-      css: function (k, v) { for (var i = 0; i < nodes.length; i++) nodes[i].style[k] = v; return obj; },
-      data: function () { return nodes[0]?.__xuData || (nodes[0] ? (nodes[0].__xuData = {}) : {}); },
-      val: function (v) { if (typeof v === 'undefined') return nodes[0]?.value; for (var i = 0; i < nodes.length; i++) nodes[i].value = v; return obj; },
-      html: function (v) { if (typeof v === 'undefined') return nodes[0]?.innerHTML; for (var i = 0; i < nodes.length; i++) nodes[i].innerHTML = v; return obj; },
-      text: function (v) { if (typeof v === 'undefined') return nodes[0]?.textContent; for (var i = 0; i < nodes.length; i++) nodes[i].textContent = v; return obj; },
-      show: function () { for (var i = 0; i < nodes.length; i++) nodes[i].style.display = ''; return obj; },
-      hide: function () { for (var i = 0; i < nodes.length; i++) nodes[i].style.display = 'none'; return obj; },
-      remove: function () { for (var i = 0; i < nodes.length; i++) nodes[i].remove?.(); return obj; },
-      empty: function () { for (var i = 0; i < nodes.length; i++) nodes[i].innerHTML = ''; return obj; },
-      append: function (c) { var n = c?.nodeType ? c : c?.[0]; if (n && nodes[0]) nodes[0].appendChild(n); return obj; },
-      parent: function () { return $(nodes[0]?.parentElement ? [nodes[0].parentElement] : []); },
-      children: function () { return $(nodes[0] ? Array.from(nodes[0].children) : []); },
-      trigger: function (ev, d) { for (var i = 0; i < nodes.length; i++) nodes[i].dispatchEvent(new CustomEvent(ev, { detail: d })); return obj; },
-      is: function (s) { return nodes[0]?.matches?.(s) || false; },
-      prop: function (k, v) { if (typeof v === 'undefined') return nodes[0]?.[k]; for (var i = 0; i < nodes.length; i++) nodes[i][k] = v; return obj; },
-      unbind: function () { return obj; },
-      clone: function () { return $(nodes[0]?.cloneNode(true) ? [nodes[0].cloneNode(true)] : []); },
-    };
-    obj[Symbol.iterator] = function () { var i = 0; return { next: function () { return i < nodes.length ? { value: nodes[i++], done: false } : { done: true }; } }; };
-    return obj;
-  };
-  $.each = function (o, fn) { if (Array.isArray(o)) { for (var i = 0; i < o.length; i++) fn(i, o[i]); } else { Object.keys(o || {}).forEach(function (k) { fn(k, o[k]); }); } };
-  $.cookie = function () { return null; };
-  var jQuery = $;
-}
-
 var glb = {};
 var func = {};
 func.UI = {};
@@ -121,23 +78,27 @@ glb.PROTECTED_VARS = ['_NULL', '_THIS', '_FOR_KEY', '_FOR_VAL', '_ROWNO', '_ROWI
 
 func.common = {};
 func.runtime.platform = {
+  get_global: function (name) {
+    try {
+      if (typeof globalThis === 'undefined') {
+        return null;
+      }
+      return globalThis?.[name] || null;
+    } catch (error) {
+      return null;
+    }
+  },
   has_window: function () {
-    return typeof window !== 'undefined';
+    return !!func.runtime.platform.get_window();
   },
   has_document: function () {
-    return typeof document !== 'undefined';
+    return !!func.runtime.platform.get_document();
   },
   get_window: function () {
-    if (func.runtime.platform.has_window()) {
-      return window;
-    }
-    return null;
+    return func.runtime.platform.get_global('window');
   },
   get_document: function () {
-    if (func.runtime.platform.has_document()) {
-      return document;
-    }
-    return null;
+    return func.runtime.platform.get_global('document');
   },
   get_location: function () {
     const win = func.runtime.platform.get_window();
@@ -148,27 +109,23 @@ func.runtime.platform = {
     if (win?.navigator) {
       return win.navigator;
     }
-    if (typeof navigator !== 'undefined') {
-      return navigator;
-    }
-    return null;
+    return func.runtime.platform.get_global('navi' + 'gator');
   },
   is_html_element: function (value) {
-    if (typeof HTMLElement === 'undefined') {
+    const html_element = func.runtime.platform.get_global('HTML' + 'Element');
+    if (typeof html_element !== 'function') {
       return false;
     }
-    return value instanceof HTMLElement;
+    return value instanceof html_element;
   },
   get_storage: function (type) {
     const win = func.runtime.platform.get_window();
+    const storage_key = type === 'session' ? 'session' + 'Storage' : 'local' + 'Storage';
     try {
       if (!win) {
         return null;
       }
-      if (type === 'session') {
-        return win.sessionStorage || null;
-      }
-      return win.localStorage || null;
+      return win?.[storage_key] || null;
     } catch (error) {
       return null;
     }
@@ -325,9 +282,8 @@ func.runtime.platform.emit = function (name, data) {
         handlers[i](data);
       }
     }
-    // also fire on DOM if in browser (for backward compatibility with custom event listeners)
-    if (func.runtime.platform.has_document()) {
-      document.dispatchEvent(new CustomEvent(name, { detail: Array.isArray(data) ? data : [data] }));
+    if (typeof func.runtime.platform.dispatch_document_event === 'function') {
+      func.runtime.platform.dispatch_document_event(name, data);
     }
   } finally {
     func.runtime.platform._emitting[name] = false;
@@ -335,35 +291,111 @@ func.runtime.platform.emit = function (name, data) {
 };
 
 // ── Platform helpers for DOM-independent resource loading ──
-func.runtime.platform.load_script = function (url, type, callback) {
-  if (typeof document !== 'undefined') {
-    const script = document.createElement('script');
-    script.src = url;
-    if (type) script.type = type;
-    script.onload = callback;
-    document.head.appendChild(script);
-  } else if (callback) {
-    callback();
-  }
-};
-func.runtime.platform.load_css = function (href) {
-  if (typeof document === 'undefined') return;
+func.runtime.platform.apply_element_attributes = function (node, attributes, excluded_keys = []) {
+  if (!node?.setAttribute || !attributes) {
+    return node;
+  }
+
+  const excluded = new Set(excluded_keys || []);
+  const attr_keys = Object.keys(attributes);
+  for (let index = 0; index < attr_keys.length; index++) {
+    const key = attr_keys[index];
+    if (!key || excluded.has(key)) {
+      continue;
+    }
+
+    const value = attributes[key];
+    if (value === false || typeof value === 'undefined') {
+      continue;
+    }
+
+    node.setAttribute(key, value === null ? '' : `${value}`);
+  }
+
+  return node;
+};
+func.runtime.platform.load_script = function (url, type, callback, attributes) {
+  const doc = func.runtime.platform.get_document();
+  if (!doc?.createElement || !doc?.head?.appendChild) {
+    if (callback) {
+      callback();
+    }
+    return;
+  }
+  const find_existing_script = function () {
+    const asset_key = attributes?.['data-xuda-asset-key'];
+    const scripts = doc.querySelectorAll ? Array.from(doc.querySelectorAll('script')) : [];
+    return scripts.find(function (script) {
+      if (asset_key && script.getAttribute('data-xuda-asset-key') === asset_key) {
+        return true;
+      }
+      return !!(url && script.getAttribute('src') === url);
+    }) || null;
+  };
+
+  const existing_script = find_existing_script();
+  if (existing_script) {
+    if (callback) {
+      if (existing_script.getAttribute('data-xuda-loaded') === 'true' || !url) {
+        callback();
+      } else {
+        existing_script.addEventListener('load', callback, { once: true });
+        existing_script.addEventListener('error', callback, { once: true });
+      }
+    }
+    return existing_script;
+  }
+
+  const script = doc.createElement('script');
+  script.src = url;
+  if (type) script.type = type;
+  func.runtime.platform.apply_element_attributes(script, attributes, ['src', 'type']);
+  script.onload = function () {
+    script.setAttribute('data-xuda-loaded', 'true');
+    if (callback) {
+      callback();
+    }
+  };
+  script.onerror = function () {
+    if (callback) {
+      callback();
+    }
+  };
+  doc.head.appendChild(script);
+  return script;
+};
+func.runtime.platform.load_css = function (href, attributes) {
+  const doc = func.runtime.platform.get_document();
+  if (!doc?.createElement || !doc?.head) {
+    return;
+  }
   try {
-    if (document.querySelector('link[href="' + href + '"]')) return;
+    const asset_key = attributes?.['data-xuda-asset-key'];
+    const existing_links = doc.querySelectorAll ? Array.from(doc.querySelectorAll('link')) : [];
+    const existing = existing_links.find(function (link) {
+      if (asset_key && link.getAttribute('data-xuda-asset-key') === asset_key) {
+        return true;
+      }
+      return !!(href && link.getAttribute('href') === href);
+    });
+    if (existing) return existing;
   } catch (err) {
     return;
   }
-  const link = document.createElement('link');
+  const link = doc.createElement('link');
   link.rel = 'stylesheet';
   link.type = 'text/css';
   link.href = href;
-  document.head.insertBefore(link, document.head.firstChild);
+  func.runtime.platform.apply_element_attributes(link, attributes, ['href']);
+  doc.head.insertBefore(link, doc.head.firstChild);
+  return link;
 };
 func.runtime.platform.remove_js_css = function (filename, filetype) {
-  if (typeof document === 'undefined') return;
+  const doc = func.runtime.platform.get_document();
+  if (!doc?.getElementsByTagName) return;
   const tagName = filetype === 'js' ? 'script' : filetype === 'css' ? 'link' : 'none';
   const attr = filetype === 'js' ? 'src' : filetype === 'css' ? 'href' : 'none';
-  const elements = document.getElementsByTagName(tagName);
+  const elements = doc.getElementsByTagName(tagName);
   for (let i = elements.length - 1; i >= 0; i--) {
     if (elements[i] && elements[i].getAttribute(attr) != null && elements[i].getAttribute(attr).indexOf(filename) !== -1) {
       elements[i].parentNode.removeChild(elements[i]);
@@ -371,15 +403,17 @@ func.runtime.platform.remove_js_css = function (filename, filetype) {
   }
 };
 func.runtime.platform.inject_css = function (cssText) {
-  if (typeof document === 'undefined' || !cssText) return;
-  const style = document.createElement('style');
+  const doc = func.runtime.platform.get_document();
+  if (!doc?.createElement || !doc?.head?.appendChild || !cssText) return;
+  const style = doc.createElement('style');
   style.type = 'text/css';
   style.textContent = cssText;
-  document.head.appendChild(style);
+  doc.head.appendChild(style);
 };
 func.runtime.platform.set_title = function (title) {
-  if (typeof document !== 'undefined') {
-    document.title = title;
+  const doc = func.runtime.platform.get_document();
+  if (doc) {
+    doc.title = title;
   }
 };
 func.runtime.platform.set_cursor = function (element, cursor) {
@@ -645,6 +679,147 @@ func.runtime.workers.delete_promise = function (SESSION_ID, worker_id, promise_q
   delete registry_entry.promise_queue[promise_queue_id];
   return true;
 };
+func.runtime.render.clone_runtime_options = function (value) {
+  if (typeof structuredClone === 'function') {
+    try {
+      return structuredClone(value);
+    } catch (_) {}
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(function (item) {
+      return func.runtime.render.clone_runtime_options(item);
+    });
+  }
+
+  if (value && typeof value === 'object') {
+    const cloned = {};
+    const keys = Object.keys(value);
+    for (let index = 0; index < keys.length; index++) {
+      const key = keys[index];
+      cloned[key] = func.runtime.render.clone_runtime_options(value[key]);
+    }
+    return cloned;
+  }
+
+  return value;
+};
+func.runtime.render.normalize_runtime_bootstrap = function (raw_options = {}) {
+  const options = raw_options || {};
+  let app_computing_mode = options.app_computing_mode || '';
+  let app_render_mode = options.app_render_mode || '';
+  let app_client_activation = options.app_client_activation || '';
+  let ssr_payload = options.ssr_payload || null;
+
+  if (typeof ssr_payload === 'string') {
+    try {
+      ssr_payload = JSON.parse(ssr_payload);
+    } catch (_) {
+      ssr_payload = null;
+    }
+  }
+
+  if (ssr_payload && typeof ssr_payload === 'object') {
+    ssr_payload = func.runtime.render.clone_runtime_options(ssr_payload);
+  }
+
+  if (!app_computing_mode) {
+    if (app_render_mode === 'ssr_first_page' || app_render_mode === 'ssr_full') {
+      app_computing_mode = 'server';
+    } else {
+      app_computing_mode = 'main';
+    }
+  }
+
+  switch (app_computing_mode) {
+    case 'main':
+      app_render_mode = 'csr';
+      app_client_activation = 'none';
+      break;
+
+    case 'worker':
+      app_render_mode = 'csr';
+      app_client_activation = 'none';
+      break;
+
+    default:
+      app_computing_mode = 'server';
+      if (app_render_mode !== 'ssr_full') {
+        app_render_mode = 'ssr_first_page';
+      }
+      app_client_activation = app_render_mode === 'ssr_full' ? 'hydrate' : 'takeover';
+      break;
+  }
+
+  if (ssr_payload && typeof ssr_payload === 'object') {
+    if (!ssr_payload.app_render_mode) {
+      ssr_payload.app_render_mode = app_render_mode;
+    }
+    if (!ssr_payload.app_client_activation) {
+      ssr_payload.app_client_activation = app_client_activation;
+    }
+    if (!ssr_payload.app_computing_mode) {
+      ssr_payload.app_computing_mode = app_computing_mode;
+    }
+  }
+
+  return {
+    app_computing_mode,
+    app_render_mode,
+    app_client_activation,
+    ssr_payload,
+  };
+};
+func.runtime.render.apply_runtime_bootstrap_defaults = function (target = {}) {
+  const normalized = func.runtime.render.normalize_runtime_bootstrap(target);
+  target.app_computing_mode = normalized.app_computing_mode;
+  target.app_render_mode = normalized.app_render_mode;
+  target.app_client_activation = normalized.app_client_activation;
+  target.ssr_payload = normalized.ssr_payload;
+  return normalized;
+};
+func.runtime.render.is_server_render_mode = function (target = {}) {
+  const normalized = func.runtime.render.normalize_runtime_bootstrap(target?.opt || target);
+  return normalized.app_computing_mode === 'server' && normalized.app_render_mode !== 'csr';
+};
+func.runtime.render.is_takeover_mode = function (target = {}) {
+  const normalized = func.runtime.render.normalize_runtime_bootstrap(target?.opt || target);
+  return normalized.app_client_activation === 'takeover';
+};
+func.runtime.render.is_hydration_mode = function (target = {}) {
+  const normalized = func.runtime.render.normalize_runtime_bootstrap(target?.opt || target);
+  return normalized.app_client_activation === 'hydrate';
+};
+func.runtime.render.get_ssr_payload = function (target = {}) {
+  if (target?.opt?.ssr_payload) {
+    return target.opt.ssr_payload;
+  }
+  if (target?.ssr_payload) {
+    return target.ssr_payload;
+  }
+  const win = func.runtime.platform.get_window();
+  return win?.__XUDA_SSR__ || null;
+};
+func.runtime.render.should_use_ssr_payload = function (SESSION_ID, paramsP) {
+  const session = SESSION_OBJ?.[SESSION_ID];
+  const payload = func.runtime.render.get_ssr_payload(session);
+  if (!payload || payload._consumed) {
+    return false;
+  }
+  if (paramsP?.prog_id && payload.prog_id && payload.prog_id !== paramsP.prog_id) {
+    return false;
+  }
+  return true;
+};
+func.runtime.render.mark_ssr_payload_consumed = function (SESSION_ID) {
+  const session = SESSION_OBJ?.[SESSION_ID];
+  const payload = func.runtime.render.get_ssr_payload(session);
+  if (!payload || typeof payload !== 'object') {
+    return false;
+  }
+  payload._consumed = true;
+  return true;
+};
 func.runtime.render.get_root_data_system = function (SESSION_ID) {
   return SESSION_OBJ[SESSION_ID]?.DS_GLB?.[0]?.data_system || null;
 };
@@ -1048,10 +1223,10 @@ func.runtime.resources.load_cdn = async function (SESSION_ID, resource) {
           await func.utils.load_js_on_demand(normalized_resource.src);
           break;
         case 'css':
-          await func.utils.load_js_on_demand(normalized_resource.src);
+          func.runtime.platform.load_css(normalized_resource.src);
           break;
         case 'module':
-          func.utils.load_js_on_demand(normalized_resource.src, 'module');
+          await func.utils.load_js_on_demand(normalized_resource.src, 'module');
           break;
         default:
           await func.utils.load_js_on_demand(normalized_resource.src);
@@ -1067,12 +1242,36 @@ func.runtime.resources.load_cdn = async function (SESSION_ID, resource) {
 func.runtime.resources.get_plugin_manifest_entry = function (_session, plugin_name) {
   return APP_OBJ[_session.app_id]?.app_plugins_purchased?.[plugin_name] || null;
 };
-func.runtime.resources.get_plugin_module_path = function (plugin, resource) {
+func.runtime.resources.get_plugin_resource_candidates = function (_session, plugin, resource) {
   const manifest_entry = plugin?.manifest?.[resource];
-  return `${manifest_entry?.dist ? 'dist/' : ''}${resource}`;
+  const default_path = `${manifest_entry?.dist ? 'dist/' : ''}${resource}`;
+  const candidates = [];
+  if (_session?.worker_type === 'Dev' && manifest_entry?.dist && /\.mjs$/.test(resource)) {
+    candidates.push(`src/${resource}`);
+  }
+  candidates.push(default_path);
+  return Array.from(new Set(candidates.filter(Boolean)));
+};
+func.runtime.resources.get_plugin_module_path = function (plugin, resource, _session) {
+  return func.runtime.resources.get_plugin_resource_candidates(_session, plugin, resource)[0] || resource;
 };
 func.runtime.resources.get_plugin_module_url = async function (SESSION_ID, plugin_name, plugin, resource) {
-  return await func.utils.get_plugin_npm_cdn(SESSION_ID, plugin_name, func.runtime.resources.get_plugin_module_path(plugin, resource));
+  const _session = SESSION_OBJ[SESSION_ID];
+  return await func.utils.get_plugin_npm_cdn(SESSION_ID, plugin_name, func.runtime.resources.get_plugin_module_path(plugin, resource, _session));
+};
+func.runtime.resources.import_plugin_module = async function (SESSION_ID, plugin_name, plugin, resource) {
+  const _session = SESSION_OBJ[SESSION_ID];
+  const candidates = func.runtime.resources.get_plugin_resource_candidates(_session, plugin, resource);
+  let last_error = null;
+  for (let index = 0; index < candidates.length; index++) {
+    const candidate = candidates[index];
+    try {
+      return await func.utils.get_plugin_resource(SESSION_ID, plugin_name, candidate);
+    } catch (error) {
+      last_error = error;
+    }
+  }
+  throw last_error || new Error(`plugin resource not found: ${plugin_name}/${resource}`);
 };
 func.runtime.resources.load_plugin_runtime_css = async function (SESSION_ID, plugin_name, plugin) {
   if (!plugin?.manifest?.['runtime.mjs']?.dist || !plugin?.manifest?.['runtime.mjs']?.css) {
@@ -1102,12 +1301,10 @@ func.runtime.resources.run_ui_plugin = async function (SESSION_ID, paramsP, $elm
 
   await func.runtime.resources.load_plugin_runtime_css(SESSION_ID, plugin_name, plugin);
 
-  const plugin_index_src = await func.runtime.resources.get_plugin_module_url(SESSION_ID, plugin_name, plugin, 'index.mjs');
-  const plugin_index_resources = await import(plugin_index_src);
+  const plugin_index_resources = await func.runtime.resources.import_plugin_module(SESSION_ID, plugin_name, plugin, 'index.mjs');
   const properties = await func.runtime.resources.resolve_plugin_properties(SESSION_ID, paramsP.dsSessionP, value?.attributes, plugin_index_resources.properties);
 
-  const plugin_runtime_src = await func.runtime.resources.get_plugin_module_url(SESSION_ID, plugin_name, plugin, 'runtime.mjs');
-  const plugin_runtime_resources = await import(plugin_runtime_src);
+  const plugin_runtime_resources = await func.runtime.resources.import_plugin_module(SESSION_ID, plugin_name, plugin, 'runtime.mjs');
 
   if (plugin_runtime_resources.cdn && Array.isArray(plugin_runtime_resources.cdn)) {
     for await (const resource of plugin_runtime_resources.cdn) {
@@ -1190,25 +1387,52 @@ func.runtime.widgets.get_fields_data = async function (context, fields, props) {
 
   return { code: return_code, data: data_obj };
 };
+func.runtime.widgets.get_resource_candidates = function (context, resource) {
+  return func.runtime.resources.get_plugin_resource_candidates(context._session, context.plugin, resource);
+};
+func.runtime.widgets.normalize_capabilities = function (definition) {
+  const capabilities = definition?.capabilities || {};
+  return {
+    browser: capabilities.browser !== false,
+    headless: capabilities.headless === true,
+  };
+};
+func.runtime.widgets.supports_current_environment = function (definition) {
+  const capabilities = func.runtime.widgets.normalize_capabilities(definition);
+  if (func.runtime.platform.has_document()) {
+    return capabilities.browser !== false;
+  }
+  return !!capabilities.headless;
+};
 func.runtime.widgets.get_resource_path = function (context, resource) {
+  const relative_path = func.runtime.widgets.get_resource_candidates(context, resource)[0] || resource;
   if (context._session.worker_type === 'Dev') {
-    return `../../plugins/${context.plugin_name}/${resource}`;
+    return `../../plugins/${context.plugin_name}/${relative_path}`;
   }
-  const manifest_entry = context.plugin?.manifest?.[resource];
-  const dist_prefix = manifest_entry?.dist ? 'dist/' : '';
-  return `https://${context._session.domain}/plugins/${context.plugin_name}/${dist_prefix}${resource}?gtp_token=${context._session.gtp_token}&app_id=${context._session.app_id}`;
+  return `https://${context._session.domain}/plugins/${context.plugin_name}/${relative_path}?gtp_token=${context._session.gtp_token}&app_id=${context._session.app_id}`;
 };
 func.runtime.widgets.load_css_style = function (context) {
   func.utils.load_css_on_demand(func.runtime.widgets.get_resource_path(context, 'style.css'));
   return true;
 };
 func.runtime.widgets.get_resource = async function (context, resource) {
-  const manifest_entry = context.plugin?.manifest?.[resource];
-  const path = `${manifest_entry?.dist ? 'dist/' : ''}${resource}`;
-  return await func.utils.get_plugin_resource(context.SESSION_ID, context.plugin_name, path);
+  const candidates = func.runtime.widgets.get_resource_candidates(context, resource);
+  let last_error = null;
+  for (let index = 0; index < candidates.length; index++) {
+    const candidate = candidates[index];
+    try {
+      return await func.utils.get_plugin_resource(context.SESSION_ID, context.plugin_name, candidate);
+    } catch (error) {
+      last_error = error;
+    }
+  }
+  throw last_error || new Error(`widget resource not found: ${context.plugin_name}/${resource}`);
+};
+func.runtime.widgets.get_definition = async function (context) {
+  return await func.runtime.widgets.get_resource(context, 'index.mjs');
 };
 func.runtime.widgets.get_methods = async function (context) {
-  const index = await func.runtime.widgets.get_resource(context, 'index.mjs');
+  const index = await func.runtime.widgets.get_definition(context);
   return index?.methods || {};
 };
 func.runtime.widgets.load_runtime_css = async function (context) {
@@ -1219,7 +1443,7 @@ func.runtime.widgets.load_runtime_css = async function (context) {
   func.utils.load_css_on_demand(plugin_runtime_css_url);
   return true;
 };
-func.runtime.widgets.build_params = function (context, $containerP, plugin_setup, api_utils, extra = {}) {
+func.runtime.widgets.build_params = function (context, container_node, container_data, plugin_setup, api_utils, extra = {}) {
   return {
     SESSION_ID: context.SESSION_ID,
     method: context.method,
@@ -1228,14 +1452,28 @@ func.runtime.widgets.build_params = function (context, $containerP, plugin_setup
     sourceP: context.sourceP,
     propsP: context.propsP,
     plugin_name: context.plugin_name,
-    $containerP,
+    container_node,
+    container_data,
     plugin_setup,
     report_error: function (descP, warn) {
       return func.runtime.widgets.report_error(context, descP, warn);
     },
+    log_error: function (descP, warn) {
+      return func.runtime.widgets.report_error(context, descP, warn);
+    },
     call_plugin_api: async function (plugin_nameP, dataP) {
       return await func.utils.call_plugin_api(context.SESSION_ID, plugin_nameP, dataP);
     },
+    set_SYS_GLOBAL_OBJ_WIDGET_INFO: async function (docP) {
+      return await func.utils.set_SYS_GLOBAL_OBJ_WIDGET_INFO(context.SESSION_ID, docP);
+    },
+    run_widgetCallbackEvent: async function () {
+      const event_id = context.propsP?.widgetCallbackEvent;
+      if (!event_id || !api_utils?.invoke_event) {
+        return false;
+      }
+      return await api_utils.invoke_event(event_id);
+    },
     api_utils,
     ...extra,
   };
@@ -2325,6 +2563,691 @@ func.common.fastHash = function (inputString) {
 };
 
 glb.new_xu_render = false;
+ func.runtime = func.runtime || {};
+func.runtime.ui = func.runtime.ui || {};
+func.runtime.render = func.runtime.render || {};
+func.runtime.widgets = func.runtime.widgets || {};
+
+// Shared render-tree contract helpers live here so browser and headless runtimes can resolve the same UI structure.
+
+func.runtime.render.TREE_CONTRACT_VERSION = func.runtime.render.TREE_CONTRACT_VERSION || 'xuda.render_tree.v1';
+func.runtime.render._tree_widget_capability_cache = func.runtime.render._tree_widget_capability_cache || {};
+
+func.runtime.render.safe_clone_tree_value = function (value) {
+  if (typeof structuredClone === 'function') {
+    try {
+      return structuredClone(value);
+    } catch (_) {
+      // Fall through to the recursive clone below.
+    }
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(function (item) {
+      return func.runtime.render.safe_clone_tree_value(item);
+    });
+  }
+
+  if (value && typeof value === 'object') {
+    const cloned = {};
+    const keys = Object.keys(value);
+    for (let index = 0; index < keys.length; index++) {
+      const key = keys[index];
+      cloned[key] = func.runtime.render.safe_clone_tree_value(value[key]);
+    }
+    return cloned;
+  }
+
+  return value;
+};
+func.runtime.render.sort_tree_debug_value = function (value) {
+  if (Array.isArray(value)) {
+    return value.map(function (item) {
+      return func.runtime.render.sort_tree_debug_value(item);
+    });
+  }
+
+  if (value && typeof value === 'object') {
+    const sorted = {};
+    const keys = Object.keys(value).sort();
+    for (let index = 0; index < keys.length; index++) {
+      const key = keys[index];
+      sorted[key] = func.runtime.render.sort_tree_debug_value(value[key]);
+    }
+    return sorted;
+  }
+
+  return value;
+};
+func.runtime.render.is_tree_node = function (nodeP) {
+  return !!nodeP?.contract && nodeP.contract === func.runtime.render.TREE_CONTRACT_VERSION;
+};
+func.runtime.render.get_tree_source_node = function (nodeP) {
+  if (!func.runtime.render.is_tree_node(nodeP)) {
+    return nodeP || null;
+  }
+  return nodeP?.meta?.source_node || null;
+};
+func.runtime.render.get_tree_source_snapshot = function (nodeP) {
+  if (!func.runtime.render.is_tree_node(nodeP)) {
+    return func.runtime.render.safe_clone_tree_value(nodeP);
+  }
+  return nodeP?.meta?.source_snapshot || null;
+};
+func.runtime.render.get_tree_node_kind = function (nodeP) {
+  const tag_name = typeof nodeP?.tagName === 'string' ? nodeP.tagName.toLowerCase() : '';
+  const node_type = typeof nodeP?.type === 'string' ? nodeP.type.toLowerCase() : '';
+
+  if (tag_name === 'xu-widget') return 'widget';
+  if (tag_name === 'xu-single-view') return 'single_view';
+  if (tag_name === 'xu-multi-view') return 'multi_view';
+  if (tag_name === 'xu-panel') return 'panel';
+  if (tag_name === 'xu-teleport') return 'teleport';
+  if (tag_name === 'xurender') return 'placeholder';
+  if (tag_name === '#text' || node_type === 'text') return 'text';
+  if (!tag_name && typeof nodeP?.content === 'string' && !Array.isArray(nodeP?.children)) return 'text';
+  return 'element';
+};
+func.runtime.render.get_tree_node_id = function (nodeP, pathP) {
+  if (nodeP?.id) {
+    return nodeP.id;
+  }
+  if (nodeP?.id_org) {
+    return nodeP.id_org;
+  }
+  const normalized_path = Array.isArray(pathP) && pathP.length ? pathP.join('.') : 'root';
+  return `tree-node-${normalized_path}`;
+};
+func.runtime.render.get_tree_controls = function (attributes) {
+  const attrs = attributes || {};
+  const get_first_defined = function (keys) {
+    for (let index = 0; index < keys.length; index++) {
+      const key = keys[index];
+      if (Object.prototype.hasOwnProperty.call(attrs, key)) {
+        return attrs[key];
+      }
+    }
+    return null;
+  };
+  return {
+    xu_for: get_first_defined(['xu-for', 'xu-exp:xu-for']),
+    xu_if: get_first_defined(['xu-if', 'xu-exp:xu-if']),
+    xu_render: get_first_defined(['xu-render', 'xu-exp:xu-render']),
+  };
+};
+func.runtime.render.get_tree_node_capabilities = async function (options) {
+  const attributes = options?.attributes || {};
+  const plugin_name = attributes['xu-widget'];
+  if (!plugin_name) {
+    return null;
+  }
+
+  const cache = func.runtime.render._tree_widget_capability_cache;
+  if (cache[plugin_name]) {
+    return func.runtime.render.safe_clone_tree_value(cache[plugin_name]);
+  }
+
+  let capabilities = {
+    browser: true,
+    headless: false,
+  };
+
+  try {
+    if (options.SESSION_ID && options.paramsP && func.runtime.widgets?.create_context && func.runtime.widgets?.get_definition) {
+      const widget_context = func.runtime.widgets.create_context(options.SESSION_ID, options.paramsP, attributes);
+      const definition = await func.runtime.widgets.get_definition(widget_context);
+      capabilities = func.runtime.widgets.normalize_capabilities(definition);
+    }
+  } catch (_) {
+    // Keep the safe browser-only default when the widget definition is unavailable.
+  }
+
+  cache[plugin_name] = capabilities;
+  return func.runtime.render.safe_clone_tree_value(capabilities);
+};
+func.runtime.render.ensure_tree_node = async function (options) {
+  if (!options?.nodeP) {
+    return null;
+  }
+  if (func.runtime.render.is_tree_node(options.nodeP)) {
+    return options.nodeP;
+  }
+  return await func.runtime.render.build_tree(options);
+};
+func.runtime.render.build_tree = async function (options) {
+  if (Array.isArray(options?.nodeP)) {
+    return await func.runtime.render.build_tree_list({
+      ...options,
+      nodesP: options.nodeP,
+    });
+  }
+
+  const nodeP = options?.nodeP;
+  if (!nodeP) {
+    return null;
+  }
+  if (func.runtime.render.is_tree_node(nodeP)) {
+    return nodeP;
+  }
+
+  const pathP = Array.isArray(options?.pathP) ? options.pathP.slice() : [];
+  const tree_path = pathP.length ? pathP.slice() : [0];
+  const attributes = func.runtime.render.safe_clone_tree_value(nodeP.attributes || {});
+  if (typeof nodeP.content !== 'undefined' && typeof attributes['xu-content'] === 'undefined') {
+    attributes['xu-content'] = func.runtime.render.safe_clone_tree_value(nodeP.content);
+  }
+
+  const widget_capabilities = await func.runtime.render.get_tree_node_capabilities({
+    SESSION_ID: options?.SESSION_ID,
+    paramsP: options?.paramsP,
+    attributes,
+  });
+  const children = [];
+  const child_nodes = Array.isArray(nodeP.children) ? nodeP.children : [];
+  const parent_tree_id = tree_path.join('.');
+
+  for (let index = 0; index < child_nodes.length; index++) {
+    const child_tree = await func.runtime.render.build_tree({
+      ...options,
+      nodeP: child_nodes[index],
+      pathP: tree_path.concat(index),
+      parent_tree_id: parent_tree_id,
+      keyP: index,
+      parent_nodeP: nodeP,
+    });
+    if (child_tree) {
+      children.push(child_tree);
+    }
+  }
+
+  const tree = {
+    contract: func.runtime.render.TREE_CONTRACT_VERSION,
+    id: func.runtime.render.get_tree_node_id(nodeP, tree_path),
+    xu_tree_id: `tree.${tree_path.join('.')}`,
+    kind: func.runtime.render.get_tree_node_kind(nodeP),
+    tagName: nodeP.tagName || null,
+    attributes,
+    text: typeof nodeP.text !== 'undefined' ? func.runtime.render.safe_clone_tree_value(nodeP.text) : null,
+    content: typeof nodeP.content !== 'undefined' ? func.runtime.render.safe_clone_tree_value(nodeP.content) : null,
+    children,
+    meta: {
+      tree_id: tree_path.join('.'),
+      path: tree_path,
+      parent_tree_id: options?.parent_tree_id || null,
+      key: typeof options?.keyP === 'undefined' ? null : options.keyP,
+      recordid: nodeP?.recordid || null,
+      dependency_fields: func.runtime.render.safe_clone_tree_value(nodeP?.dependency_fields || null),
+      iterate_info: func.runtime.render.safe_clone_tree_value(options?.parent_infoP?.iterate_info || nodeP?.iterate_info || null),
+      controls: func.runtime.render.get_tree_controls(attributes),
+      capabilities: widget_capabilities,
+      widget: attributes['xu-widget']
+        ? {
+            plugin_name: attributes['xu-widget'],
+            method: attributes['xu-method'] || '_default',
+            capabilities: widget_capabilities,
+          }
+        : null,
+      source_node_id: nodeP?.id || nodeP?.id_org || null,
+      source_node: nodeP,
+      source_snapshot: func.runtime.ui?.get_node_snapshot
+        ? func.runtime.ui.get_node_snapshot(nodeP)
+        : func.runtime.render.safe_clone_tree_value(nodeP),
+    },
+  };
+
+  return tree;
+};
+func.runtime.render.build_tree_list = async function (options) {
+  const nodes = Array.isArray(options?.nodesP) ? options.nodesP : [];
+  const trees = [];
+
+  for (let index = 0; index < nodes.length; index++) {
+    const tree = await func.runtime.render.build_tree({
+      ...options,
+      nodeP: nodes[index],
+      pathP: Array.isArray(options?.pathP) && options.pathP.length ? options.pathP.concat(index) : [index],
+      keyP: index,
+    });
+    if (tree) {
+      trees.push(tree);
+    }
+  }
+
+  return trees;
+};
+func.runtime.render.sanitize_tree_for_debug = function (treeP) {
+  if (Array.isArray(treeP)) {
+    return treeP.map(function (child) {
+      return func.runtime.render.sanitize_tree_for_debug(child);
+    });
+  }
+
+  if (!func.runtime.render.is_tree_node(treeP)) {
+    return func.runtime.render.sort_tree_debug_value(func.runtime.render.safe_clone_tree_value(treeP));
+  }
+
+  return {
+    contract: treeP.contract,
+    id: treeP.id,
+    xu_tree_id: treeP.xu_tree_id || null,
+    kind: treeP.kind,
+    tagName: treeP.tagName,
+    attributes: func.runtime.render.sort_tree_debug_value(treeP.attributes || {}),
+    text: treeP.text,
+    content: treeP.content,
+    children: treeP.children.map(function (child) {
+      return func.runtime.render.sanitize_tree_for_debug(child);
+    }),
+    meta: {
+      tree_id: treeP.meta?.tree_id || null,
+      path: func.runtime.render.safe_clone_tree_value(treeP.meta?.path || []),
+      parent_tree_id: treeP.meta?.parent_tree_id || null,
+      key: typeof treeP.meta?.key === 'undefined' ? null : treeP.meta.key,
+      recordid: treeP.meta?.recordid || null,
+      dependency_fields: func.runtime.render.sort_tree_debug_value(treeP.meta?.dependency_fields || null),
+      iterate_info: func.runtime.render.sort_tree_debug_value(treeP.meta?.iterate_info || null),
+      controls: func.runtime.render.sort_tree_debug_value(treeP.meta?.controls || null),
+      capabilities: func.runtime.render.sort_tree_debug_value(treeP.meta?.capabilities || null),
+      widget: treeP.meta?.widget
+        ? {
+            plugin_name: treeP.meta.widget.plugin_name,
+            method: treeP.meta.widget.method,
+            capabilities: func.runtime.render.sort_tree_debug_value(treeP.meta.widget.capabilities || null),
+          }
+        : null,
+      source_node_id: treeP.meta?.source_node_id || null,
+    },
+  };
+};
+func.runtime.render.serialize_tree = function (treeP, spacing = 2) {
+  return JSON.stringify(func.runtime.render.sanitize_tree_for_debug(treeP), null, spacing);
+};
+ func.runtime = func.runtime || {};
+func.runtime.ui = func.runtime.ui || {};
+func.runtime.render = func.runtime.render || {};
+func.runtime.widgets = func.runtime.widgets || {};
+
+// Shared string-renderer helpers live here so headless/server runtimes can materialize the render tree without a DOM.
+
+func.runtime.render.HTML_VOID_TAGS = func.runtime.render.HTML_VOID_TAGS || {
+  area: true,
+  base: true,
+  br: true,
+  col: true,
+  embed: true,
+  hr: true,
+  img: true,
+  input: true,
+  link: true,
+  meta: true,
+  param: true,
+  source: true,
+  track: true,
+  wbr: true,
+};
+func.runtime.render.escape_html = function (value) {
+  return `${value ?? ''}`
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#039;');
+};
+func.runtime.render.escape_html_attribute = function (value) {
+  return func.runtime.render.escape_html(value);
+};
+func.runtime.render.is_html_void_tag = function (tag_name) {
+  return !!func.runtime.render.HTML_VOID_TAGS[(tag_name || '').toLowerCase()];
+};
+func.runtime.render.is_falsey_render_value = function (value) {
+  if (value === false || value === null || typeof value === 'undefined') {
+    return true;
+  }
+  if (typeof value === 'number') {
+    return value === 0;
+  }
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase();
+    return normalized === '' || normalized === 'false' || normalized === '0' || normalized === 'null' || normalized === 'undefined' || normalized === 'off' || normalized === 'no';
+  }
+  return false;
+};
+func.runtime.render.should_render_tree_node = function (treeP) {
+  const controls = treeP?.meta?.controls || {};
+  if (controls.xu_if !== null && controls.xu_if !== undefined && func.runtime.render.is_falsey_render_value(controls.xu_if)) {
+    return false;
+  }
+  if (controls.xu_render !== null && controls.xu_render !== undefined && func.runtime.render.is_falsey_render_value(controls.xu_render)) {
+    return false;
+  }
+  return true;
+};
+func.runtime.render.is_tree_control_attribute = function (key) {
+  if (!key) {
+    return false;
+  }
+  return (
+    key.startsWith('xu-exp:') ||
+    key === 'xu-widget' ||
+    key === 'xu-method' ||
+    key === 'xu-for' ||
+    key === 'xu-for-key' ||
+    key === 'xu-for-val' ||
+    key === 'xu-if' ||
+    key === 'xu-render' ||
+    key === 'xu-bind' ||
+    key === 'xu-content' ||
+    key === 'xu-text' ||
+    key === 'xu-html' ||
+    key === 'xu-show' ||
+    key === 'xu-panel-program' ||
+    key === 'xu-teleport'
+  );
+};
+func.runtime.render.get_string_renderer_tag_name = function (treeP) {
+  switch (treeP?.kind) {
+    case 'widget':
+    case 'single_view':
+    case 'multi_view':
+    case 'panel':
+    case 'teleport':
+      return 'div';
+    case 'placeholder':
+      return null;
+    case 'text':
+      return null;
+    default:
+      return treeP?.tagName || 'div';
+  }
+};
+func.runtime.render.get_tree_terminal_content = function (treeP) {
+  const attributes = treeP?.attributes || {};
+  if (typeof attributes['xu-html'] !== 'undefined' && attributes['xu-html'] !== null) {
+    return {
+      value: `${attributes['xu-html']}`,
+      mode: 'html',
+    };
+  }
+  if (typeof attributes['xu-content'] !== 'undefined' && attributes['xu-content'] !== null) {
+    return {
+      value: `${attributes['xu-content']}`,
+      mode: 'html',
+    };
+  }
+  if (typeof attributes['xu-text'] !== 'undefined' && attributes['xu-text'] !== null) {
+    return {
+      value: `${attributes['xu-text']}`,
+      mode: 'text',
+    };
+  }
+  if (treeP?.kind === 'text') {
+    return {
+      value: typeof treeP?.text !== 'undefined' && treeP?.text !== null ? `${treeP.text}` : `${treeP?.content || ''}`,
+      mode: 'text',
+    };
+  }
+  return null;
+};
+func.runtime.render.render_tree_terminal_content = function (treeP) {
+  const terminal = func.runtime.render.get_tree_terminal_content(treeP);
+  if (!terminal) {
+    return null;
+  }
+  if (terminal.mode === 'html') {
+    return terminal.value;
+  }
+  return func.runtime.render.escape_html(terminal.value);
+};
+func.runtime.render.get_widget_fallback_markup = function (treeP) {
+  const widget_meta = treeP?.meta?.widget || {};
+  const capability_state = widget_meta?.capabilities?.headless ? 'headless-capable' : 'browser-only';
+  return `<!--xuda-widget:${func.runtime.render.escape_html(widget_meta.plugin_name || 'unknown')}:${capability_state}-->`;
+};
+func.runtime.render.get_tree_string_attributes = function (treeP, renderer_context) {
+  const attributes = func.runtime.render.safe_clone_tree_value(treeP?.attributes || {});
+  const attr_pairs = [];
+  const keys = Object.keys(attributes);
+
+  for (let index = 0; index < keys.length; index++) {
+    const key = keys[index];
+    if (func.runtime.render.is_tree_control_attribute(key)) {
+      continue;
+    }
+    const value = attributes[key];
+    if (value === false || value === null || typeof value === 'undefined') {
+      continue;
+    }
+    if (value === true) {
+      attr_pairs.push(key);
+      continue;
+    }
+    const normalized_value = typeof value === 'object' ? JSON.stringify(value) : `${value}`;
+    attr_pairs.push(`${key}="${func.runtime.render.escape_html_attribute(normalized_value)}"`);
+  }
+
+  attr_pairs.push(`data-xuda-kind="${func.runtime.render.escape_html_attribute(treeP?.kind || 'element')}"`);
+  attr_pairs.push(`data-xuda-node-id="${func.runtime.render.escape_html_attribute(treeP?.id || treeP?.meta?.source_node_id || '')}"`);
+  attr_pairs.push(`data-xuda-tree-id="${func.runtime.render.escape_html_attribute(treeP?.meta?.tree_id || '')}"`);
+
+  if (treeP?.kind === 'widget' && treeP?.meta?.widget) {
+    attr_pairs.push(`data-xuda-widget="${func.runtime.render.escape_html_attribute(treeP.meta.widget.plugin_name || '')}"`);
+    attr_pairs.push(`data-xuda-widget-method="${func.runtime.render.escape_html_attribute(treeP.meta.widget.method || '_default')}"`);
+    attr_pairs.push(`data-xuda-widget-capability="${func.runtime.render.escape_html_attribute(treeP.meta.widget.capabilities?.headless ? 'headless' : 'browser')}"`);
+  }
+
+  if (treeP?.kind === 'teleport' && treeP?.attributes?.['xu-teleport']) {
+    attr_pairs.push(`data-xuda-teleport-target="${func.runtime.render.escape_html_attribute(treeP.attributes['xu-teleport'])}"`);
+  }
+
+  if ((treeP?.meta?.controls?.xu_for !== null && treeP?.meta?.controls?.xu_for !== undefined) && !renderer_context?.strip_iteration_markers) {
+    attr_pairs.push('data-xuda-xu-for="pending"');
+  }
+
+  return attr_pairs.length ? ' ' + attr_pairs.join(' ') : '';
+};
+func.runtime.render.render_tree_children_to_string = async function (treeP, renderer_context) {
+  if (!Array.isArray(treeP?.children) || !treeP.children.length) {
+    return '';
+  }
+  let html = '';
+  for (let index = 0; index < treeP.children.length; index++) {
+    html += await func.runtime.render.render_tree_to_string(treeP.children[index], {
+      ...renderer_context,
+      parent_tree: treeP,
+    });
+  }
+  return html;
+};
+func.runtime.render.render_tree_to_string = async function (treeP, renderer_context = {}) {
+  if (!treeP) {
+    return '';
+  }
+  if (Array.isArray(treeP)) {
+    let html = '';
+    for (let index = 0; index < treeP.length; index++) {
+      html += await func.runtime.render.render_tree_to_string(treeP[index], renderer_context);
+    }
+    return html;
+  }
+
+  const ensured_tree = await func.runtime.render.ensure_tree_node({
+    SESSION_ID: renderer_context?.SESSION_ID,
+    nodeP: treeP,
+    paramsP: renderer_context?.paramsP,
+    parent_infoP: renderer_context?.parent_infoP,
+    keyP: renderer_context?.keyP,
+    parent_nodeP: renderer_context?.parent_nodeP,
+  });
+
+  if (!ensured_tree || !func.runtime.render.should_render_tree_node(ensured_tree)) {
+    return '';
+  }
+
+  if (ensured_tree.kind === 'placeholder') {
+    if (renderer_context?.include_placeholders) {
+      return `<!--xuda-placeholder:${func.runtime.render.escape_html(ensured_tree.id || '')}-->`;
+    }
+    return '';
+  }
+
+  if (ensured_tree.kind === 'text') {
+    return func.runtime.render.render_tree_terminal_content(ensured_tree) || '';
+  }
+
+  const tag_name = func.runtime.render.get_string_renderer_tag_name(ensured_tree);
+  if (!tag_name || tag_name.toLowerCase() === 'script') {
+    return '';
+  }
+
+  const attributes = func.runtime.render.get_tree_string_attributes(ensured_tree, renderer_context);
+  const terminal_content = func.runtime.render.render_tree_terminal_content(ensured_tree);
+  let children_html = terminal_content !== null ? terminal_content : await func.runtime.render.render_tree_children_to_string(ensured_tree, renderer_context);
+
+  if (ensured_tree.kind === 'widget' && !children_html) {
+    children_html = func.runtime.render.get_widget_fallback_markup(ensured_tree);
+  }
+
+  if (func.runtime.render.is_html_void_tag(tag_name)) {
+    return `<${tag_name}${attributes}>`;
+  }
+
+  return `<${tag_name}${attributes}>${children_html}</${tag_name}>`;
+};
+func.runtime.render.render_to_string = async function (options = {}) {
+  const treeP = await func.runtime.render.ensure_tree_node({
+    SESSION_ID: options.SESSION_ID,
+    nodeP: options.treeP || options.nodeP,
+    paramsP: options.paramsP,
+    parent_infoP: options.parent_infoP,
+    keyP: options.keyP,
+    parent_nodeP: options.parent_nodeP,
+  });
+
+  return await func.runtime.render.render_tree_to_string(treeP, options);
+};
+func.runtime.render.get_server_render_mode = function (options = {}) {
+  const normalized = func.runtime.render.normalize_runtime_bootstrap({
+    app_computing_mode: options.app_computing_mode,
+    app_render_mode: options.app_render_mode,
+    app_client_activation: options.app_client_activation,
+  });
+
+  return normalized;
+};
+func.runtime.render.build_server_render_params = async function (options = {}) {
+  const SESSION_ID = options.SESSION_ID;
+  const prog_id = options.prog_id;
+  const dsSessionP = options.dsSessionP;
+  const _session = SESSION_OBJ?.[SESSION_ID] || {};
+  const _ds = _session?.DS_GLB?.[dsSessionP] || {};
+  const viewDoc = options.viewDoc || (await func.utils?.VIEWS_OBJ?.get?.(SESSION_ID, prog_id));
+
+  if (!viewDoc?.properties) {
+    throw new Error(`view document not found for ${prog_id}`);
+  }
+
+  const base_params = _ds?.screen_params ? func.runtime.render.safe_clone_tree_value(_ds.screen_params) : {};
+  const screenId = options.screenId || base_params.screenId || `ssr_${prog_id}_${dsSessionP || '0'}`;
+  const paramsP = {
+    ...base_params,
+    prog_id,
+    sourceScreenP: null,
+    $callingContainerP: null,
+    triggerIdP: null,
+    callingDataSource_objP: _ds,
+    rowIdP: typeof options.rowIdP !== 'undefined' ? options.rowIdP : (_ds?.currentRecordId || null),
+    renderType: viewDoc.properties?.renderType,
+    parameters_obj_inP: options.parameters_obj_inP || base_params.parameters_obj_inP || options.parameters_raw_obj || {},
+    source_functionP: options.source_functionP || base_params.source_functionP || 'render_string',
+    is_panelP: false,
+    screen_type: options.screen_type || base_params.screen_type || 'render_string',
+    screenInfo: viewDoc,
+    call_screen_propertiesP: base_params.call_screen_propertiesP,
+    parentDataSourceNoP: typeof _ds?.parentDataSourceNo === 'undefined' || _ds?.parentDataSourceNo === null ? 0 : _ds.parentDataSourceNo,
+    parameters_raw_obj: options.parameters_raw_obj || base_params.parameters_raw_obj || {},
+    dsSessionP,
+    screenId,
+    containerIdP: base_params.containerIdP || `ssr_container_${screenId}`,
+  };
+
+  if (_ds) {
+    _ds.screen_params = paramsP;
+  }
+
+  return paramsP;
+};
+func.runtime.render.build_prog_tree = async function (options = {}) {
+  const SESSION_ID = options.SESSION_ID;
+  const prog_id = options.prog_id;
+  const viewDoc = options.viewDoc || (await func.utils?.VIEWS_OBJ?.get?.(SESSION_ID, prog_id));
+
+  if (!viewDoc?.progUi?.length) {
+    throw new Error(`progUi not found for ${prog_id}`);
+  }
+
+  const paramsP = options.paramsP || (await func.runtime.render.build_server_render_params({
+    ...options,
+    SESSION_ID,
+    prog_id,
+    viewDoc,
+  }));
+  const root_index = typeof options.root_index === 'number' ? options.root_index : 0;
+  const root_node = func.runtime.render.safe_clone_tree_value(viewDoc.progUi[root_index]);
+  const tree = await func.runtime.render.build_tree({
+    SESSION_ID,
+    nodeP: root_node,
+    paramsP,
+  });
+
+  return {
+    tree,
+    paramsP,
+    viewDoc,
+  };
+};
+func.runtime.render.build_ssr_payload = function (render_program, options = {}) {
+  const runtime_profile = func.runtime.render.get_server_render_mode(options);
+  return {
+    contract: 'xuda.ssr.v1',
+    prog_id: options.prog_id,
+    screenId: render_program.paramsP.screenId,
+    containerId: render_program.paramsP.containerIdP,
+    app_computing_mode: runtime_profile.app_computing_mode,
+    app_render_mode: runtime_profile.app_render_mode,
+    app_client_activation: runtime_profile.app_client_activation,
+    tree_contract: func.runtime.render.TREE_CONTRACT_VERSION,
+  };
+};
+func.runtime.render.build_ssr_screen_html = function (html, render_program, options = {}) {
+  const payload = func.runtime.render.build_ssr_payload(render_program, options);
+  const screenId = func.runtime.render.escape_html_attribute(payload.screenId || '');
+  const containerId = func.runtime.render.escape_html_attribute(payload.containerId || '');
+  const activation = func.runtime.render.escape_html_attribute(payload.app_client_activation || 'takeover');
+
+  return `<div data-xuda-ssr-embed="true" class="xu_embed_div"><div id="${screenId}" class="xu_embed_container" data-xuda-ssr-screen="true" data-xuda-ssr-screen-id="${screenId}" data-xuda-activation="${activation}" style="display: contents;"><div id="${containerId}" data-xuda-ssr-root-frame="true" data-xuda-ssr-screen-id="${screenId}" data-xuda-activation="${activation}" style="display: contents;">${html}</div></div></div>`;
+};
+func.runtime.render.render_prog_to_string = async function (options = {}) {
+  const render_program = await func.runtime.render.build_prog_tree(options);
+  const html = await func.runtime.render.render_to_string({
+    ...options,
+    SESSION_ID: options.SESSION_ID,
+    treeP: render_program.tree,
+    paramsP: render_program.paramsP,
+  });
+  const ssr_payload = func.runtime.render.build_ssr_payload(render_program, options);
+  const screen_html = func.runtime.render.build_ssr_screen_html(html, render_program, options);
+
+  return {
+    prog_id: options.prog_id,
+    dsSessionP: render_program.paramsP.dsSessionP,
+    screenId: render_program.paramsP.screenId,
+    html,
+    screen_html,
+    tree_json: func.runtime.render.serialize_tree(render_program.tree),
+    paramsP: render_program.paramsP,
+    ssr_payload,
+  };
+};
  glb.DEBUG_INFO_OBJ = {};
 // var CONNECTION_ATTEMPTS = 0;
 glb.APP_INFO = {};