@xpell/core 2.0.0-alpha.11 → 2.0.1

package/dist/xpell-core.es.js

@@ -1,14 +1,19 @@
-class S {
+var T = (o) => {
+  throw TypeError(o);
+};
+var q = (o, e, t) => e.has(o) || T("Cannot " + t);
+var p = (o, e, t) => (q(o, e, "read from private field"), t ? t.call(o) : e.get(o)), B = (o, e, t) => e.has(o) ? T("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(o) : e.set(o, t), W = (o, e, t, s) => (q(o, e, "write to private field"), s ? s.call(o, t) : e.set(o, t), t);
+class Q {
   /**
    * Create ignore list for parser to ignore spell words
    * @param list - comma-separated list of words
    * @param reservedWords - base reserved words map (mutated)
    */
-  createIgnoreList(t, e) {
-    if (!t) return e;
-    const s = t.split(",").map((i) => i.trim()).filter(Boolean);
-    for (const i of s) e[i] = "";
-    return e;
+  createIgnoreList(e, t) {
+    if (!e) return t;
+    const s = e.split(",").map((n) => n.trim()).filter(Boolean);
+    for (const n of s) t[n] = "";
+    return t;
   }
   /**
    * GUID / UUID v4 (cross-platform)
@@ -19,21 +24,21 @@ class S {
    * 3) Math.random() fallback (NOT crypto-secure, legacy fallback only)
    */
   guid() {
-    const e = globalThis.crypto;
-    if (e && typeof e.randomUUID == "function")
-      return e.randomUUID();
-    if (e && typeof e.getRandomValues == "function") {
-      const r = new Uint8Array(16);
-      e.getRandomValues(r), r[6] = r[6] & 15 | 64, r[8] = r[8] & 63 | 128;
-      const c = Array.from(r, (_) => _.toString(16).padStart(2, "0"));
-      return c.slice(0, 4).join("") + "-" + c.slice(4, 6).join("") + "-" + c.slice(6, 8).join("") + "-" + c.slice(8, 10).join("") + "-" + c.slice(10, 16).join("");
+    const t = globalThis.crypto;
+    if (t && typeof t.randomUUID == "function")
+      return t.randomUUID();
+    if (t && typeof t.getRandomValues == "function") {
+      const i = new Uint8Array(16);
+      t.getRandomValues(i), i[6] = i[6] & 15 | 64, i[8] = i[8] & 63 | 128;
+      const a = Array.from(i, (_) => _.toString(16).padStart(2, "0"));
+      return a.slice(0, 4).join("") + "-" + a.slice(4, 6).join("") + "-" + a.slice(6, 8).join("") + "-" + a.slice(8, 10).join("") + "-" + a.slice(10, 16).join("");
     }
-    const s = "0123456789abcdef".split(""), i = [];
-    let n;
-    i[8] = i[13] = i[18] = i[23] = "-", i[14] = "4";
-    for (let r = 0; r < 36; r++)
-      i[r] || (n = (0 | Math.random() * 16) >>> 0, i[r] = s[r === 19 ? n & 3 | 8 : n & 15]);
-    return i.join("");
+    const s = "0123456789abcdef".split(""), n = [];
+    let r;
+    n[8] = n[13] = n[18] = n[23] = "-", n[14] = "4";
+    for (let i = 0; i < 36; i++)
+      n[i] || (r = (0 | Math.random() * 16) >>> 0, n[i] = s[i === 19 ? r & 3 | 8 : r & 15]);
+    return n.join("");
   }
   /**
    * Merge defaults into data object (mutates data)
@@ -41,138 +46,218 @@ class S {
    * @param defaults - defaults object
    * @param force - overwrite existing values
    */
-  mergeDefaultsWithData(t, e, s = !1) {
-    if (!t) return e;
-    t._id || (t._id = t.id ?? this.guid());
-    for (const i of Object.keys(e))
-      (!(i in t) || s) && (t[i] = e[i]);
-    return t;
+  mergeDefaultsWithData(e, t, s = !1) {
+    if (!e) return t;
+    e._id || (e._id = e.id ?? this.guid());
+    for (const n of Object.keys(t))
+      (!(n in e) || s) && (e[n] = t[n]);
+    return e;
   }
   /**
    * Encode string to Base64 (UTF-8 safe, cross-platform)
    */
-  encode(t) {
-    const e = globalThis;
-    if (typeof e.btoa == "function") {
-      const s = encodeURIComponent(String(t)).replace(
+  encode(e) {
+    const t = globalThis;
+    if (typeof t.btoa == "function") {
+      const s = encodeURIComponent(String(e)).replace(
         /%([0-9A-F]{2})/g,
-        (i, n) => String.fromCharCode(parseInt(n, 16))
+        (n, r) => String.fromCharCode(parseInt(r, 16))
       );
-      return e.btoa(s);
+      return t.btoa(s);
     }
-    if (e.Buffer && typeof e.Buffer.from == "function")
-      return e.Buffer.from(String(t), "utf8").toString("base64");
+    if (t.Buffer && typeof t.Buffer.from == "function")
+      return t.Buffer.from(String(e), "utf8").toString("base64");
     throw new Error("Base64 encode not supported in this environment");
   }
   /**
    * Decode Base64 string to UTF-8 (cross-platform)
    */
-  decode(t) {
-    const e = globalThis;
-    if (typeof e.atob == "function") {
-      const s = e.atob(String(t)), i = Array.prototype.map.call(s, (n) => "%" + n.charCodeAt(0).toString(16).padStart(2, "0")).join("");
-      return decodeURIComponent(i);
+  decode(e) {
+    const t = globalThis;
+    if (typeof t.atob == "function") {
+      const s = t.atob(String(e)), n = Array.prototype.map.call(s, (r) => "%" + r.charCodeAt(0).toString(16).padStart(2, "0")).join("");
+      return decodeURIComponent(n);
     }
-    if (e.Buffer && typeof e.Buffer.from == "function")
-      return e.Buffer.from(String(t), "base64").toString("utf8");
+    if (t.Buffer && typeof t.Buffer.from == "function")
+      return t.Buffer.from(String(e), "base64").toString("utf8");
     throw new Error("Base64 decode not supported in this environment");
   }
   /**
    * Returns a random integer between min and max (inclusive)
    * NOTE: Not cryptographically secure (OK for UI, NOT for IDs)
    */
-  getRandomInt(t, e) {
-    return t = Math.ceil(t), e = Math.floor(e), Math.floor(Math.random() * (e - t + 1)) + t;
+  getRandomInt(e, t) {
+    return e = Math.ceil(e), t = Math.floor(t), Math.floor(Math.random() * (t - e + 1)) + e;
   }
   /**
    * Extract parameter from XCommand
    */
-  getParam(t, e, s = 0) {
-    return t?._params?.[e] ?? s;
+  getParam(e, t, s = 0) {
+    return e?._params?.[t] ?? s;
   }
   /**
    * Default frame scheduler (cross-platform)
    * - Browser: requestAnimationFrame
    * - Node / non-DOM: setImmediate (fast) or setTimeout (paced by target fps)
    */
-  createDefaultScheduler(t) {
-    const e = globalThis;
-    if (typeof e.requestAnimationFrame == "function")
-      return (n) => e.requestAnimationFrame(n);
-    const s = typeof t == "number" && isFinite(t) && t > 0 ? t : 60;
-    if (typeof e.setImmediate == "function" && (!t || t >= 60))
-      return (n) => e.setImmediate(n);
-    const i = Math.max(1, Math.round(1e3 / s));
-    return (n) => e.setTimeout(n, i);
+  createDefaultScheduler(e) {
+    const t = globalThis;
+    if (typeof t.requestAnimationFrame == "function")
+      return (r) => t.requestAnimationFrame(r);
+    const s = typeof e == "number" && isFinite(e) && e > 0 ? e : 60;
+    if (typeof t.setImmediate == "function" && (!e || e >= 60))
+      return (r) => t.setImmediate(r);
+    const n = Math.max(1, Math.round(1e3 / s));
+    return (r) => t.setTimeout(r, n);
+  }
+  to_iso_now() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  is_plain_object(e) {
+    return typeof e == "object" && e !== null && !Array.isArray(e);
+  }
+  ensure_string(e, t) {
+    if (typeof e != "string" || !e.trim())
+      throw new Error(`Invalid '${t}'`);
+    return e.trim();
+  }
+  ensure_params(e) {
+    return this.is_plain_object(e) ? e : {};
+  }
+  /**
+   * Copy keys from source to target only when value is not null/undefined.
+   * Keeps valid falsy values (0, false, "").
+   */
+  addIfNotNull(e, t, s) {
+    if (!(!e || !t || !Array.isArray(s)))
+      for (const n of s) {
+        const r = e[n];
+        r != null && (t[n] = r);
+      }
+  }
+  /**
+  * Add Last Slash
+  * adds a last slash to the url if it doesn't have one
+  */
+  als(e) {
+    const t = String(e ?? "");
+    return t.endsWith("/") ? t : t + "/";
+  }
+  /**
+   * Clear Last Slash
+   * removes the last slash if exists
+   */
+  cls(e) {
+    const t = String(e ?? "");
+    return t.endsWith("/") ? t.slice(0, -1) : t;
+  }
+  /**
+   * Add First Slash
+   */
+  afs(e) {
+    const t = String(e ?? "");
+    return t.startsWith("/") ? t : "/" + t;
+  }
+  /**
+   * Clear First Slash
+   */
+  cfs(e) {
+    const t = String(e ?? "");
+    return t.startsWith("/") ? t.slice(1) : t;
+  }
+  /**
+   * Calculates expiration time based on short format:
+   *  - 1h (hours)
+   *  - 2d (days)
+   *  - 3y (years, 365d)
+   * Returns epoch ms (now + delta).
+   */
+  calculateExpiration(e) {
+    const s = String(e ?? "").trim().match(/^(\d+)([hdy])$/);
+    if (!s) throw new Error("Invalid expiration format. Use: 1h | 2d | 3y");
+    const n = Number.parseInt(s[1], 10), r = s[2], i = Date.now();
+    let a = 0;
+    switch (r) {
+      case "h":
+        a = n * 60 * 60 * 1e3;
+        break;
+      case "d":
+        a = n * 24 * 60 * 60 * 1e3;
+        break;
+      case "y":
+        a = n * 365 * 24 * 60 * 60 * 1e3;
+        break;
+    }
+    return i + a;
   }
 }
-const p = new S();
-class M {
-  #t = 0;
-  // displayed fps (stable)
+const z = new Q(), l = z;
+class Y {
   #e = 0;
+  // displayed fps (stable)
+  #t = 0;
   // EMA of ms/frame
   #s = 0;
-  #i;
-  // weight of new samples (0..1)
   #n;
+  // weight of new samples (0..1)
+  #r;
   // minimum integer change to update displayed fps
-  constructor(t = 0.05, e = 1) {
-    const s = Number(t);
-    this.#i = Number.isFinite(s) ? Math.min(1, Math.max(1e-3, s)) : 0.05;
-    const i = Number(e);
-    this.#n = Number.isFinite(i) ? Math.max(0, Math.floor(i)) : 1;
+  constructor(e = 0.05, t = 1) {
+    const s = Number(e);
+    this.#n = Number.isFinite(s) ? Math.min(1, Math.max(1e-3, s)) : 0.05;
+    const n = Number(t);
+    this.#r = Number.isFinite(n) ? Math.max(0, Math.floor(n)) : 1;
   }
   now() {
-    const t = globalThis.performance;
-    return t && typeof t.now == "function" ? t.now() : Date.now();
+    const e = globalThis.performance;
+    return e && typeof e.now == "function" ? e.now() : Date.now();
   }
   calc() {
-    const t = this.now();
+    const e = this.now();
     if (this.#s === 0)
-      return this.#s = t, this.#t;
-    const e = t - this.#s;
-    if (this.#s = t, !Number.isFinite(e) || e <= 0) return this.#t;
-    this.#e === 0 ? this.#e = e : this.#e = (1 - this.#i) * this.#e + this.#i * e;
-    const s = 1e3 / this.#e;
-    if (!Number.isFinite(s) || s <= 0) return this.#t;
-    const i = Math.round(s);
-    return this.#t !== 0 && this.#n > 0 && Math.abs(i - this.#t) < this.#n ? this.#t : (this.#t = i, this.#t);
+      return this.#s = e, this.#e;
+    const t = e - this.#s;
+    if (this.#s = e, !Number.isFinite(t) || t <= 0) return this.#e;
+    this.#t === 0 ? this.#t = t : this.#t = (1 - this.#n) * this.#t + this.#n * t;
+    const s = 1e3 / this.#t;
+    if (!Number.isFinite(s) || s <= 0) return this.#e;
+    const n = Math.round(s);
+    return this.#e !== 0 && this.#r > 0 && Math.abs(n - this.#e) < this.#r ? this.#e : (this.#e = n, this.#e);
   }
   reset() {
-    this.#t = 0, this.#e = 0, this.#s = 0;
+    this.#e = 0, this.#t = 0, this.#s = 0;
   }
 }
-class I {
-  constructor(t) {
-    this._enabled = !0, this._show_date = !1, this._show_time = !0, this._debug = !1, t && this.configure(t);
+class Z {
+  constructor(e) {
+    this._enabled = !0, this._show_date = !1, this._show_time = !0, this._debug = !1, e && this.configure(e);
   }
-  configure(t) {
-    typeof t._enabled == "boolean" && (this._enabled = t._enabled), typeof t._show_date == "boolean" && (this._show_date = t._show_date), typeof t._show_time == "boolean" && (this._show_time = t._show_time), typeof t._debug == "boolean" && (this._debug = t._debug);
+  configure(e) {
+    typeof e._enabled == "boolean" && (this._enabled = e._enabled), typeof e._show_date == "boolean" && (this._show_date = e._show_date), typeof e._show_time == "boolean" && (this._show_time = e._show_time), typeof e._debug == "boolean" && (this._debug = e._debug);
   }
   _dt() {
-    const t = /* @__PURE__ */ new Date(), e = this._show_date ? `${t.getDate()}.${t.getMonth()}.${t.getFullYear()} ` : "", s = this._show_time ? `${t.getHours()}:${t.getMinutes()}:${t.getSeconds()}.${t.getMilliseconds()}|` : "";
-    return e + s;
+    const e = /* @__PURE__ */ new Date(), t = this._show_date ? `${e.getDate()}.${e.getMonth()}.${e.getFullYear()} ` : "", s = this._show_time ? `${e.getHours()}:${e.getMinutes()}:${e.getSeconds()}.${e.getMilliseconds()}|` : "";
+    return t + s;
   }
-  log(t, ...e) {
-    this._enabled && console.log(this._dt(), t, ...e);
+  log(e, ...t) {
+    this._enabled && console.log(this._dt(), e, ...t);
   }
-  warn(t, ...e) {
-    this._enabled && console.warn(this._dt(), t, ...e);
+  warn(e, ...t) {
+    this._enabled && console.warn(this._dt(), e, ...t);
   }
-  error(t, ...e) {
-    this._enabled && console.error(this._dt(), t, ...e);
+  error(e, ...t) {
+    this._enabled && console.error(this._dt(), e, ...t);
   }
-  debug(t, ...e) {
-    !this._enabled || !this._debug || console.debug(this._dt(), t, ...e);
+  debug(e, ...t) {
+    !this._enabled || !this._debug || console.debug(this._dt(), e, ...t);
   }
 }
-const a = new I(), X = typeof process < "u" && !!process?.env && process.env.NODE_ENV === "production";
-X || console.info(
+const c = new Z(), G = typeof process < "u" && !!process?.env && process.env.NODE_ENV === "production";
+G || console.info(
   "[Xpell] _xlog is redirected to console in development mode. Tip: enable 'Show timestamps' in DevTools → Console for timed logs."
 );
-const y = X ? a : console;
-class A {
+const j = G ? c : console;
+class ee {
   constructor() {
     this._objects = {}, this._listeners = /* @__PURE__ */ new Map(), this._any_listeners = /* @__PURE__ */ new Set(), this._compat_writes = !0, this._warn_legacy_writes = !0, this._verbose = !1, this._compat_legacy_keys = !0, this._o_proxy = null, this._objects = {};
   }
@@ -183,49 +268,49 @@ class A {
    */
   get _o() {
     return !this._compat_writes && !this._warn_legacy_writes ? this._objects : (this._o_proxy || (this._o_proxy = new Proxy(this._objects, {
-      set: (t, e, s) => {
-        const i = String(e);
+      set: (e, t, s) => {
+        const n = String(t);
         return this._warn_legacy_writes && console.warn(
-          `[XData] Legacy write: _o["${i}"] = ... ; prefer XData.set("${i}", value).`
-        ), this._compat_writes ? this.set(i, s, { source: "legacy:_o" }) : t[i] = s, !0;
+          `[XData] Legacy write: _o["${n}"] = ... ; prefer XData.set("${n}", value).`
+        ), this._compat_writes ? this.set(n, s, { source: "legacy:_o" }) : e[n] = s, !0;
       },
-      deleteProperty: (t, e) => {
-        const s = String(e);
+      deleteProperty: (e, t) => {
+        const s = String(t);
         return this._warn_legacy_writes && console.warn(
           `[XData] Legacy delete: delete _o["${s}"] ; prefer XData.delete("${s}").`
-        ), this._compat_writes ? this.delete(s, { source: "legacy:_o" }) : delete t[s], !0;
+        ), this._compat_writes ? this.delete(s, { source: "legacy:_o" }) : delete e[s], !0;
       }
     })), this._o_proxy);
   }
   /** Preferred read API */
-  get(t) {
-    return this._objects[t];
+  get(e) {
+    return this._objects[e];
   }
   /** Preferred write API */
-  set(t, e, s) {
-    const i = this._objects[t];
-    this._objects[t] = e, this._emit({ key: t, value: e, prev: i, ts: Date.now(), op: "set", meta: s });
+  set(e, t, s) {
+    const n = this._objects[e];
+    this._objects[e] = t, this._emit({ key: e, value: t, prev: n, ts: Date.now(), op: "set", meta: s });
   }
   /** Shallow merge helper (nice for state objects) */
-  patch(t, e, s) {
-    const i = this._objects[t], r = { ...i && typeof i == "object" ? i : {}, ...e };
-    this._objects[t] = r, this._emit({ key: t, value: r, prev: i, ts: Date.now(), op: "patch", meta: s });
+  patch(e, t, s) {
+    const n = this._objects[e], i = { ...n && typeof n == "object" ? n : {}, ...t };
+    this._objects[e] = i, this._emit({ key: e, value: i, prev: n, ts: Date.now(), op: "patch", meta: s });
   }
   /** In-place mutation notifier */
-  touch(t, e) {
-    const s = this._objects[t];
-    this._emit({ key: t, value: s, prev: s, ts: Date.now(), op: "touch", meta: e });
+  touch(e, t) {
+    const s = this._objects[e];
+    this._emit({ key: e, value: s, prev: s, ts: Date.now(), op: "touch", meta: t });
   }
-  has(t) {
-    return Object.prototype.hasOwnProperty.call(this._objects, t);
+  has(e) {
+    return Object.prototype.hasOwnProperty.call(this._objects, e);
   }
-  delete(t, e) {
-    const s = this._objects[t];
-    delete this._objects[t], this._emit({ key: t, value: void 0, prev: s, ts: Date.now(), op: "delete", meta: e });
+  delete(e, t) {
+    const s = this._objects[e];
+    delete this._objects[e], this._emit({ key: e, value: void 0, prev: s, ts: Date.now(), op: "delete", meta: t });
   }
-  pick(t, e) {
-    const s = this._objects[t];
-    return this.delete(t, e), s;
+  pick(e, t) {
+    const s = this._objects[e];
+    return this.delete(e, t), s;
   }
   clean() {
     this._objects = {};
@@ -233,32 +318,32 @@ class A {
   // ----------------------------
   // Subscriptions
   // ----------------------------
-  on(t, e) {
-    let s = this._listeners.get(t);
-    return s || this._listeners.set(t, s = /* @__PURE__ */ new Set()), s.add(e), () => this.off(t, e);
+  on(e, t) {
+    let s = this._listeners.get(e);
+    return s || this._listeners.set(e, s = /* @__PURE__ */ new Set()), s.add(t), () => this.off(e, t);
   }
-  off(t, e) {
-    const s = this._listeners.get(t);
-    s && (s.delete(e), s.size === 0 && this._listeners.delete(t));
+  off(e, t) {
+    const s = this._listeners.get(e);
+    s && (s.delete(t), s.size === 0 && this._listeners.delete(e));
   }
-  onAny(t) {
-    return this._any_listeners.add(t), () => this._any_listeners.delete(t);
+  onAny(e) {
+    return this._any_listeners.add(e), () => this._any_listeners.delete(e);
   }
   // ----------------------------
   // Emit
   // ----------------------------
-  _emit(t) {
-    this._verbose && t.meta?.trace && (t.stack = new Error().stack);
-    const e = this._listeners.get(t.key);
-    if (e) for (const s of e) s(t);
-    for (const s of this._any_listeners) s(t);
+  _emit(e) {
+    this._verbose && e.meta?.trace && (e.stack = new Error().stack);
+    const t = this._listeners.get(e.key);
+    if (t) for (const s of t) s(e);
+    for (const s of this._any_listeners) s(e);
   }
 }
-const u = new A(), P = u;
-class x {
-  constructor(t) {
-    t && Object.keys(t).forEach((e) => {
-      this[e] = t[e];
+const x = new ee(), f = x;
+class I {
+  constructor(e) {
+    e && Object.keys(e).forEach((t) => {
+      this[t] = e[t];
     }), this.d || (this.d = Date.now());
   }
   /**
@@ -271,84 +356,84 @@ class x {
    * @param defaultValue the default value if none above exists
    * @returns {any} the actual parameter value
    */
-  getParam(t, e, s) {
-    return this._params?.hasOwnProperty(e) ? this._params[e] : this._params?.hasOwnProperty(t) ? this._params[t] : s;
+  getParam(e, t, s) {
+    return this._params?.hasOwnProperty(t) ? this._params[t] : this._params?.hasOwnProperty(e) ? this._params[e] : s;
   }
 }
-const w = {
+const X = {
   type: "_type",
   children: "_children"
-}, f = class f {
+}, b = class b {
   /**
    * Adds HTML-Xpell Mapping item
    * @param htmlElement HTML element to change from
    * @param xpellElement Xpell element to change to 
    */
-  static addHtml2XpellMapItem(t, e) {
-    f.html2XMap.elements[t] = e;
+  static addHtml2XpellMapItem(e, t) {
+    b.html2XMap.elements[e] = t;
   }
   /**
    * convert text command to Xpell json command
    * @param {string} txt 
    */
-  static parse(t, e) {
-    const s = t.split(" ");
-    let i = new x();
-    if (e ? (i._module = e, i._op = s[0]) : (i._module = s[0], i._op = s[1]), i._params = {}, s.length > 1)
-      for (let n = 2; n < s.length; ++n) {
-        const r = s[n];
-        if (r.indexOf(":") > -1) {
-          const _ = r.split(":");
-          i._params[_[0]] = _[1];
+  static parse(e, t) {
+    const s = e.split(" ");
+    let n = new I();
+    if (t ? (n._module = t, n._op = s[0]) : (n._module = s[0], n._op = s[1]), n._params = {}, s.length > 1)
+      for (let r = 2; r < s.length; ++r) {
+        const i = s[r];
+        if (i.indexOf(":") > -1) {
+          const _ = i.split(":");
+          n._params[_[0]] = _[1];
         } else
-          i._params[n - 1] = s[n];
+          n._params[r - 1] = s[r];
       }
-    return i;
+    return n;
   }
-  static replaceSpacesInQuotes(t, e = "_%20_") {
-    return t.replace(/(['"])(.*?)\1/g, (s, i, n) => {
-      const r = String(n).replace(/\s/g, e);
-      return `${i}${r}${i}`;
+  static replaceSpacesInQuotes(e, t = "_%20_") {
+    return e.replace(/(['"])(.*?)\1/g, (s, n, r) => {
+      const i = String(r).replace(/\s/g, t);
+      return `${n}${i}${n}`;
     });
   }
-  static parseObjectCommand(t, e) {
-    t = f.replaceSpacesInQuotes(t);
-    const s = t.trim().split(/\s+/), i = e || s.shift();
-    if (!i) throw new Error("Missing module name");
-    let n;
-    if (s[0]?.startsWith("#") && (n = s.shift().slice(1), !n))
+  static parseObjectCommand(e, t) {
+    e = b.replaceSpacesInQuotes(e);
+    const s = e.trim().split(/\s+/), n = t || s.shift();
+    if (!n) throw new Error("Missing module name");
+    let r;
+    if (s[0]?.startsWith("#") && (r = s.shift().slice(1), !r))
       throw new Error("Invalid object selector '#'. Use '#<id>'");
-    const r = s.shift();
-    if (!r) throw new Error("Missing operation");
-    const c = {};
+    const i = s.shift();
+    if (!i) throw new Error("Missing operation");
+    const a = {};
     let _ = null, h = null;
-    if (s.forEach((l) => {
+    if (s.forEach((u) => {
       if (h) {
-        if (h += ` ${l}`, l.endsWith(h[0])) {
+        if (h += ` ${u}`, u.endsWith(h[0])) {
           const m = h.slice(1, -1).replace(/_%20_/g, " ");
-          c[_] = m, h = null;
+          a[_] = m, h = null;
         }
         return;
       }
-      if (l.startsWith('"') || l.startsWith("'")) {
-        if (h = l, l.endsWith(l[0]) && l.length > 1) {
-          const m = l.slice(1, -1).replace(/_%20_/g, " ");
-          c[_] = m, h = null;
+      if (u.startsWith('"') || u.startsWith("'")) {
+        if (h = u, u.endsWith(u[0]) && u.length > 1) {
+          const m = u.slice(1, -1).replace(/_%20_/g, " ");
+          a[_] = m, h = null;
         }
         return;
       }
-      if (l.includes(":")) {
-        const m = l.split(":"), k = m[0], F = m.slice(1).join(":").replace(/_%20_/g, " ");
-        c[k] = F, _ = null;
+      if (u.includes(":")) {
+        const m = u.split(":"), O = m[0], H = m.slice(1).join(":").replace(/_%20_/g, " ");
+        a[O] = H, _ = null;
         return;
       }
-      _ = l.replace(/_%20_/g, " ");
+      _ = u.replace(/_%20_/g, " ");
     }), h) throw new Error("Unclosed quoted parameter value");
     return {
-      _module: i,
-      _object: n,
-      _op: r,
-      _params: c
+      _module: n,
+      _object: r,
+      _op: i,
+      _params: a
     };
   }
   /**
@@ -356,9 +441,9 @@ const w = {
    * @param xmlString XML string
    * @returns 
    */
-  static xmlString2Xpell(t) {
-    const s = new DOMParser().parseFromString(t, "text/xml");
-    return s.childNodes.length > 0 ? f.xml2Xpell(s.childNodes[0]) : {};
+  static xmlString2Xpell(e) {
+    const s = new DOMParser().parseFromString(e, "text/xml");
+    return s.childNodes.length > 0 ? b.xml2Xpell(s.childNodes[0]) : {};
   }
   /**
    * Converts XML/HTML Document to Xpell JSON
@@ -366,26 +451,26 @@ const w = {
    * @param forceXhtml force Xpell XHTML for every unknown object
    * @returns {} Xpell JSON
    */
-  static xml2Xpell(t, e) {
-    const s = f.html2XMap;
-    let i = {};
-    i._children = [];
-    const n = t.nodeName, r = t.nodeName;
-    let c = e;
-    if (e ? (i[w.type] = "xhtml", i._html_ns = "http://www.w3.org/2000/svg") : i._type = s.elements[n] ? s.elements[n] : n, t.attributes)
-      for (let _ = 0; _ < t.attributes.length; ++_) {
-        const h = t.attributes[_], l = s.attributes[h.name] ? s.attributes[h.name] : h.name;
-        i[l] = h.value;
+  static xml2Xpell(e, t) {
+    const s = b.html2XMap;
+    let n = {};
+    n._children = [];
+    const r = e.nodeName, i = e.nodeName;
+    let a = t;
+    if (t ? (n[X.type] = "xhtml", n._html_ns = "http://www.w3.org/2000/svg") : n._type = s.elements[r] ? s.elements[r] : r, e.attributes)
+      for (let _ = 0; _ < e.attributes.length; ++_) {
+        const h = e.attributes[_], u = s.attributes[h.name] ? s.attributes[h.name] : h.name;
+        n[u] = h.value;
       }
-    if (t?.firstChild?.nodeValue && (i.text = t?.firstChild.nodeValue.trim()), i[w.type] == "xhtml" ? i._html_tag = r : i[w.type] == "svg" && (c = !0, i._html_ns = "http://www.w3.org/2000/svg"), t?.childNodes.length > 0)
-      for (let _ = 0; _ < t.childNodes.length; ++_) {
-        const h = t.childNodes[_];
-        h.nodeName.startsWith("#") || i[w.children].push(f.xml2Xpell(h, c));
+    if (e?.firstChild?.nodeValue && (n.text = e?.firstChild.nodeValue.trim()), n[X.type] == "xhtml" ? n._html_tag = i : n[X.type] == "svg" && (a = !0, n._html_ns = "http://www.w3.org/2000/svg"), e?.childNodes.length > 0)
+      for (let _ = 0; _ < e.childNodes.length; ++_) {
+        const h = e.childNodes[_];
+        h.nodeName.startsWith("#") || n[X.children].push(b.xml2Xpell(h, a));
       }
-    return i;
+    return n;
   }
 };
-f.html2XMap = {
+b.html2XMap = {
   elements: {
     div: "view",
     a: "link",
@@ -415,189 +500,201 @@ f.html2XMap = {
     id: "_id"
   }
 };
-let g = f;
-class $ {
-  constructor() {
-    this._log_rules = {
-      register: !1,
-      remove: !1,
-      fire: !1
-    }, this._events = {}, this._listener_index = {};
-  }
-  /**
-   * Register a listener on an event name (runtime bus only).
-   *
-   * Backward compatible:
-   * - Canonical: on(name, cb, { _once, _owner, _tag })
-   * - Legacy:   on(name, cb, { _once }, owner)
-   */
-  on(t, e, s = {}, i) {
-    this._events[t] || (this._events[t] = []);
-    const n = s?._owner ?? i, r = p.guid(), c = {
-      _id: r,
-      _callback: e,
-      _options: s,
-      _owner: n,
-      _tag: s?._tag
-    };
-    return this._events[t].push(c), this._listener_index[r] = t, this._log_rules.register && y.log("XEM Register", t, r), r;
-  }
-  /**
-   * Register a listener that will be removed after first fire.
-   */
-  once(t, e, s) {
-    return this.on(t, e, { _once: !0, _owner: s });
-  }
-  /**
-   * Fire an event with optional payload.
-   */
-  async fire(t, e) {
-    const s = this._events[t];
-    if (!s || s.length === 0) return;
-    this._log_rules.fire && y.log("XEM Fire", t, e);
-    const i = s.slice(), n = [];
-    for (const r of i) {
-      try {
-        r && r._callback && r._callback(e);
-      } catch (c) {
-        y.error(c);
-      }
-      r?._options?._once && n.push(r._id);
-    }
-    for (const r of n) this.remove(r);
-  }
-  /**
-   * Remove a listener by id.
-   */
-  remove(t) {
-    const e = this._listener_index[t];
-    if (!e) return;
-    const s = this._events[e];
-    if (s && s.length) {
-      const i = s.findIndex((n) => n?._id === t);
-      i >= 0 && s.splice(i, 1), s.length === 0 && delete this._events[e];
-    }
-    delete this._listener_index[t], this._log_rules.remove && y.log("XEM Remove", e, t);
-  }
-  /**
-   * Remove all listeners for a given owner reference.
-   */
-  removeOwner(t) {
-    if (!t) return;
-    const e = [];
-    for (const s of Object.values(this._events))
-      for (const i of s)
-        (i?._owner ?? i?._options?._owner) === t && e.push(i._id);
-    e.forEach((s) => this.remove(s));
-  }
-  /**
-   * Clear the entire event bus (mostly for tests / hard reset).
-   */
-  clear() {
-    this._events = {}, this._listener_index = {};
-  }
-}
-const b = new $();
-class R {
-  #t;
+let w = b;
+class te {
   #e;
+  #t;
   #s;
   constructor() {
-    this.#t = {}, this.#e = {}, this.#s = {};
+    this.#e = {}, this.#t = {}, this.#s = {};
   }
   get _objects() {
-    return this.#e;
+    return this.#t;
   }
   /**
    * Checks if an object is found in the object manager
    * @param xObjectId 
    * @returns 
    */
-  hasObject(t) {
-    return this.#e.hasOwnProperty(t);
+  hasObject(e) {
+    return this.#t.hasOwnProperty(e);
   }
   /**
    * Register multiple classes dictionary into the object manager
    * @param xObjects - key value list -> \{"view":XView,...\}
    */
-  registerObjects(t) {
-    Object.keys(t).forEach((s) => this.registerObject(s, t[s]));
+  registerObjects(e) {
+    Object.keys(e).forEach((s) => this.registerObject(s, e[s]));
   }
   /**
    * Registers single XObject
    * @param name - name of the object
    * @param xObjects The object class
    */
-  registerObject(t, e) {
-    this.#t[t] = e;
+  registerObject(e, t) {
+    this.#e[e] = t;
   }
   /**
    * Checks if a class (name) is found in the object manager classes dictionary
    * @param name - class name
    * @returns {boolean} 
    */
-  hasObjectClass(t) {
-    return this.#t.hasOwnProperty(t);
+  hasObjectClass(e) {
+    return this.#e.hasOwnProperty(e);
   }
   /**
    * Retrieves XObject class instance
    * @param name class name
    * @returns {XObject}
    */
-  getObjectClass(t) {
-    return this.#t[t];
+  getObjectClass(e) {
+    return this.#e[e];
   }
   /**
    * Retrieves all the classes dictionary
    * @returns XObjectManagerIndex
+   * @deprecated use getObjectClasses() instead
    */
   getAllClasses() {
-    return this.#t;
+    return this.getObjectClasses();
+  }
+  getObjectClasses() {
+    return this.#e;
   }
   get _classes() {
-    return this.#t;
+    return this.#e;
   }
   /**
    * Add XObject instance to the manager
    * @param xObject XObject to maintain
    */
-  addObject(t) {
-    t && t._id ? (this.#e[t._id] = t, (!t._name || t._name.length == 0) && (t._name = t._id), this.#s[t._name] = t._id) : a.log("unable to add object");
+  addObject(e) {
+    e && e._id ? (this.#t[e._id] = e, (!e._name || e._name.length == 0) && (e._name = e._id), this.#s[e._name] = e._id) : c.log("unable to add object");
   }
   /**
    * Remove XObject from the manager 
    * @param xObjectId object id to remove
    */
-  removeObject(t) {
-    const e = this.#e[t];
-    e && (delete this.#s[e?._name], delete this.#e[t]);
+  removeObject(e) {
+    const t = this.#t[e];
+    t && (delete this.#s[t?._name], delete this.#t[e]);
   }
   /**
    * Retrieves XObject instance
    * @param xObjectId XObject id 
    * @returns {XObject}
    */
-  getObject(t) {
-    return this.#e[t];
+  getObject(e) {
+    return this.#t[e];
   }
   /**
    * alias to getObject
    * @param id 
    * @returns 
    */
-  go(t) {
-    return this.getObject(t);
+  go(e) {
+    return this.getObject(e);
   }
   /**
    * Retrieves XObject instance
    * @param objectName XObject name 
    * @returns {XObject}
    */
-  getObjectByName(t) {
-    return this.#s[t] ? this.getObject(this.#s[t]) : null;
+  getObjectByName(e) {
+    return this.#s[e] ? this.getObject(this.#s[e]) : null;
   }
 }
-const N = [
+class ue {
+  constructor() {
+    this._log_rules = {
+      register: !1,
+      remove: !1,
+      fire: !1
+    }, this._events = {}, this._listener_index = {};
+  }
+  /**
+   * Register a listener on an event name (runtime bus only).
+   *
+   * Backward compatible:
+   * - Canonical: on(name, cb, { _once, _owner, _tag })
+   * - Legacy:   on(name, cb, { _once }, owner)
+   */
+  on(e, t, s = {}, n) {
+    this._events[e] || (this._events[e] = []);
+    const r = s?._owner ?? n, i = l.guid(), a = {
+      _id: i,
+      _callback: t,
+      _options: s,
+      _owner: r,
+      _tag: s?._tag
+    };
+    return this._events[e].push(a), this._listener_index[i] = e, this._log_rules.register && j.log("XEM Register", e, i), i;
+  }
+  /**
+   * Register a listener that will be removed after first fire.
+   */
+  once(e, t, s) {
+    return this.on(e, t, { _once: !0, _owner: s });
+  }
+  /**
+   * Fire an event with optional payload.
+   */
+  async fire(e, t) {
+    const s = this._events[e];
+    if (!s || s.length === 0) return;
+    this._log_rules.fire && j.log("XEM Fire", e, t);
+    const n = s.slice(), r = [];
+    for (const i of n) {
+      try {
+        i && i._callback && i._callback(t);
+      } catch (a) {
+        j.error(a);
+      }
+      i?._options?._once && r.push(i._id);
+    }
+    for (const i of r) this.remove(i);
+  }
+  /**
+   * Remove a listener by id.
+   */
+  remove(e) {
+    const t = this._listener_index[e];
+    if (!t) return;
+    const s = this._events[t];
+    if (s && s.length) {
+      const n = s.findIndex((r) => r?._id === e);
+      n >= 0 && s.splice(n, 1), s.length === 0 && delete this._events[t];
+    }
+    delete this._listener_index[e], this._log_rules.remove && j.log("XEM Remove", t, e);
+  }
+  /**
+   * Remove all listeners for a given owner reference.
+   */
+  removeOwner(e) {
+    if (!e) return;
+    const t = [];
+    for (const s of Object.values(this._events))
+      for (const n of s)
+        (n?._owner ?? n?._options?._owner) === e && t.push(n._id);
+    t.forEach((s) => this.remove(s));
+  }
+  /**
+   * Clear the entire event bus (mostly for tests / hard reset).
+   */
+  clear() {
+    this._events = {}, this._listener_index = {};
+  }
+}
+let P;
+function de(o) {
+  P = o;
+}
+function D() {
+  if (!P)
+    throw new Error("XEventManager not set");
+  return P;
+}
+const se = [
   "_nano_commands",
   "_cache_cmd_txt",
   "_cache_jcmd",
@@ -606,106 +703,297 @@ const N = [
   "_parent",
   "_children"
 ];
-function v(o) {
-  return N.includes(o);
+function E(o) {
+  return se.includes(o);
 }
-function D(o) {
+function J(o) {
   if (!o || typeof o != "object" || Array.isArray(o)) return !1;
-  const t = Object.getPrototypeOf(o);
-  return t === Object.prototype || t === null;
+  const e = Object.getPrototypeOf(o);
+  return e === Object.prototype || e === null;
 }
-const C = {
-  info: (o, t) => {
-    a.log("XObject id " + t?._id);
-  },
-  log: (o, t) => {
-    o._params && o._params[1] ? a.log(o._params[1]) : a.log(t);
-  },
-  fire: (o, t) => {
-    o._params && o._params[1] ? b.fire(o._params[1], o._params[2]) : o._params && o._params.event && b.fire(o._params.event, o._params.data);
-  },
-  // no-op utility command for sequence placeholders and explicit "do nothing" steps.
-  noop: () => {
-  },
-  // set a runtime field directly on the object.
-  "set-field": (o, t) => {
-    const e = o._params?.name, s = o._params?.value;
-    if (!(!t || typeof e != "string" || e.length === 0)) {
-      if (v(e)) {
-        a.error(`set-field denied for protected field: ${e}`);
-        return;
+function g(o, e) {
+  return o._skill = e, o.getSkill = () => e, o;
+}
+const V = {
+  info: g(
+    (o, e) => {
+      c.log("XObject id " + e?._id);
+    },
+    {
+      _name: "info",
+      _scope: "object",
+      _description: "Logs the current object's id."
+    }
+  ),
+  log: g(
+    (o, e) => {
+      o._params && o._params[1] ? c.log(o._params[1]) : c.log(e);
+    },
+    {
+      _name: "log",
+      _scope: "object",
+      _description: "Logs a message or the current object.",
+      _params: {
+        1: "Optional message to log."
       }
-      t[e] = s;
     }
-  },
-  // delete a runtime field from the object.
-  "delete-field": (o, t) => {
-    const e = o._params?.name;
-    if (!(!t || typeof e != "string" || e.length === 0)) {
-      if (v(e)) {
-        a.error(`delete-field denied for protected field: ${e}`);
-        return;
+  ),
+  fire: g(
+    (o, e) => {
+      o._params && o._params[1] ? D().fire(
+        String(o._params[1]),
+        o._params[2]
+      ) : o._params && o._params.event && D().fire(
+        String(o._params.event),
+        o._params.data
+      );
+    },
+    {
+      _name: "fire",
+      _scope: "object",
+      _description: "Fires an XEventManager event.",
+      _params: {
+        event: "Event name.",
+        data: "Optional event payload.",
+        1: "Event name shorthand.",
+        2: "Event payload shorthand."
+      },
+      _example: {
+        _op: "fire",
+        _params: {
+          event: "user:login",
+          data: {
+            source: "button"
+          }
+        }
       }
-      delete t[e];
     }
-  },
-  // toggle a field with boolean-first semantics.
-  "toggle-field": (o, t) => {
-    const e = o._params?.name;
-    if (!t || typeof e != "string" || e.length === 0) return;
-    if (v(e)) {
-      a.error(`toggle-field denied for protected field: ${e}`);
-      return;
+  ),
+  noop: g(
+    () => {
+    },
+    {
+      _name: "noop",
+      _scope: "object",
+      _description: "No-op command. Useful as a placeholder in sequences."
     }
-    const s = t[e];
-    typeof s == "boolean" ? t[e] = !s : s == null ? t[e] = !0 : t[e] = !1;
-  },
-  // shallow-merge a plain object into a target object field.
-  merge: (o, t) => {
-    const e = o._params?.name, s = o._params?.value;
-    if (!t || typeof e != "string" || e.length === 0) return;
-    if (v(e)) {
-      a.error(`merge denied for protected field: ${e}`);
-      return;
+  ),
+  "set-field": g(
+    (o, e) => {
+      const t = o._params?.name, s = o._params?.value;
+      if (!(!e || typeof t != "string" || t.length === 0)) {
+        if (E(t)) {
+          c.error(`set-field denied for protected field: ${t}`);
+          return;
+        }
+        e[t] = s;
+      }
+    },
+    {
+      _name: "set-field",
+      _scope: "object",
+      _description: "Sets a runtime field directly on the current object.",
+      _params: {
+        name: "Field name.",
+        value: "Value to assign."
+      },
+      _example: {
+        _op: "set-field",
+        _params: {
+          name: "_text",
+          value: "Hello"
+        }
+      }
     }
-    if (!D(s)) {
-      a.error("merge expects _params.value as a plain object");
-      return;
+  ),
+  "delete-field": g(
+    (o, e) => {
+      const t = o._params?.name;
+      if (!(!e || typeof t != "string" || t.length === 0)) {
+        if (E(t)) {
+          c.error(`delete-field denied for protected field: ${t}`);
+          return;
+        }
+        delete e[t];
+      }
+    },
+    {
+      _name: "delete-field",
+      _scope: "object",
+      _description: "Deletes a runtime field from the current object.",
+      _params: {
+        name: "Field name to delete."
+      }
     }
-    const i = t[e];
-    D(i) || (t[e] = {}), Object.assign(t[e], s);
-  },
-  // run a sequence of steps in strict order (await each).
-  "run-seq": async (o, t) => {
-    if (!t) return;
-    const e = o._params?.seq;
-    if (!Array.isArray(e)) {
-      a.error("run-seq expects _params.seq as an array");
-      return;
+  ),
+  "toggle-field": g(
+    (o, e) => {
+      const t = o._params?.name;
+      if (!e || typeof t != "string" || t.length === 0) return;
+      if (E(t)) {
+        c.error(`toggle-field denied for protected field: ${t}`);
+        return;
+      }
+      const s = e[t];
+      typeof s == "boolean" ? e[t] = !s : s == null ? e[t] = !0 : e[t] = !1;
+    },
+    {
+      _name: "toggle-field",
+      _scope: "object",
+      _description: "Toggles a runtime field using boolean-first semantics.",
+      _params: {
+        name: "Field name to toggle."
+      }
     }
-    for (const s of e) {
-      if (typeof s == "string") {
-        await t.run(`${t._id} ${s}`);
-        continue;
+  ),
+  merge: g(
+    (o, e) => {
+      const t = o._params?.name, s = o._params?.value;
+      if (!e || typeof t != "string" || t.length === 0) return;
+      if (E(t)) {
+        c.error(`merge denied for protected field: ${t}`);
+        return;
       }
-      if (s && typeof s == "object" && s._op) {
-        const i = s._object;
-        if (!(i == null || i === "this" || i === t._id)) {
-          a.error("run-seq rejected non-self _object target");
-          return;
+      if (!J(s)) {
+        c.error("merge expects _params.value as a plain object");
+        return;
+      }
+      const n = e[t];
+      J(n) || (e[t] = {}), Object.assign(e[t], s);
+    },
+    {
+      _name: "merge",
+      _scope: "object",
+      _description: "Shallow-merges a plain object into a target object field.",
+      _params: {
+        name: "Target field name.",
+        value: "Plain object to merge."
+      }
+    }
+  ),
+  "run-seq": g(
+    async (o, e) => {
+      if (!e) return;
+      const t = o._params?.seq;
+      if (!Array.isArray(t)) {
+        c.error("run-seq expects _params.seq as an array");
+        return;
+      }
+      for (const s of t) {
+        if (typeof s == "string") {
+          await e.run(`${e._id} ${s}`);
+          continue;
+        }
+        if (s && typeof s == "object" && s._op) {
+          const n = s._object;
+          if (!(n == null || n === "this" || n === e._id)) {
+            c.error("run-seq rejected non-self _object target");
+            return;
+          }
+          const i = {
+            _op: s._op,
+            _params: s._params ? { ...s._params } : void 0
+          };
+          await e.execute(i);
+          continue;
+        }
+        c.error(
+          "run-seq skipped invalid step; expected string or object with _op"
+        );
+      }
+    },
+    {
+      _name: "run-seq",
+      _scope: "object",
+      _description: "Runs a sequence of local nano-command steps in strict order.",
+      _params: {
+        seq: "Array of command strings or local command objects."
+      },
+      _example: {
+        _op: "run-seq",
+        _params: {
+          seq: [
+            {
+              _op: "set-field",
+              _params: {
+                name: "_debug",
+                value: !0
+              }
+            },
+            {
+              _op: "log",
+              _params: {
+                1: "Debug enabled"
+              }
+            }
+          ]
         }
-        const r = {
-          _op: s._op,
-          _params: s._params ? { ...s._params } : void 0
-        };
-        await t.execute(r);
-        continue;
       }
-      a.error("run-seq skipped invalid step; expected string or object with _op");
     }
-  }
-}, O = { _children: "child nodes" };
-class j {
+  )
+};
+let $;
+function ne(o) {
+  $ = o;
+}
+function re() {
+  if (!$)
+    throw new Error("XRuntime not set");
+  return $;
+}
+const R = {
+  _id: "xobject",
+  _title: "XObject Core Runtime Contract",
+  _version: "1.0.0",
+  _active: !0,
+  _type: "runtime-api-skill",
+  _description: "Base runtime object for identity, typing, composition, lifecycle hooks, events, data binding, and nano-command execution.",
+  _fields: {
+    _id: "Unique object id.",
+    _type: "Registered runtime object type.",
+    _name: "Optional object name.",
+    _children: "Child objects/data.",
+    _data_source: "XData key to bind this object to.",
+    _on: "Event handlers map.",
+    _once: "One-time event handlers map.",
+    _on_create: "Lifecycle handler after object creation.",
+    _on_mount: "Lifecycle handler after mount.",
+    _on_frame: "Frame lifecycle handler.",
+    _on_data: "Data-source lifecycle handler.",
+    _process_frame: "Enable/disable frame processing.",
+    _process_data: "Enable/disable data-source processing.",
+    _debug: "Enable object debug logs."
+  },
+  _exports: {
+    _xui_fields: [
+      "_id",
+      "_type",
+      "_name",
+      "_children",
+      "_data_source",
+      "_on",
+      "_once",
+      "_on_create",
+      "_on_mount",
+      "_on_frame",
+      "_on_data",
+      "_process_frame",
+      "_process_data",
+      "_debug"
+    ]
+  },
+  _core_rules: [
+    "All Xpell runtime objects inherit this contract.",
+    "Generated object JSON must be data-only.",
+    "Do not generate JavaScript functions.",
+    "Use _children for composition.",
+    "Use _on/_once with nano-command strings or data-only command objects."
+  ],
+  _notes: [
+    "Runtime methods include parse, append, run, execute, bindDataSource, unbindDataSource, toXData, dispose, and removeChild.",
+    "Most prompts should use this skill as a compact dependency summary, not full context."
+  ]
+}, M = { _children: "child nodes" }, S = class S {
   /**
    * XObject constructor is creating the object and adding all the data keys to the XObject instance
    * @param data constructor input data (object)
@@ -713,7 +1001,7 @@ class j {
    * @param skipParse - skip data parsing 
    * if override this method make sure to call super.init(data,skipParse) and to set skipParse to true
    */
-  constructor(t, e, s) {
+  constructor(e, t, s) {
     this._children = [], this._parent = null, this._on = {}, this._once = {}, this._process_frame = !0, this._process_data = !0, this._nano_commands = {}, this._event_listeners_ids = {}, this._event_parsed = !1, this._mounted = !1, this._xporter = {
       _ignore_fields: [
         "_to_xdata_ignore_fields",
@@ -734,14 +1022,46 @@ class j {
         "_debug"
       ],
       _instance_xporters: {}
-    }, e && p.mergeDefaultsWithData(t, e), this._id = t && t._id ? t._id : "xo-" + p.guid(), this._type = "object", this._children = [], this._nano_commands = {}, this.addNanoCommandPack(C), t && t.hasOwnProperty("_nano_commands") && t._nano_commands && (this.addNanoCommandPack(t._nano_commands), delete t._nano_commands), this.addXporterDataIgnoreFields(["_nano_commands"]), this.addXporterInstanceXporter(j, (i) => i.toXData()), this._xem_options = {
+    }, t && l.mergeDefaultsWithData(e, t), this._id = e && e._id ? e._id : "xo-" + l.guid(), this._type = "object", this._children = [], this._nano_commands = {}, this.addNanoCommandPack(V), e && e.hasOwnProperty("_nano_commands") && e._nano_commands && (this.addNanoCommandPack(e._nano_commands), delete e._nano_commands), this.addXporterDataIgnoreFields(["_nano_commands"]), this.addXporterInstanceXporter(S, (n) => n.toXData()), this._xem_options = {
       // _instance:_xem
       // _object: this
       // _support_html: true
-    }, !s && t && this.parse(t, O);
+    }, !s && e && this.parse(e, M);
+  }
+  static getOwnSkill() {
+    const e = this, t = e._skill ?? R;
+    return {
+      ...t,
+      _exports: {
+        ...t._exports ?? {},
+        _nano_commands: e.getNanoCommandSkills?.() ?? []
+      }
+    };
   }
-  log(t, ...e) {
-    this._debug && t && a.log(this._type + "->" + this._id + "]", t, ...e);
+  static getSkillChain() {
+    const e = Object.getPrototypeOf(this), t = e && typeof e.getSkillChain == "function" ? e.getSkillChain() : [], s = Object.prototype.hasOwnProperty.call(this, "_skill") ? this.getOwnSkill() : null;
+    return s ? [...t, s] : t;
+  }
+  static getOwnNanoCommands() {
+    return {
+      ...V
+    };
+  }
+  static getNanoCommands() {
+    return {
+      ...this.getOwnNanoCommands()
+    };
+  }
+  static getNanoCommandSkills() {
+    return Object.prototype.hasOwnProperty.call(
+      this,
+      "getOwnNanoCommands"
+    ) ? Object.values(this.getOwnNanoCommands()).map(
+      (t) => t.getSkill?.() ?? t._skill
+    ).filter(Boolean) : [];
+  }
+  log(e, ...t) {
+    this._debug && e && c.log(this._type + "->" + this._id + "]", e, ...t);
   }
   /**
    * Initialize the XObject
@@ -749,82 +1069,72 @@ class j {
    * @param skipParse - skip data parsing
    * @deprecated - use parse method instead
    */
-  init(t, e) {
-    !e && t && this.parse(t, O);
+  init(e, t) {
+    !t && e && this.parse(e, M);
   }
-  parseEvents(t) {
+  parseEvents(e) {
     if (!this._event_parsed) {
-      t || (t = this._xem_options), Object.keys(this._on).forEach((s) => {
-        this.addEventListener(s, this._on[s], t);
+      e || (e = this._xem_options), Object.keys(this._on).forEach((s) => {
+        this.addEventListener(s, this._on[s], e);
       });
-      const e = {};
-      Object.assign(e, t), e._once = !0, Object.keys(this._once).forEach((s) => {
-        this.addEventListener(s, this._once[s], e);
+      const t = {};
+      Object.assign(t, e), t._once = !0, Object.keys(this._once).forEach((s) => {
+        this.addEventListener(s, this._once[s], t);
       }), this._event_parsed = !0;
     }
   }
-  addEventListener(t, e, s) {
+  addEventListener(e, t, s) {
     s || (s = this._xem_options);
-    let i;
-    if (typeof e == "function")
-      i = async (r) => {
-        e(this, r);
-      };
-    else if (typeof e == "string")
-      i = async (r) => {
-        const c = this._id + " " + e + " event-data='" + JSON.stringify(r).replace(/'/g, "\\'") + "'";
-        await this.run(c);
-      };
-    else
-      throw new Error("event handler must be a function");
-    const n = b.on(t, i, s, this);
-    this._event_listeners_ids[t] || (this._event_listeners_ids[t] = []), this._event_listeners_ids[t].push(n);
+    const n = async (i) => {
+      await this.checkAndRunInternalFunction(t, i);
+    }, r = D().on(e, n, s, this);
+    return this._event_listeners_ids[e] || (this._event_listeners_ids[e] = []), this._event_listeners_ids[e].push(r), r;
   }
-  removeEventListener(t) {
-    const e = this._event_listeners_ids[t];
-    e && e.length && (e.forEach((s) => {
-      b.remove(s);
-    }), delete this._event_listeners_ids[t]);
+  removeEventListener(e) {
+    const t = this._event_listeners_ids[e];
+    t && t.length && (t.forEach((s) => {
+      D().remove(s);
+    }), delete this._event_listeners_ids[e]);
   }
   removeAllEventListeners() {
-    Object.keys(this._event_listeners_ids).forEach((e) => this.removeEventListener(e));
+    Object.keys(this._event_listeners_ids).forEach((t) => this.removeEventListener(t));
   }
   /**
    * Append a child XObject to this XObject
    * @param xobject 
    */
-  append(t) {
-    this._children?.push(t), t._parent = this;
+  append(e) {
+    this._children?.push(e), e._parent = this;
   }
   /**
    * Add single nano command to the object
    * @param commandName - the nano command name
    * @param nanoCommandFunction 
    */
-  addNanoCommand(t, e) {
-    typeof e == "function" && (this._nano_commands[t] = e);
+  addNanoCommand(e, t) {
+    typeof t == "function" && (this._nano_commands[e] = t);
   }
-  addNanoCommandPack(t) {
-    t && Object.keys(t).forEach((e) => {
-      this.addNanoCommand(e, t[e]);
+  addNanoCommandPack(e) {
+    e && Object.keys(e).forEach((t) => {
+      this.addNanoCommand(t, e[t]);
     });
   }
   /**
    * List of fields to ignore when exporting the xobject to XData or string format
    * @param <string[]> ignoreFields - an array with all the fields to ignore 
    */
-  addXporterDataIgnoreFields(t) {
-    this._xporter._ignore_fields = this._xporter._ignore_fields.concat(t);
+  addXporterDataIgnoreFields(e) {
+    this._xporter._ignore_fields = this._xporter._ignore_fields.concat(e);
   }
   /**
    * Add XData Xporter instance handler
    * @param <XDataInstanceXporter> ie - the instance exporter object
    */
-  addXporterInstanceXporter(t, e) {
-    const s = p.guid();
+  addXporterInstanceXporter(e, t) {
+    const s = l.guid();
     this._xporter._instance_xporters[s] = {
-      cls: t,
-      handler: e
+      cls: e,
+      handler: t
     };
   }
   /**
@@ -832,9 +1142,9 @@ class j {
    * @param data data to parse
    * @param ignore - lis of words to ignore in the parse process
    */
-  parse(t, e = O) {
-    Object.keys(t).forEach((i) => {
-      !e.hasOwnProperty(i) && t.hasOwnProperty(i) && (this[i] = t[i]);
+  parse(e, t = M) {
+    Object.keys(e).forEach((n) => {
+      !t.hasOwnProperty(n) && e.hasOwnProperty(n) && (this[n] = e[n]);
     });
   }
   /**
@@ -847,9 +1157,9 @@ class j {
    * ...
    * }
    */
-  parseFieldsFromXDataObject(t, e) {
-    Object.keys(e).forEach((i) => {
-      t.hasOwnProperty(i) ? this[i] = t[i] : this[i] = e[i];
+  parseFieldsFromXDataObject(e, t) {
+    Object.keys(t).forEach((n) => {
+      e.hasOwnProperty(n) ? this[n] = e[n] : this[n] = t[n];
     });
   }
   /**
@@ -858,13 +1168,13 @@ class j {
    * @param {Array<string>} fields - array of field names (string)
    * @param checkNonXParams - also check non Xpell fields (fields that not starting with "_" sign)
    */
-  parseFields(t, e, s) {
-    e.forEach((i) => {
-      if (t.hasOwnProperty(i))
-        this[i] = t[i];
-      else if (s && i.startsWith("_")) {
-        const n = i.substring(1);
-        t.hasOwnProperty(n) && (this[i] = t[n], this[n] = t[n]);
+  parseFields(e, t, s) {
+    t.forEach((n) => {
+      if (e.hasOwnProperty(n))
+        this[n] = e[n];
+      else if (s && n.startsWith("_")) {
+        const r = n.substring(1);
+        e.hasOwnProperty(r) && (this[n] = e[r], this[r] = e[r]);
       }
     });
   }
@@ -881,43 +1191,138 @@ class j {
   async onCreate() {
     this._on_create ? this.checkAndRunInternalFunction(this._on_create) : this._on && this._on.create ? this.checkAndRunInternalFunction(this._on.create) : this._once && this._once.create && this.checkAndRunInternalFunction(this._once.create);
   }
-  async runCmd(t) {
-    const e = t instanceof x ? t : new x(t);
-    await this.execute(e);
-  }
-  async checkAndRunInternalFunction(t, ...e) {
-    if (Array.isArray(t)) {
-      for (const s of t)
-        await this.checkAndRunInternalFunction(s, ...e);
-      return;
+  async runCmd(e) {
+    const t = e instanceof I ? e : new I(e);
+    await this.execute(t);
+  }
+  async checkAndRunInternalFunction(e, ...t) {
+    const s = (r) => {
+      if (typeof r == "string") {
+        if (r === "$event") return t[0];
+        if (r.startsWith("$event.")) {
+          const i = r.slice(7).split(".");
+          let a = t[0];
+          for (const _ of i) {
+            if (a == null) return;
+            a = a[_];
+          }
+          return a;
+        }
+        if (r === "$data") return t[0];
+        if (r.startsWith("$data.")) {
+          const i = r.slice(6).split(".");
+          let a = t[0];
+          for (const _ of i) {
+            if (a == null) return;
+            a = a[_];
+          }
+          return a;
+        }
+        return r;
+      }
+      if (Array.isArray(r))
+        return r.map(s);
+      if (r && typeof r == "object") {
+        const i = {};
+        for (const a of Object.keys(r))
+          i[a] = s(r[a]);
+        return i;
+      }
+      return r;
+    }, n = async (r, i) => (i !== void 0 && r && typeof r == "object" && !Array.isArray(r) && (r = {
+      ...r,
+      _params: {
+        ...r._params ?? {},
+        _prev: i
+      }
+    }), await this.checkAndRunInternalFunction(
+      r,
+      ...t
+    ));
+    if (Array.isArray(e)) {
+      let r;
+      for (const i of e)
+        r = await n(
+          i,
+          r
+        );
+      return r;
     }
-    if (typeof t == "function") {
-      await t(this, ...e);
-      return;
+    if (typeof e == "function")
+      return await e(this, ...t);
+    if (typeof e == "string") {
+      const r = w.parseObjectCommand(
+        `${this._id} ${e}`
+      );
+      if (t.length > 0) {
+        r._params = r._params || {};
+        const i = t[0];
+        r._params._event = i, !r._params.data && !i?.target && (r._params.data = i);
+      }
+      return await this.execute(r);
     }
-    if (typeof t == "string") {
-      if (e.length > 0) {
-        const s = e[0], i = JSON.stringify(s).replace(/'/g, "\\'");
-        await this.run(`${this._id} ${t} data:'${i}'`);
-      } else
-        await this.run(`${this._id} ${t}`);
-      return;
+    if (e && typeof e == "object" && Array.isArray(e._commands)) {
+      const r = e, i = typeof r._mode == "string" ? r._mode : "sequence", a = r._stop_on_error !== !1, _ = r._commands;
+      if (i === "parallel") {
+        const u = await Promise.allSettled(
+          _.map(
+            (O) => n(O)
+          )
+        ), m = u.find(
+          (O) => O.status === "rejected"
+        );
+        if (m && a)
+          throw m.reason;
+        return u;
+      }
+      let h;
+      for (const u of _)
+        try {
+          h = await n(
+            u,
+            i === "chain" ? h : void 0
+          );
+        } catch (m) {
+          if (c.error(
+            this._type + "->" + this._id + "] command sequence failed",
+            m
+          ), a)
+            throw m;
+        }
+      return h;
     }
-    if (t && typeof t == "object" && t._op) {
-      const s = t;
-      if ((s._object === void 0 || s._object === null || s._object === "this" ? this._id : s._object) !== this._id) {
-        a.error(
-          "XObject JSON handler target not supported in core-only patch; expected _object omitted/'this'/" + this._id
+    if (e && typeof e == "object" && e._op) {
+      const r = e;
+      if ((r._object === void 0 || r._object === null || r._object === "this" ? this._id : r._object) !== this._id) {
+        c.error(
+          "XObject JSON handler target not supported; expected _object omitted/'this'/" + this._id
         );
         return;
       }
-      const n = {
-        _op: s._op,
-        _params: s._params ? { ...s._params } : void 0
+      const a = {
+        ...r,
+        _params: r._params ? { ...r._params } : {}
       };
-      e.length > 0 && (n._params || (n._params = {}), Object.prototype.hasOwnProperty.call(n._params, "data") || (n._params.data = e[0])), this._debug && a.log(this._type + "->" + this._id + "]", "JSON handler executed locally", n), await this.execute(n);
-      return;
+      if (t.length > 0) {
+        const _ = t[0];
+        Object.prototype.hasOwnProperty.call(
+          a._params,
+          "data"
+        ) || (a._params.data = _), Object.prototype.hasOwnProperty.call(
+          a._params,
+          "_event"
+        ) || (a._params._event = _);
+      }
+      return a._params = s(a._params), this._debug && c.log(
+        this._type + "->" + this._id + "]",
+        "JSON handler executed locally",
+        a
+      ), await this.execute(a);
     }
+    c.error(
+      this._type + "->" + this._id + "] invalid handler in checkAndRunInternalFunction",
+      e
+    );
   }
   /**
    * Triggers when the object is being mounted to other element
@@ -931,23 +1336,23 @@ class j {
   async onMount() {
     if (!this._mounted) {
       this.parseEvents(this._xem_options), this._process_data && typeof this._data_source == "string" && this._data_source.length > 0 && this.bindDataSource(this._data_source, { initial: !0 }), this._on_mount ? await this.checkAndRunInternalFunction(this._on_mount) : this._on && this._on.mount ? await this.checkAndRunInternalFunction(this._on.mount) : this._once && this._once.mount && await this.checkAndRunInternalFunction(this._once.mount), this._mounted = !0;
-      for (const t of this._children)
-        t.onMount && typeof t.onMount == "function" && t.onMount();
+      for (const e of this._children)
+        e.onMount && typeof e.onMount == "function" && e.onMount();
     }
   }
   emptyDataSource() {
-    const t = this._data_source;
-    if (typeof t != "string" || t.length === 0) return;
-    const e = this._type ?? this.constructor.name, s = this._id ?? "no-id";
-    u.delete(t, { source: `${e}#${s}.emptyDataSource` });
+    const e = this._data_source;
+    if (typeof e != "string" || e.length === 0) return;
+    const t = this._type ?? this.constructor.name, s = this._id ?? "no-id";
+    x.delete(e, { source: `${t}#${s}.emptyDataSource` });
   }
   /**
    * Triggers when new data is being received from the data source
    * @param data - the data
    * if override this method make sure to call super.onData(data) to run the _on_data attribute
    */
-  async onData(t) {
-    this._process_data && (this._on_data ? this.checkAndRunInternalFunction(this._on_data, t) : this._on && this._on.data ? this.checkAndRunInternalFunction(this._on.data, t) : this._once && this._once.data && this.checkAndRunInternalFunction(this._once.data, t));
+  async onData(e) {
+    this._process_data && (this._on_data ? this.checkAndRunInternalFunction(this._on_data, e) : this._on && this._on.data ? this.checkAndRunInternalFunction(this._on.data, e) : this._once && this._once.data && this.checkAndRunInternalFunction(this._once.data, e));
   }
   /**
    * Triggers from Xpell frame every frame
@@ -969,19 +1374,19 @@ class j {
    * _on_frame: "nano command text"
    * 
    */
-  async onFrame(t) {
-    this._process_frame && (this._on_frame ? this.checkAndRunInternalFunction(this._on_frame, t) : this._on && this._on.frame ? this.checkAndRunInternalFunction(this._on.frame, t) : this._once && this._once.frame && this.checkAndRunInternalFunction(this._once.frame, t));
-    for (const e of this._children)
-      e.onFrame && typeof e.onFrame == "function" && e.onFrame(t);
+  async onFrame(e) {
+    this._process_frame && (this._on_frame ? this.checkAndRunInternalFunction(this._on_frame, e) : this._on && this._on.frame ? this.checkAndRunInternalFunction(this._on.frame, e) : this._once && this._once.frame && this.checkAndRunInternalFunction(this._once.frame, e));
+    for (const t of this._children)
+      t.onFrame && typeof t.onFrame == "function" && t.onFrame(e);
   }
   /**
    * Runs object nano commands
    * @param nanoCommand - object nano command (string)
    * @param cache - cache last command to prevent multiple parsing on the same command
    */
-  async run(t, e = !0) {
-    let s = this._cache_cmd_txt && this._cache_cmd_txt == t ? this._cache_jcmd : g.parseObjectCommand(t);
-    e && (this._cache_cmd_txt = t, this._cache_jcmd = s), await this.execute(s);
+  async run(e, t = !0) {
+    let s = this._cache_cmd_txt && this._cache_cmd_txt == e ? this._cache_jcmd : w.parseObjectCommand(e);
+    t && (this._cache_cmd_txt = e, this._cache_jcmd = s), await this.execute(s);
   }
   /**
    * Execute XCommand within the XObject Nano Commands
@@ -994,39 +1399,62 @@ class j {
    * }
    * 
    */
-  async execute(t) {
-    if (t._op && this._nano_commands[t._op])
+  async execute(e) {
+    const t = e?._op;
+    if (!t) {
+      c.error(this._id + " missing _op in command");
+      return;
+    }
+    const s = e?._module;
+    if (s)
       try {
-        await this._nano_commands[t._op](t, this);
-      } catch (e) {
-        a.error(this._id + " has error with command name " + t._op + " " + e);
+        return await re().execute({
+          ...e,
+          _module: s
+        });
+      } catch (n) {
+        c.error(
+          this._id + " module execution failed: " + s + "." + t + " " + n
+        );
+        return;
       }
-    else
-      a.error(this._id + " has no command name " + t._op);
+    if (this._nano_commands[t])
+      try {
+        return await this._nano_commands[t](
+          e,
+          this
+        );
+      } catch (n) {
+        c.error(
+          this._id + " has error with command name " + t + " " + n
+        );
+        return;
+      }
+    c.error(this._id + " has no command name " + t);
   }
   /**
    * Return an IXObjectData JSON representation of the XObject
    * @returns IXObjectData
    */
   toXData() {
-    const t = {};
-    return Object.keys(this).forEach((e) => {
-      if (!this._xporter._ignore_fields.includes(e) && this.hasOwnProperty(e) && this[e] !== void 0) {
-        const s = this[e];
+    const e = {};
+    return Object.keys(this).forEach((t) => {
+      if (!this._xporter._ignore_fields.includes(t) && this.hasOwnProperty(t) && this[t] !== void 0) {
+        const s = this[t];
         if (typeof s == "function")
           return;
         if (typeof s == "object") {
-          const i = Object.keys(this._xporter._instance_xporters);
-          let n = !0;
-          i.forEach((r) => {
-            this._xporter._instance_xporters[r], s instanceof this._xporter._instance_xporters[r].cls && (t[e] = this._xporter._instance_xporters[r].handler(s), n = !1);
-          }), n && (t[e] = s);
+          const n = Object.keys(this._xporter._instance_xporters);
+          let r = !0;
+          n.forEach((i) => {
+            this._xporter._instance_xporters[i], s instanceof this._xporter._instance_xporters[i].cls && (e[t] = this._xporter._instance_xporters[i].handler(s), r = !1);
+          }), r && (e[t] = s);
         } else
-          t[e] = s;
+          e[t] = s;
       }
-    }), t._children = [], this._children.length > 0 && this._children.forEach((e) => {
-      typeof e.toXData == "function" && t._children?.push(e.toXData());
-    }), t;
+    }), e._children = [], this._children.length > 0 && this._children.forEach((t) => {
+      typeof t.toXData == "function" && e._children?.push(t.toXData());
+    }), e;
   }
   /**
    * Return a string representation of the XObject
@@ -1035,16 +1463,16 @@ class j {
   toString() {
     return JSON.stringify(this.toXData());
   }
-  clearAttributes(t) {
-    t.forEach((e) => {
-      this.hasOwnProperty(e) && (this[e] = null, delete this[e]);
+  clearAttributes(e) {
+    e.forEach((t) => {
+      this.hasOwnProperty(t) && (this[t] = null, delete this[t]);
     });
   }
-  bindDataSource(t, e) {
-    const s = e?.initial ?? !0, i = t ?? this._data_source;
-    typeof i != "string" || i.length === 0 || this._process_data && (this._xd_bound_key === i && this._xd_unsub || (this.unbindDataSource(), this._data_source = i, this._xd_bound_key = i, this._type ?? this.constructor.name, this._id, this._xd_unsub = u.on(i, async (n) => {
-      await this.onData(n.value);
-    }), s && u.has(i) && this.onData(u.get(i))));
+  bindDataSource(e, t) {
+    const s = t?.initial ?? !0, n = e ?? this._data_source;
+    typeof n != "string" || n.length === 0 || this._process_data && (this._xd_bound_key === n && this._xd_unsub || (this.unbindDataSource(), this._data_source = n, this._xd_bound_key = n, this._type ?? this.constructor.name, this._id, this._xd_unsub = x.on(n, async (r) => {
+      await this.onData(r.value);
+    }), s && x.has(n) && this.onData(x.get(n))));
   }
   unbindDataSource() {
     this._xd_unsub?.(), this._xd_unsub = void 0, this._xd_bound_key = void 0;
@@ -1054,11 +1482,11 @@ class j {
    */
   async dispose() {
     if (this.unbindDataSource(), this._parent) {
-      const t = this._parent._children.indexOf(this);
-      t > -1 && this._parent._children.splice(t, 1);
+      const e = this._parent._children.indexOf(this);
+      e > -1 && this._parent._children.splice(e, 1);
     }
-    this._process_data = !1, this._process_frame = !1, this.removeAllEventListeners(), this.clearAttributes(["_cache_cmd_txt", "_cache_jcmd", "_nano_commands", "_event_listeners_ids", "_parent", "_on", "_once", "_xem_options", "_xporter"]), this._children && this._children.forEach((t) => {
-      typeof t.dispose == "function" && t.dispose();
+    this._process_data = !1, this._process_frame = !1, this.removeAllEventListeners(), this.clearAttributes(["_cache_cmd_txt", "_cache_jcmd", "_nano_commands", "_event_listeners_ids", "_parent", "_on", "_once", "_xem_options", "_xporter"]), this._children && this._children.forEach((e) => {
+      typeof e.dispose == "function" && e.dispose();
     }), this._children = [];
   }
   /**
@@ -1066,80 +1494,156 @@ class j {
    * @param child - the child to
    * @returns void
       */
-  removeChild(t, e = !1) {
-    if (e)
-      t.dispose();
+  removeChild(e, t = !1) {
+    if (t)
+      e.dispose();
     else {
-      const s = this._children.indexOf(t);
-      s > -1 && this._children.splice(s, 1), t._parent = null;
+      const s = this._children.indexOf(e);
+      s > -1 && this._children.splice(s, 1), e._parent = null;
     }
   }
   /**
    * @param child - the child to add
    * @deprecated use append method instead
    */
-  addChild(t) {
-    this.append(t);
+  addChild(e) {
+    this.append(e);
   }
-}
-class W {
+};
+S._xtype = "object", S._skill = R;
+let F = S;
+class pe {
   /**
    * Get all registered object in this ObjectPack
    * @returns XObject dictionary
    */
   static getObjects() {
     return {
-      object: j
+      object: F
     };
   }
 }
-const T = "engine:module:num-of-objects:";
-class q {
-  //engine: any;  //deprecated remove after spell3d
-  constructor(t) {
-    this._log_rules = {
+const ie = "engine:module:num-of-objects:", N = {
+  _id: "xmodule",
+  _title: "XModule Runtime Contract",
+  _version: "1.0.0",
+  _active: !0,
+  _type: "runtime-api-skill",
+  _description: "Base runtime module contract for object ownership, object packs, and executable underscore-prefixed commands.",
+  _core_rules: [
+    "Every module must have a unique _name.",
+    "Modules expose commands through methods prefixed with underscore.",
+    "Command names remove the leading underscore and convert dashes to underscores internally.",
+    "Modules own and create registered XObject classes.",
+    "Do not mutate another module's objects directly."
+  ]
+};
+var d;
+const C = class C {
+  constructor(e) {
+    B(this, d);
+    this._loaded = !1, this._loading = !1, this._log_rules = {
       createObject: !1,
       removeObject: !1
-    }, this.#t = new R(), this._name = t._name, this._id = p.guid();
+    }, W(this, d, new te()), this._name = e._name, this._id = l.guid();
   }
-  #t;
-  load() {
-    a.log("Module " + this._name + " loaded");
+  static getOwnSkillBase() {
+    return {
+      ...this._skill
+    };
+  }
+  getOwnSkill() {
+    const t = this.constructor._skill ?? N;
+    return {
+      ...t,
+      _exports: {
+        ...t._exports ?? {},
+        _modules: [
+          {
+            _name: this._name,
+            _scope: t._type === "server-module-api" ? "server" : "client",
+            _description: t._description,
+            _ops: this.getCommandSkills()
+          }
+        ]
+      }
+    };
+  }
+  getSkillChain() {
+    return [this.getOwnSkill()];
+  }
+  getObjectSkills() {
+    const e = [], t = /* @__PURE__ */ new Set();
+    for (const s of Object.values(p(this, d).getObjectClasses())) {
+      if (typeof s.getOwnSkill != "function") continue;
+      const n = s.getOwnSkill();
+      n?._id && (t.has(n._id) || (t.add(n._id), e.push(n)));
+    }
+    return e;
+  }
+  getCommandSkills() {
+    const e = Object.getPrototypeOf(this), s = this.constructor._ops ?? {};
+    return Object.getOwnPropertyNames(e).filter(
+      (n) => n.startsWith("_") && !n.startsWith("__") && typeof this[n] == "function"
+    ).map((n) => {
+      const r = n.slice(1).replaceAll("_", "-");
+      return s[r] ?? {
+        _name: r,
+        _scope: "module",
+        _description: `Runtime module command: ${r}`
+      };
+    });
+  }
+  async load() {
+    if (!(this._loaded || this._loading)) {
+      this._loading = !0;
+      try {
+        await this.onLoad(), this._loaded = !0, c.log("Module " + this._name + " loaded");
+      } finally {
+        this._loading = !1;
+      }
+    }
+  }
+  async onLoad() {
   }
   /**
    * Creates new XObject from data object
    * @param data - The data of the new object (JSON)
    * @return {XObject|*}
    */
-  create(t) {
-    let e;
-    if (t.hasOwnProperty("_type"))
-      if (this.#t.hasObjectClass(t._type)) {
-        let s = this.#t.getObjectClass(t._type);
-        s.hasOwnProperty("defaults") && p.mergeDefaultsWithData(t, s.defaults), e = new s(t);
-      } else
-        throw "Xpell object '" + t._type + "' not found";
-    else
-      e = new j(t);
-    return this.#t.addObject(e), t._children && t._children.forEach((s) => {
-      const i = this.create(s);
-      e.append(i);
-    }), e.onCreate(), e;
+  create(e) {
+    e._debug && c.log("Creating object with data", e);
+    let t;
+    if (e.hasOwnProperty("_type")) {
+      e._debug && c.log("Object type is", e._type, this.hasObject(e._type) ? "found" : "not found", "in module", this._name);
+      const s = String(e._type), n = p(this, d).getObjectClass(s);
+      if (!n)
+        throw `Xpell object '${s}' not found in module '${this._name}'`;
+      typeof n == "function" && n.hasOwnProperty("defaults") && l.mergeDefaultsWithData(
+        e,
+        n.defaults
+      ), t = new n(e);
+    } else
+      t = new F(e);
+    return p(this, d).addObject(t), e._children && e._children.forEach((s) => {
+      const n = this.create(s);
+      t.append(n);
+    }), t.onCreate(), t;
   }
   /**
    * removes and XObject from the object manager
    * @param objectId op
    */
-  remove(t) {
-    const e = this.#t.getObject(t);
-    if (!e) return;
-    const s = [], i = (n) => {
-      n?._id && (s.push(n._id), (n._children ?? []).forEach((r) => i(r)));
+  remove(e) {
+    const t = p(this, d).getObject(e);
+    if (!t) return;
+    const s = [], n = (r) => {
+      r?._id && (s.push(r._id), (r._children ?? []).forEach((i) => n(i)));
     };
-    i(e), typeof e.dispose == "function" && e.dispose(), s.reverse().forEach((n) => this.#t.removeObject(n));
+    n(t), typeof t.dispose == "function" && t.dispose(), s.reverse().forEach((r) => p(this, d).removeObject(r));
   }
-  _info(t) {
-    a.log("module info");
+  _info(e) {
+    c.log("module info");
   }
   //xpell interpreter 
   /**
@@ -1148,11 +1652,11 @@ class q {
    * @param {string} XCommand input - text 
    * @returns command execution result
    */
-  async run(t) {
-    if (t) {
-      let e = t.trim();
-      e.startsWith(this._name) || (e = this._name + " " + e);
-      let s = g.parse(e);
+  async run(e) {
+    if (e) {
+      let t = e.trim();
+      t.startsWith(this._name) || (t = this._name + " " + t);
+      let s = w.parse(t);
       return await this.execute(s);
     } else
       throw "Unable to parse Xpell Command";
@@ -1163,32 +1667,32 @@ class q {
    * @returns command execution result
    */
   // inside XModule class
-  async execute(t) {
-    if (!t || !t._op)
+  async execute(e) {
+    if (!e || !e._op)
       throw new Error(`Invalid XCommand: missing _op (module: ${this._name})`);
-    const e = t._object;
-    if (e) {
-      const n = this.#t.getObject(e);
-      if (!n)
-        throw new Error(`Module '${this._name}' cant find object id: ${e}`);
-      return await n.execute(t);
+    const t = e._object;
+    if (t) {
+      const r = p(this, d).getObject(t);
+      if (!r)
+        throw new Error(`Module '${this._name}' cant find object id: ${t}`);
+      return await r.execute(e);
     }
-    const s = "_" + t._op.replaceAll("-", "_"), i = this[s];
-    if (typeof i == "function")
-      return await i.call(this, t);
-    throw new Error(`Module '${this._name}' cant find op: ${t._op}`);
+    const s = "_" + e._op.replaceAll("-", "_"), n = this[s];
+    if (typeof n == "function")
+      return await n.call(this, e);
+    throw new Error(`Module '${this._name}' cant find op: ${e._op}`);
   }
   /**
    * This method triggers every frame from the Xpell engine.
    * The method can be override by the extending module to support extended onFrame functionality
    * @param frameNumber Current frame number
    */
-  async onFrame(t) {
-    const e = this.#t._objects, s = Object.keys(e);
-    s.forEach((i) => {
-      const n = e[i];
-      n && n.onFrame && typeof n.onFrame == "function" && n?.onFrame(t);
-    }), P.set(T + this._id, s.length, {
+  async onFrame(e) {
+    const t = p(this, d)._objects, s = Object.keys(t);
+    s.forEach((n) => {
+      const r = t[n];
+      r && r.onFrame && typeof r.onFrame == "function" && r?.onFrame(e);
+    }), f.set(ie + this._id, s.length, {
       source: "xmodule"
     });
   }
@@ -1203,18 +1707,21 @@ class q {
    * getObject directly on the module instead of om.getObject 
    */
   get om() {
-    return this.#t;
+    return p(this, d);
   }
   get _object_manager() {
-    return this.#t;
+    return p(this, d);
   }
   /**
    * Returns the XObject instance from the module Object Manager
    * @param objectId 
    * @returns XObject
    */
-  getObject(t) {
-    return this.#t.getObject(t);
+  getObject(e) {
+    return p(this, d).getObject(e);
+  }
+  hasObject(e) {
+    return p(this, d).hasObjectClass(e);
   }
   /**
    * Returns the XObject instance from the module Object Manager
@@ -1222,23 +1729,23 @@ class q {
    * xmodule._o["object-id"] is equivalent to xmodule.getObject("object-id")
    */
   get _o() {
-    return this.#t._objects;
+    return p(this, d)._objects;
   }
   /**
    * Imports external object pack to the engine
    * The object class should be like XObjects with static implementation of getObjects() method
    * @param {XObjects} xObjectPack 
    */
-  importObjectPack(t) {
-    this.#t.registerObjects(t.getObjects());
+  importObjectPack(e) {
+    p(this, d).registerObjects(e.getObjects());
   }
   /**
    * Imports external object pack to the engine
    * @deprecated - use importObjectPack instead
    * @param xObjectPack 
    */
-  importObjects(t) {
-    this.importObjectPack(t);
+  importObjects(e) {
+    this.importObjectPack(e);
   }
   /**
    * Imports external objects to the engine
@@ -1246,19 +1753,19 @@ class q {
    * @param xObjectName 
    * @param xObject 
    */
-  importObject(t, e) {
-    this.#t.registerObject(t, e);
+  importObject(e, t) {
+    p(this, d).registerObject(e, t);
   }
   // In XModule
-  async _help(t) {
-    const e = t?._params?._op ?? t?._params?._command ?? "";
-    return this.help(e);
+  async _help(e) {
+    const t = e?._params?._op ?? e?._params?._command ?? "";
+    return this.help(t);
   }
   /**
    * Override in modules to provide help text.
    * @param op optional: specific command name (e.g. "navigate")
    */
-  help(t) {
+  help(e) {
     return {
       module: this._name,
       usage: `${this._name} help`,
@@ -1266,60 +1773,264 @@ class q {
       note: "No help() implemented for this module."
     };
   }
-}
-class J {
+};
+d = new WeakMap(), C._skill = N, C._ops = {
+  help: {
+    _name: "help",
+    _scope: "module",
+    _description: "Return module help or command-specific help."
+  },
+  info: {
+    _name: "info",
+    _scope: "module",
+    _description: "Log basic module information."
+  }
+};
+let A = C;
+const oe = {
+  _id: "xdata",
+  _title: "XData Runtime State Contract",
+  _version: "1.0.0",
+  _active: !0,
+  _type: "xdata-skill",
+  _description: "Shared runtime state store used by Xpell modules and objects for reactive data binding.",
+  _requires: ["xmodule"],
+  _core_rules: [
+    "Use XData for shared runtime state.",
+    "Use _data_source on objects to bind to an XData key.",
+    "Use $xdata.key references in generated payloads when a flow or command needs current state.",
+    "Do not use XData as hidden local component state.",
+    "XData keys should be explicit and stable."
+  ],
+  _fields: {
+    _data_source: "XData key used by XObject/XUIObject for reactive data binding.",
+    "$xdata.key": "Runtime payload reference to an XData value."
+  }
+}, v = class v extends A {
+  constructor() {
+    super({ _name: v._name });
+  }
+  async _get(e) {
+    const t = l.ensure_params(e?._params), s = l.ensure_string(t.key, "key");
+    return {
+      _ok: !0,
+      _result: f.get(s)
+    };
+  }
+  async _set(e) {
+    const t = l.ensure_params(e?._params), s = l.ensure_string(t.key, "key");
+    return t._debug && j.log("XD SET", { key: s, value: t.value }), f.set(s, t.value, {
+      source: t.source ?? "xd:set"
+    }), {
+      _ok: !0,
+      _result: { key: s }
+    };
+  }
+  async _patch(e) {
+    const t = l.ensure_params(e?._params), s = l.ensure_string(t.key, "key");
+    if (!l.is_plain_object(t.value))
+      throw new Error("xd patch expects value as plain object");
+    return f.patch(s, t.value, {
+      source: t.source ?? "xd:patch"
+    }), {
+      _ok: !0,
+      _result: { key: s }
+    };
+  }
+  async _delete(e) {
+    const t = l.ensure_params(e?._params), s = l.ensure_string(t.key, "key");
+    return f.delete(s, {
+      source: t.source ?? "xd:delete"
+    }), {
+      _ok: !0,
+      _result: { key: s }
+    };
+  }
+  async _touch(e) {
+    const t = l.ensure_params(e?._params), s = l.ensure_string(t.key, "key");
+    return f.touch(s, {
+      source: t.source ?? "xd:touch"
+    }), {
+      _ok: !0,
+      _result: { key: s }
+    };
+  }
+  async _has(e) {
+    const t = l.ensure_params(e?._params), s = l.ensure_string(t.key, "key");
+    return {
+      _ok: !0,
+      _result: f.has(s)
+    };
+  }
+};
+v._name = "xd", v._skill = oe, v._ops = {
+  get: {
+    _name: "get",
+    _scope: "module",
+    _description: "Get value from XData store.",
+    _params: {
+      key: "XData key."
+    }
+  },
+  set: {
+    _name: "set",
+    _scope: "module",
+    _description: "Set value in XData store.",
+    _params: {
+      key: "XData key.",
+      value: "Value to store.",
+      source: "Optional mutation source."
+    }
+  },
+  patch: {
+    _name: "patch",
+    _scope: "module",
+    _description: "Patch plain object into existing XData value.",
+    _params: {
+      key: "XData key.",
+      value: "Plain object patch.",
+      source: "Optional mutation source."
+    }
+  },
+  delete: {
+    _name: "delete",
+    _scope: "module",
+    _description: "Delete XData key.",
+    _params: {
+      key: "XData key.",
+      source: "Optional mutation source."
+    }
+  },
+  touch: {
+    _name: "touch",
+    _scope: "module",
+    _description: "Trigger XData subscribers without changing value.",
+    _params: {
+      key: "XData key.",
+      source: "Optional mutation source."
+    }
+  },
+  has: {
+    _name: "has",
+    _scope: "module",
+    _description: "Check if XData key exists.",
+    _params: {
+      key: "XData key."
+    }
+  }
+};
+let L = v;
+const ae = {
+  _id: "xem",
+  _title: "XEventManager Runtime Event Bus",
+  _version: "1.0.0",
+  _active: !0,
+  _type: "runtime-api-skill",
+  _description: "Global runtime event bus for decoupled communication between Xpell modules, objects, flows, and UI components.",
+  _requires: ["xmodule"],
+  _core_rules: [
+    "Use XEM for decoupled runtime events.",
+    "Use explicit event names and explicit payload objects.",
+    "Do not use XEM as state storage.",
+    "Use XData for shared state and XEM for notifications/events.",
+    "Prefer _on/_once on objects for local event handlers."
+  ],
+  _fields: {
+    _on: "Object event handler map.",
+    _once: "Object one-time event handler map.",
+    event: "Event name to fire.",
+    data: "Optional event payload."
+  },
+  _notes: [
+    "XEM is process-wide and listener order should not be assumed.",
+    "Event payloads should be JSON/data-only."
+  ]
+}, k = class k extends A {
+  constructor() {
+    super({ _name: k._name });
+  }
+  async _fire(e) {
+    const t = l.ensure_params(e?._params), s = l.ensure_string(t.event, "event"), n = t.data;
+    t._debug && j.log("xem fire 🔥 ", s, n), await D().fire(s, n);
+  }
+};
+k._name = "xem", k._skill = ae, k._ops = {
+  fire: {
+    _name: "fire",
+    _scope: "module",
+    _description: "Fire a global XEM event with optional payload data.",
+    _params: {
+      event: "Event name.",
+      data: "Optional event payload.",
+      _debug: "Optional debug log flag."
+    },
+    _example: {
+      _module: "xem",
+      _op: "fire",
+      _params: {
+        event: "user:login",
+        data: {
+          source: "login-button"
+        }
+      }
+    }
+  }
+};
+let U = k;
+class me {
   /* -------------------------------------------------- */
   /* core helpers                                       */
   /* -------------------------------------------------- */
-  static get(t, e, s) {
-    if (!t?._params) return s;
-    const i = t._params[e];
-    return i !== void 0 ? i : s;
-  }
-  static has(t, e) {
-    return t?._params && t._params[e] !== void 0;
-  }
-  static str(t, ...e) {
-    for (const s of e) {
-      const i = t?._params?.[s];
-      if (i != null)
-        return String(i);
+  static get(e, t, s) {
+    if (!e?._params) return s;
+    const n = e._params[t];
+    return n !== void 0 ? n : s;
+  }
+  static has(e, t) {
+    return (e?._params || e)[t] !== void 0;
+  }
+  static str(e, ...t) {
+    const s = e?._params || e;
+    for (const n of t) {
+      const r = s?.[n];
+      if (r != null)
+        return String(r);
     }
   }
   /* -------------------------------------------------- */
   /* typed params                                       */
   /* -------------------------------------------------- */
-  static bool(t, e, s = !1) {
-    const i = this.get(t, e, s);
-    if (typeof i == "boolean") return i;
-    if (typeof i == "number") return i !== 0;
-    if (typeof i == "string") {
-      const n = i.toLowerCase();
-      if (["1", "true", "yes", "on"].includes(n)) return !0;
-      if (["0", "false", "no", "off"].includes(n)) return !1;
+  static bool(e, t, s = !1) {
+    const n = e?._params || e, r = this.get(n, t, s);
+    if (typeof r == "boolean") return r;
+    if (typeof r == "number") return r !== 0;
+    if (typeof r == "string") {
+      const i = r.toLowerCase();
+      if (["1", "true", "yes", "on"].includes(i)) return !0;
+      if (["0", "false", "no", "off"].includes(i)) return !1;
     }
-    return !!i;
+    return !!r;
   }
-  static int(t, e, s = 0) {
-    const i = this.get(t, e, s), n = parseInt(String(i), 10);
-    return Number.isFinite(n) ? n : s;
+  static int(e, t, s = 0) {
+    const n = e?._params || e, r = this.get(n, t, s), i = parseInt(String(r), 10);
+    return Number.isFinite(i) ? i : s;
   }
-  static json(t, e, s) {
-    const i = this.get(t, e, s);
-    if (i == null) return s;
-    if (typeof i == "object") return i;
-    if (typeof i == "string")
+  static json(e, t, s) {
+    const n = e?._params || e, r = this.get(n, t, s);
+    if (r == null) return s;
+    if (typeof r == "object") return r;
+    if (typeof r == "string")
       try {
-        return JSON.parse(i);
+        return JSON.parse(r);
       } catch {
         return s;
       }
     return s;
   }
 }
-class E extends Error {
-  constructor(t, e, s) {
-    super(e), this.name = "XError", this._code = t, this._level = s?._level ?? "error", this._meta = s?._meta, this._cause = s?._cause;
+class K extends Error {
+  constructor(e, t, s) {
+    super(t), this.name = "XError", this._code = e, this._level = s?._level ?? "error", this._meta = s?._meta, this._cause = s?._cause;
   }
   toXData() {
     return {
@@ -1340,33 +2051,33 @@ class E extends Error {
     };
   }
 }
-class d {
-  constructor(t) {
-    this._ok = !1, this._ts = Date.now(), this._pt = 0, t && this.setXData(t);
+class y {
+  constructor(e) {
+    this._ok = !1, this._ts = Date.now(), this._pt = 0, e && this.setXData(e);
   }
   // ---------------------------------------------------------------------------
   // Factories
   // ---------------------------------------------------------------------------
-  static create(t) {
-    return new d(t);
+  static create(e) {
+    return new y(e);
   }
-  static ok(t) {
-    return new d({ _ok: !0, _result: t });
+  static ok(e) {
+    return new y({ _ok: !0, _result: e });
   }
-  static error(t) {
-    if (t instanceof E)
-      return new d({
+  static error(e) {
+    if (e instanceof K)
+      return new y({
         _ok: !1,
-        _result: t.toXData()
+        _result: e.toXData()
       });
-    const e = new E(
+    const t = new K(
       "E_INTERNAL",
-      t?.message ?? String(t),
-      { _cause: t }
+      e?.message ?? String(e),
+      { _cause: e }
     );
-    return new d({
+    return new y({
       _ok: !1,
-      _result: e.toXData()
+      _result: t.toXData()
     });
   }
   // ---------------------------------------------------------------------------
@@ -1393,37 +2104,37 @@ class d {
   toString() {
     return JSON.stringify(this.toXData());
   }
-  setXData(t) {
-    t && ("_ok" in t && (this._ok = !!t._ok), "_ts" in t && typeof t._ts == "number" && (this._ts = t._ts), "_pt" in t && typeof t._pt == "number" && (this._pt = t._pt), "_result" in t && (this._result = t._result));
+  setXData(e) {
+    e && ("_ok" in e && (this._ok = !!e._ok), "_ts" in e && typeof e._ts == "number" && (this._ts = e._ts), "_pt" in e && typeof e._pt == "number" && (this._pt = e._pt), "_result" in e && (this._result = e._result));
   }
 }
-class V extends d {
-  constructor(t) {
-    super(d.error(t).toXData());
+class fe extends y {
+  constructor(e) {
+    super(y.error(e).toXData());
   }
 }
-class H extends d {
-  constructor(t) {
-    super({ _ok: !0, _result: t });
+class ge extends y {
+  constructor(e) {
+    super({ _ok: !0, _result: e });
   }
 }
-const U = "engine:frame-number", B = "engine:fps";
-class L {
-  constructor(t) {
-    this._log_rules = {}, this._modules = {}, this._schedule_frame = t?._schedule_frame ?? p.createDefaultScheduler(t?._target_fps), this._version = "0.0.1", this._engine_id = p.guid(), this._frame_number = 0, this._fps_calc = new M(), this.parser = g, this._modules = {}, b.fire("xpell-init"), a._enabled = !1;
+const ce = "engine:frame-number", _e = "engine:fps";
+class le {
+  constructor(e) {
+    this._log_rules = {}, this._modules = {}, this._schedule_frame = e?._schedule_frame ?? l.createDefaultScheduler(e?._target_fps), this._version = "0.0.1", this._engine_id = l.guid(), this._frame_number = 0, this._fps_calc = new Y(), this.parser = w, this._modules = {}, c._enabled = !1, ne(this);
   }
   /**
    * @deprecated use _verbose instead
    * Enable Xpell logs to console
    */
-  set verbose(t) {
-    a._enabled = t;
+  set verbose(e) {
+    c._enabled = e;
   }
   /**
    * Enable Xpell logs to console
    */
-  set _verbose(t) {
-    a._enabled = t;
+  set _verbose(e) {
+    c._enabled = e;
   }
   /**
    * Logs message to console using Xpell logger
@@ -1432,36 +2143,52 @@ class L {
    * @param msg 
    * @param optionalParams
    */
-  log(t, ...e) {
-    a.log(t, ...e);
+  log(e, ...t) {
+    c.log(e, ...t);
   }
   /**
    * Delay the execution of the next command
    * @param ms - delay in milliseconds
    * @returns 
    */
-  async delay(t) {
-    return new Promise((e) => setTimeout(e, t));
+  async delay(e) {
+    return new Promise((t) => setTimeout(t, e));
+  }
+  /** 
+   *  Module management
+   *  Modules are the main building blocks of Xpell applications, providing specific functionality (UI, data, etc.)
+   *  loadModule() is fire-and-forget.
+   * Use loadModuleAsync() for deterministic startup. 
+  */
+  addModule(e) {
+    return this._modules.hasOwnProperty(e._name) ? (c.log("Module " + e._name + " already loaded"), !1) : (this._modules[e._name] = e, !0);
   }
   /**
    * Loads Xpell module into the engine
    * @param {XModule} xModule 
    */
-  loadModule(t) {
-    this._modules.hasOwnProperty(t._name) ? a.log("Module " + t._name + " already loaded") : (this._modules[t._name] = t, t.load());
+  loadModule(e) {
+    this.addModule(e) && e.load();
   }
   /**
    * Loads multiple module at ones
    * @param {Array<XModule>} xModulesArray 
    */
-  loadModules(...t) {
-    t.forEach((e) => this.loadModule(e));
+  loadModules(...e) {
+    e.forEach((t) => this.loadModule(t));
+  }
+  async loadModuleAsync(e) {
+    this.addModule(e) && await e.load();
+  }
+  async loadModulesAsync(...e) {
+    for (const t of e)
+      await this.loadModuleAsync(t);
   }
   /**
    * Display information about the Xpell engine to the console
    */
   info() {
-    a.log(`Xpell information:
+    c.log(`Xpell information:
 - Engine Id: ` + this._engine_id + `
 - Version ` + this._version);
   }
@@ -1469,10 +2196,10 @@ class L {
   * Run textual xCommand -
   * @param {cmd} - text command
   */
-  run(t) {
-    if (t?.length > 2) {
-      let e = g.parse(t);
-      return this.execute(e);
+  run(e) {
+    if (e?.length > 2) {
+      let t = w.parse(e);
+      return this.execute(t);
     } else
       throw "Unable to parse Xpell command";
   }
@@ -1480,10 +2207,10 @@ class L {
    * Execute Xpell Command 
    * @param {XCommand} 
    */
-  execute(t) {
-    if (t && t._module && this._modules[t._module])
-      return this._modules[t._module].execute(t);
-    throw "Xpell module " + t._module + " not loaded";
+  execute(e) {
+    if (e && e._module && this._modules[e._module])
+      return this._modules[e._module].execute(e);
+    throw "Xpell module " + e._module + " not loaded";
   }
   /**
    * Main onFrame method
@@ -1491,63 +2218,85 @@ class L {
    */
   onFrame() {
     this._frame_number++;
-    for (const e of Object.keys(this._modules)) {
-      const s = this._modules[e];
+    for (const t of Object.keys(this._modules)) {
+      const s = this._modules[t];
       s?.onFrame && typeof s.onFrame == "function" && s.onFrame(this._frame_number);
     }
-    const t = this._fps_calc.calc();
-    u.set(U, this._frame_number, { source: "engine" }), u.set(B, t, { source: "engine" }), u._compat_legacy_keys && (u.set("frame-number", this._frame_number, { source: "engine:legacy" }), u.set("fps", t, { source: "engine:legacy" })), this._schedule_frame(() => this.onFrame());
+    const e = this._fps_calc.calc();
+    f.set(ce, this._frame_number, { source: "engine" }), f.set(_e, e, { source: "engine" }), f._compat_legacy_keys && (f.set("frame-number", this._frame_number, { source: "engine:legacy" }), f.set("fps", e, { source: "engine:legacy" })), this._schedule_frame(() => this.onFrame());
   }
   /**
    * Gets Xpell module by name
    * @param {string} moduleName - name of the loaded module
    * @returns {XModule}
    */
-  getModule(t) {
-    return this._modules[t];
+  getModule(e) {
+    return this._modules[e];
   }
   /**
    * Start Xpell engine for web browsers using requestAnimationFrame
    */
   start() {
-    a.log("Starting Xpell"), this.onFrame();
+    c.log("Loading Xpell core modules...[xd, xem]"), this.loadModule(new L()), this.loadModule(new U()), c.log("Starting Xpell"), this.onFrame();
   }
-  /**
-   * deprecated - use XData._o directly
-   */
-  getParam(t, e) {
-    return t in u._o ? u._o[t] : e;
+  getCoreSkills() {
+    return [
+      N,
+      R
+    ];
+  }
+  getModuleSkills() {
+    return Object.values(this._modules).flatMap(
+      (e) => typeof e.getSkillChain == "function" ? e.getSkillChain() : []
+    );
+  }
+  getSkills() {
+    return {
+      _runtime: {
+        _engine_id: this._engine_id,
+        _version: this._version
+      },
+      _skills: this.getCoreSkills(),
+      _modules: Object.values(this._modules).map((e) => ({
+        _name: e._name,
+        _skills: typeof e.getSkillChain == "function" ? e.getSkillChain() : [],
+        _objects: typeof e.getObjectSkills == "function" ? e.getObjectSkills() : []
+      }))
+    };
   }
 }
-const Q = new L();
+const be = new le();
 export {
-  x as XCommand,
-  B as XD_FPS,
-  U as XD_FRAME_NUMBER,
-  u as XData,
-  E as XError,
-  b as XEventManager,
-  a as XLogger,
-  q as XModule,
-  j as XObject,
-  R as XObjectManager,
-  W as XObjectPack,
-  J as XParams,
-  g as XParser,
-  d as XResponse,
-  V as XResponseError,
-  H as XResponseOK,
-  p as XUtils,
-  Q as Xpell,
-  L as XpellEngine,
-  A as _XData,
-  $ as _XEventManager,
-  I as _XLogger,
-  S as _XUtils,
-  Q as _x,
-  P as _xd,
-  b as _xem,
-  a as _xlog,
-  p as _xu,
-  Q as default
+  I as XCommand,
+  _e as XD_FPS,
+  ce as XD_FRAME_NUMBER,
+  x as XData,
+  L as XDataModule,
+  K as XError,
+  U as XEventManagerModule,
+  c as XLogger,
+  A as XModule,
+  F as XObject,
+  te as XObjectManager,
+  pe as XObjectPack,
+  me as XParams,
+  w as XParser,
+  y as XResponse,
+  fe as XResponseError,
+  ge as XResponseOK,
+  z as XUtils,
+  be as Xpell,
+  le as XpellEngine,
+  ee as _XData,
+  ue as _XEventManager,
+  Z as _XLogger,
+  Q as _XUtils,
+  be as _x,
+  f as _xd,
+  c as _xlog,
+  l as _xu,
+  g as createNanoCommandWithSkill,
+  be as default,
+  D as getXEventManager,
+  de as setXEventManager
 };