roboto-js 1.8.5 → 1.8.7

package/dist/esm/rbt_api.js

@@ -1,3 +1,26 @@
+var _excluded = ["enableRealtime"],
+  _excluded2 = ["enableRealtime"];
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return e; }; var t, e = {}, r = Object.prototype, n = r.hasOwnProperty, o = Object.defineProperty || function (t, e, r) { t[e] = r.value; }, i = "function" == typeof Symbol ? Symbol : {}, a = i.iterator || "@@iterator", c = i.asyncIterator || "@@asyncIterator", u = i.toStringTag || "@@toStringTag"; function define(t, e, r) { return Object.defineProperty(t, e, { value: r, enumerable: !0, configurable: !0, writable: !0 }), t[e]; } try { define({}, ""); } catch (t) { define = function define(t, e, r) { return t[e] = r; }; } function wrap(t, e, r, n) { var i = e && e.prototype instanceof Generator ? e : Generator, a = Object.create(i.prototype), c = new Context(n || []); return o(a, "_invoke", { value: makeInvokeMethod(t, r, c) }), a; } function tryCatch(t, e, r) { try { return { type: "normal", arg: t.call(e, r) }; } catch (t) { return { type: "throw", arg: t }; } } e.wrap = wrap; var h = "suspendedStart", l = "suspendedYield", f = "executing", s = "completed", y = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var p = {}; define(p, a, function () { return this; }); var d = Object.getPrototypeOf, v = d && d(d(values([]))); v && v !== r && n.call(v, a) && (p = v); var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p); function defineIteratorMethods(t) { ["next", "throw", "return"].forEach(function (e) { define(t, e, function (t) { return this._invoke(e, t); }); }); } function AsyncIterator(t, e) { function invoke(r, o, i, a) { var c = tryCatch(t[r], t, o); if ("throw" !== c.type) { var u = c.arg, h = u.value; return h && "object" == _typeof(h) && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) { invoke("next", t, i, a); }, function (t) { invoke("throw", t, i, a); }) : e.resolve(h).then(function (t) { u.value = t, i(u); }, function (t) { return invoke("throw", t, i, a); }); } a(c.arg); } var r; o(this, "_invoke", { value: function value(t, n) { function callInvokeWithMethodAndArg() { return new e(function (e, r) { invoke(t, n, e, r); }); } return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(e, r, n) { var o = h; return function (i, a) { if (o === f) throw new Error("Generator is already running"); if (o === s) { if ("throw" === i) throw a; return { value: t, done: !0 }; } for (n.method = i, n.arg = a;;) { var c = n.delegate; if (c) { var u = maybeInvokeDelegate(c, n); if (u) { if (u === y) continue; return u; } } if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) { if (o === h) throw o = s, n.arg; n.dispatchException(n.arg); } else "return" === n.method && n.abrupt("return", n.arg); o = f; var p = tryCatch(e, r, n); if ("normal" === p.type) { if (o = n.done ? s : l, p.arg === y) continue; return { value: p.arg, done: n.done }; } "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg); } }; } function maybeInvokeDelegate(e, r) { var n = r.method, o = e.iterator[n]; if (o === t) return r.delegate = null, "throw" === n && e.iterator["return"] && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y; var i = tryCatch(o, e.iterator, r.arg); if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y; var a = i.arg; return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y); } function pushTryEntry(t) { var e = { tryLoc: t[0] }; 1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e); } function resetTryEntry(t) { var e = t.completion || {}; e.type = "normal", delete e.arg, t.completion = e; } function Context(t) { this.tryEntries = [{ tryLoc: "root" }], t.forEach(pushTryEntry, this), this.reset(!0); } function values(e) { if (e || "" === e) { var r = e[a]; if (r) return r.call(e); if ("function" == typeof e.next) return e; if (!isNaN(e.length)) { var o = -1, i = function next() { for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next; return next.value = t, next.done = !0, next; }; return i.next = i; } } throw new TypeError(_typeof(e) + " is not iterable"); } return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", { value: GeneratorFunctionPrototype, configurable: !0 }), o(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) { var e = "function" == typeof t && t.constructor; return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name)); }, e.mark = function (t) { return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t; }, e.awrap = function (t) { return { __await: t }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () { return this; }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) { void 0 === i && (i = Promise); var a = new AsyncIterator(wrap(t, r, n, o), i); return e.isGeneratorFunction(r) ? a : a.next().then(function (t) { return t.done ? t.value : a.next(); }); }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () { return this; }), define(g, "toString", function () { return "[object Generator]"; }), e.keys = function (t) { var e = Object(t), r = []; for (var n in e) r.push(n); return r.reverse(), function next() { for (; r.length;) { var t = r.pop(); if (t in e) return next.value = t, next.done = !1, next; } return next.done = !0, next; }; }, e.values = values, Context.prototype = { constructor: Context, reset: function reset(e) { if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t); }, stop: function stop() { this.done = !0; var t = this.tryEntries[0].completion; if ("throw" === t.type) throw t.arg; return this.rval; }, dispatchException: function dispatchException(e) { if (this.done) throw e; var r = this; function handle(n, o) { return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o; } for (var o = this.tryEntries.length - 1; o >= 0; --o) { var i = this.tryEntries[o], a = i.completion; if ("root" === i.tryLoc) return handle("end"); if (i.tryLoc <= this.prev) { var c = n.call(i, "catchLoc"), u = n.call(i, "finallyLoc"); if (c && u) { if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); if (this.prev < i.finallyLoc) return handle(i.finallyLoc); } else if (c) { if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); } else { if (!u) throw new Error("try statement without catch or finally"); if (this.prev < i.finallyLoc) return handle(i.finallyLoc); } } } }, abrupt: function abrupt(t, e) { for (var r = this.tryEntries.length - 1; r >= 0; --r) { var o = this.tryEntries[r]; if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) { var i = o; break; } } i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null); var a = i ? i.completion : {}; return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a); }, complete: function complete(t, e) { if ("throw" === t.type) throw t.arg; return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y; }, finish: function finish(t) { for (var e = this.tryEntries.length - 1; e >= 0; --e) { var r = this.tryEntries[e]; if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y; } }, "catch": function _catch(t) { for (var e = this.tryEntries.length - 1; e >= 0; --e) { var r = this.tryEntries[e]; if (r.tryLoc === t) { var n = r.completion; if ("throw" === n.type) { var o = n.arg; resetTryEntry(r); } return o; } } throw new Error("illegal catch attempt"); }, delegateYield: function delegateYield(e, r, n) { return this.delegate = { iterator: values(e), resultName: r, nextLoc: n }, "next" === this.method && (this.arg = t), y; } }, e; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import axios from 'axios';
 import CryptoJS from 'crypto-js';
 import RbtObject from './rbt_object.js';
@@ -5,14 +28,17 @@ import RbtUser from './rbt_user.js';
 import RbtFile from './rbt_file.js';
 import _ from 'lodash';
 import { openDB } from 'idb';
-export default class RbtApi {
-  constructor({
-    baseUrl,
-    accesskey,
-    authtoken = null,
-    apikey = null,
-    localStorageAdaptor = null
-  }) {
+var RbtApi = /*#__PURE__*/function () {
+  function RbtApi(_ref) {
+    var baseUrl = _ref.baseUrl,
+      accesskey = _ref.accesskey,
+      _ref$authtoken = _ref.authtoken,
+      authtoken = _ref$authtoken === void 0 ? null : _ref$authtoken,
+      _ref$apikey = _ref.apikey,
+      apikey = _ref$apikey === void 0 ? null : _ref$apikey,
+      _ref$localStorageAdap = _ref.localStorageAdaptor,
+      localStorageAdaptor = _ref$localStorageAdap === void 0 ? null : _ref$localStorageAdap;
+    _classCallCheck(this, RbtApi);
     this.websocketClient = null;
 
     // Object cache for sharing instances across multiple load() calls
@@ -36,15 +62,23 @@ export default class RbtApi {
     } else if (typeof localStorage != 'undefined') {
       // browser based local storage
       this.localStorageAdaptor = {
-        getItem: key => Promise.resolve(localStorage.getItem(key)),
-        setItem: (key, value) => Promise.resolve(localStorage.setItem(key, value)),
-        removeItem: key => Promise.resolve(localStorage.removeItem(key))
+        getItem: function getItem(key) {
+          return Promise.resolve(localStorage.getItem(key));
+        },
+        setItem: function setItem(key, value) {
+          return Promise.resolve(localStorage.setItem(key, value));
+        },
+        removeItem: function removeItem(key) {
+          return Promise.resolve(localStorage.removeItem(key));
+        }
       };
     }
 
     // Asynchronous browser hydration: set auth header and in-memory user
     // Use storage adaptor if available, otherwise fallback to localStorage
-    this._initializeFromStorage().catch(e => console.warn('[RbtApi] Storage initialization failed:', e));
+    this._initializeFromStorage()["catch"](function (e) {
+      return void 0;
+    });
     this.localDb = null;
     this.iac_session = null;
     this.appServiceHost = baseUrl;
@@ -59,1239 +93,1997 @@ export default class RbtApi {
     if (apikey) {
       this.apikey = apikey;
       this.axios.defaults.headers.common['apikey'] = this.apikey;
+      // ADD THIS LINE
     }
     this.initApiKey(apikey);
   }
 
   // Initialize authtoken and user from storage (cookies or localStorage)
-  async _initializeFromStorage() {
-    if (!this.localStorageAdaptor) return;
-    try {
-      // Try to get authtoken from storage adaptor (prefixed: rbt_authtoken)
-      let token = await this.localStorageAdaptor.getItem('authtoken');
-
-      // If not found in prefixed storage, try raw cookie (like accessKey)
-      if (!token && typeof document !== 'undefined') {
-        // Try to get from raw cookie
-        const cookies = document.cookie.split(';');
-        for (let cookie of cookies) {
-          const [name, value] = cookie.trim().split('=');
-          if (name === 'authtoken') {
-            token = decodeURIComponent(value);
-            break;
+  _createClass(RbtApi, [{
+    key: "_initializeFromStorage",
+    value: function () {
+      var _initializeFromStorage2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        var token, cookies, _iterator, _step, cookie, _cookie$trim$split, _cookie$trim$split2, name, value, cachedUser, parsed;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (this.localStorageAdaptor) {
+                _context.next = 2;
+                break;
+              }
+              return _context.abrupt("return");
+            case 2:
+              _context.prev = 2;
+              _context.next = 5;
+              return this.localStorageAdaptor.getItem('authtoken');
+            case 5:
+              token = _context.sent;
+              if (!(!token && typeof document !== 'undefined')) {
+                _context.next = 27;
+                break;
+              }
+              // Try to get from raw cookie
+              cookies = document.cookie.split(';');
+              _iterator = _createForOfIteratorHelper(cookies);
+              _context.prev = 9;
+              _iterator.s();
+            case 11:
+              if ((_step = _iterator.n()).done) {
+                _context.next = 19;
+                break;
+              }
+              cookie = _step.value;
+              _cookie$trim$split = cookie.trim().split('='), _cookie$trim$split2 = _slicedToArray(_cookie$trim$split, 2), name = _cookie$trim$split2[0], value = _cookie$trim$split2[1];
+              if (!(name === 'authtoken')) {
+                _context.next = 17;
+                break;
+              }
+              token = decodeURIComponent(value);
+              return _context.abrupt("break", 19);
+            case 17:
+              _context.next = 11;
+              break;
+            case 19:
+              _context.next = 24;
+              break;
+            case 21:
+              _context.prev = 21;
+              _context.t0 = _context["catch"](9);
+              _iterator.e(_context.t0);
+            case 24:
+              _context.prev = 24;
+              _iterator.f();
+              return _context.finish(24);
+            case 27:
+              if (token) {
+                this.authtoken = token;
+                this.axios.defaults.headers.common['authtoken'] = token;
+              }
+              _context.next = 32;
+              break;
+            case 30:
+              _context.prev = 30;
+              _context.t1 = _context["catch"](2);
+            case 32:
+              _context.prev = 32;
+              _context.next = 35;
+              return this.localStorageAdaptor.getItem('rbtUser');
+            case 35:
+              cachedUser = _context.sent;
+              if (cachedUser) {
+                parsed = typeof cachedUser === 'string' ? JSON.parse(cachedUser) : cachedUser;
+                if (parsed && parsed.id) {
+                  this.currentUser = new RbtUser({
+                    id: parsed.id
+                  }, this.axios);
+                  this.currentUser.setData(parsed);
+                }
+              }
+              _context.next = 41;
+              break;
+            case 39:
+              _context.prev = 39;
+              _context.t2 = _context["catch"](32);
+            case 41:
+            case "end":
+              return _context.stop();
           }
-        }
-      }
-      if (token) {
-        this.authtoken = token;
-        this.axios.defaults.headers.common['authtoken'] = token;
-        console.log('[RbtApi] Loaded authtoken from storage adaptor');
+        }, _callee, this, [[2, 30], [9, 21, 24, 27], [32, 39]]);
+      }));
+      function _initializeFromStorage() {
+        return _initializeFromStorage2.apply(this, arguments);
       }
-    } catch (e) {
-      console.warn('[RbtApi] Failed to load authtoken from storage adaptor:', e);
-    }
-    try {
-      // Try to get user from storage adaptor
-      const cachedUser = await this.localStorageAdaptor.getItem('rbtUser');
-      if (cachedUser) {
-        const parsed = typeof cachedUser === 'string' ? JSON.parse(cachedUser) : cachedUser;
-        if (parsed && parsed.id) {
-          this.currentUser = new RbtUser({
-            id: parsed.id
-          }, this.axios);
-          this.currentUser.setData(parsed);
-          console.log('[RbtApi] Loaded user from storage adaptor');
-        }
+      return _initializeFromStorage;
+    }()
+  }, {
+    key: "getWebSocketClient",
+    value: function getWebSocketClient() {
+      // Reuse existing WebSocket if it's OPEN or CONNECTING (to prevent race condition)
+      if (this.websocketClient && (this.websocketClient.readyState === WebSocket.OPEN || this.websocketClient.readyState === WebSocket.CONNECTING)) {
+        return this.websocketClient;
       }
-    } catch (e) {
-      console.warn('[RbtApi] Failed to load user from storage adaptor:', e);
-    }
-  }
-  getWebSocketClient() {
-    // Reuse existing WebSocket if it's OPEN or CONNECTING (to prevent race condition)
-    if (this.websocketClient && (this.websocketClient.readyState === WebSocket.OPEN || this.websocketClient.readyState === WebSocket.CONNECTING)) {
+      var baseUrl = this.axios.defaults.baseURL;
+      var wsProtocol = baseUrl.startsWith('https') ? 'wss://' : 'ws://';
+      var wsUrl = baseUrl.replace(/^https?:\/\//, wsProtocol);
+      this.websocketClient = new WebSocket("".concat(wsUrl, "/realtime"));
+      this._setupWebSocketHandlers(this.websocketClient);
       return this.websocketClient;
     }
-    const baseUrl = this.axios.defaults.baseURL;
-    const wsProtocol = baseUrl.startsWith('https') ? 'wss://' : 'ws://';
-    const wsUrl = baseUrl.replace(/^https?:\/\//, wsProtocol);
-    console.log('[RbtApi] Creating new WebSocket connection to:', wsUrl + '/realtime');
-    this.websocketClient = new WebSocket(`${wsUrl}/realtime`);
-    this._setupWebSocketHandlers(this.websocketClient);
-    return this.websocketClient;
-  }
-  _setupWebSocketHandlers(ws) {
-    ws.onopen = () => {
-      console.log('[RbtApi] WebSocket connected.');
-      this._wsReconnectAttempts = 0;
-      this._wsConnected = true;
+  }, {
+    key: "_setupWebSocketHandlers",
+    value: function _setupWebSocketHandlers(ws) {
+      var _this = this;
+      ws.onopen = function () {
+        _this._wsReconnectAttempts = 0;
+        _this._wsConnected = true;
+
+        // Re-subscribe to all objects that were previously subscribed
+        if (_this._wsSubscriptions) {
+          var _iterator2 = _createForOfIteratorHelper(_this._wsSubscriptions),
+            _step2;
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var objectId = _step2.value;
+              ws.send(JSON.stringify({
+                type: 'subscribe',
+                objectId: objectId
+              }));
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+        }
+      };
+      ws.onclose = function (event) {
+        _this._wsConnected = false;
+
+        // Attempt reconnection with exponential backoff
+        if (!_this._wsManualClose && _this._wsReconnectAttempts < 5) {
+          var delay = Math.min(1000 * Math.pow(2, _this._wsReconnectAttempts), 30000);
+          setTimeout(function () {
+            _this._wsReconnectAttempts++;
+            _this.websocketClient = null; // Clear the old connection
+            _this.getWebSocketClient(); // Create new connection
+          }, delay);
+        }
+      };
+      ws.onerror = function (err) {
+        console.error('[RbtApi] WebSocket error:', err);
+        _this._wsConnected = false;
+      };
 
-      // Re-subscribe to all objects that were previously subscribed
-      if (this._wsSubscriptions) {
-        for (const objectId of this._wsSubscriptions) {
-          ws.send(JSON.stringify({
-            type: 'subscribe',
-            objectId
-          }));
+      // Handle ping/pong for keep-alive
+      ws.addEventListener('ping', function () {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.pong();
         }
-      }
-    };
-    ws.onclose = event => {
-      console.warn('[RbtApi] WebSocket closed:', event.code, event.reason);
-      this._wsConnected = false;
+      });
 
-      // Attempt reconnection with exponential backoff
-      if (!this._wsManualClose && this._wsReconnectAttempts < 5) {
-        const delay = Math.min(1000 * Math.pow(2, this._wsReconnectAttempts), 30000);
-        console.log(`[RbtApi] Attempting reconnection in ${delay}ms (attempt ${this._wsReconnectAttempts + 1}/5)`);
-        setTimeout(() => {
-          this._wsReconnectAttempts++;
-          this.websocketClient = null; // Clear the old connection
-          this.getWebSocketClient(); // Create new connection
-        }, delay);
-      }
-    };
-    ws.onerror = err => {
-      console.error('[RbtApi] WebSocket error:', err);
+      // Initialize connection tracking
+      this._wsReconnectAttempts = this._wsReconnectAttempts || 0;
       this._wsConnected = false;
-    };
-
-    // Handle ping/pong for keep-alive
-    ws.addEventListener('ping', () => {
-      if (ws.readyState === WebSocket.OPEN) {
-        ws.pong();
-      }
-    });
-
-    // Initialize connection tracking
-    this._wsReconnectAttempts = this._wsReconnectAttempts || 0;
-    this._wsConnected = false;
-    this._wsManualClose = false;
-    this._wsSubscriptions = this._wsSubscriptions || new Set();
-  }
-
-  // Method to track subscriptions for reconnection
-  _trackSubscription(objectId) {
-    if (!this._wsSubscriptions) this._wsSubscriptions = new Set();
-    this._wsSubscriptions.add(objectId);
-  }
-  _untrackSubscription(objectId) {
-    if (this._wsSubscriptions) {
-      this._wsSubscriptions.delete(objectId);
+      this._wsManualClose = false;
+      this._wsSubscriptions = this._wsSubscriptions || new Set();
     }
-  }
 
-  // Method to gracefully close WebSocket
-  closeWebSocket() {
-    if (this.websocketClient) {
-      this._wsManualClose = true;
-      this.websocketClient.close();
-      this.websocketClient = null;
-    }
-  }
-  async initAuthToken(authtoken) {
-    if (!authtoken && this.localStorageAdaptor) {
-      authtoken = await this.localStorageAdaptor.getItem('authtoken');
-    }
-    if (authtoken) {
-      this.authtoken = authtoken;
-      this.axios.defaults.headers.common['authtoken'] = this.authtoken;
-    }
-  }
-  async initApiKey(apikey) {
-    if (!apikey && this.localStorageAdaptor) {
-      apikey = await this.localStorageAdaptor.getItem('apikey');
-    }
-    if (apikey) {
-      this.apikey = apikey;
-      this.axios.defaults.headers.common['apikey'] = this.apikey;
+    // Method to track subscriptions for reconnection
+  }, {
+    key: "_trackSubscription",
+    value: function _trackSubscription(objectId) {
+      if (!this._wsSubscriptions) this._wsSubscriptions = new Set();
+      this._wsSubscriptions.add(objectId);
     }
-  }
-  async initLocalDb() {
-    this.localDb = await openDB('RBTFileDatabase', 1, {
-      upgrade(db) {
-        if (!db.objectStoreNames.contains('files')) {
-          db.createObjectStore('files', {
-            autoIncrement: true
-          });
-        }
+  }, {
+    key: "_untrackSubscription",
+    value: function _untrackSubscription(objectId) {
+      if (this._wsSubscriptions) {
+        this._wsSubscriptions["delete"](objectId);
       }
-    });
-  }
-  setAppServiceHost(host) {
-    this.appServiceHost = host;
-    this.axios.defaults.baseURL = host;
-  }
-  setSiteEnv(siteEnv) {
-    this.siteEnv = siteEnv;
-  }
-  getSiteEnv(key = null) {
-    if (key) {
-      return this.siteEnv[key];
-    }
-    return this.siteEnv;
-  }
-  async registerTypedefs(typedefs) {
-    try {
-      const response = await this.axios.post('/api/doctree/registerTypedefs', [{
-        typedefs: typedefs
-      }]);
-      return response.data;
-    } catch (e) {
-      this._handleError(e);
     }
-  }
 
-  /**
-     * Logs in a user and stores the authToken.
-     *
-     * @param {Object} params - The login parameters.
-     * @param {string} params.email - The email of the user.
-     * @param {string} params.password - The password of the user.
-     * @param {string} params.code - The password of the user.
-     * @returns {Promise<Object>} - The response data from the API.
-     */
-  async login(params) {
-    try {
-      const response = await this.axios.post('/user_service/loginUser', [{
-        email: params.email,
-        password: params.password ? CryptoJS.MD5(params.password).toString(CryptoJS.enc.Hex) : null,
-        // legacy hash password (md5)
-        passwd: params.password || null,
-        // current password
-        code: params.code || null // single-use signon code (password resets)
-      }]);
-      if (response.data.ok === false) {
-        return this._handleError(response);
+    // Method to gracefully close WebSocket
+  }, {
+    key: "closeWebSocket",
+    value: function closeWebSocket() {
+      if (this.websocketClient) {
+        this._wsManualClose = true;
+        this.websocketClient.close();
+        this.websocketClient = null;
       }
-      this.iac_session = response.data;
-      this.currentUser = this.iac_session ? new RbtUser(this.iac_session.user, this.axios) : null;
-      // update axios instance headers with authtoken
-      this.axios.defaults.headers.common['authtoken'] = response.data.authToken;
-      this.authtoken = response.data.authToken;
-      if (this.localStorageAdaptor) {
-        await this.localStorageAdaptor.setItem('authtoken', response.data.authToken);
-        if (this.iac_session?.user) {
-          await this.localStorageAdaptor.setItem('rbtUser', JSON.stringify(this.iac_session.user));
-        }
-
-        // authtoken is automatically stored for server-side access by the adapter
-      }
-      return response.data;
-    } catch (e) {
-      this._handleError(e);
     }
-  }
-  async loginWithOauth(userData) {
-    try {
-      const response = await this.post('/api/account/registerOrSigninOauth', userData);
-      if (response.ok === false) {
-        return this._handleError(response);
+  }, {
+    key: "initAuthToken",
+    value: function () {
+      var _initAuthToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(authtoken) {
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              if (!(!authtoken && this.localStorageAdaptor)) {
+                _context2.next = 4;
+                break;
+              }
+              _context2.next = 3;
+              return this.localStorageAdaptor.getItem('authtoken');
+            case 3:
+              authtoken = _context2.sent;
+            case 4:
+              if (authtoken) {
+                this.authtoken = authtoken;
+                this.axios.defaults.headers.common['authtoken'] = this.authtoken;
+              }
+            case 5:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function initAuthToken(_x) {
+        return _initAuthToken.apply(this, arguments);
+      }
+      return initAuthToken;
+    }()
+  }, {
+    key: "initApiKey",
+    value: function () {
+      var _initApiKey = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(apikey) {
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              if (!(!apikey && this.localStorageAdaptor)) {
+                _context3.next = 4;
+                break;
+              }
+              _context3.next = 3;
+              return this.localStorageAdaptor.getItem('apikey');
+            case 3:
+              apikey = _context3.sent;
+            case 4:
+              if (apikey) {
+                this.apikey = apikey;
+                this.axios.defaults.headers.common['apikey'] = this.apikey;
+              }
+            case 5:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function initApiKey(_x2) {
+        return _initApiKey.apply(this, arguments);
       }
-      this.iac_session = response;
-      this.currentUser = this.iac_session ? new RbtUser(this.iac_session.user, this.axios) : null;
-      // update axios instance headers with authtoken
-      this.axios.defaults.headers.common['authtoken'] = response.authToken;
-      this.authtoken = response.authToken;
-      if (this.localStorageAdaptor) {
-        await this.localStorageAdaptor.setItem('authtoken', response.authToken);
+      return initApiKey;
+    }()
+  }, {
+    key: "initLocalDb",
+    value: function () {
+      var _initLocalDb = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return openDB('RBTFileDatabase', 1, {
+                upgrade: function upgrade(db) {
+                  if (!db.objectStoreNames.contains('files')) {
+                    db.createObjectStore('files', {
+                      autoIncrement: true
+                    });
+                  }
+                }
+              });
+            case 2:
+              this.localDb = _context4.sent;
+            case 3:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function initLocalDb() {
+        return _initLocalDb.apply(this, arguments);
       }
-      return response;
-    } catch (e) {
-      this._handleError(e);
+      return initLocalDb;
+    }()
+  }, {
+    key: "setAppServiceHost",
+    value: function setAppServiceHost(host) {
+      this.appServiceHost = host;
+      this.axios.defaults.baseURL = host;
     }
-  }
-  async logout() {
-    try {
-      // Call logout endpoint if necessary. Here, I assume there's a '/user_service/logoutUser' endpoint.
-      // This is optional and depends on how your backend is set up.
-      const response = await this.axios.post('/user_service/logoutUser');
-      if (response.data.ok === false) {
-        return this._handleError(response);
+  }, {
+    key: "setSiteEnv",
+    value: function setSiteEnv(siteEnv) {
+      this.siteEnv = siteEnv;
+    }
+  }, {
+    key: "getSiteEnv",
+    value: function getSiteEnv() {
+      var key = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      if (key) {
+        return this.siteEnv[key];
       }
-
-      // Clear the iac_session and remove the auth token from axios headers
-      this.iac_session = null;
-      this.currentUser = null;
-      this.authtoken = null;
-      if (this.axios.defaults.headers.common['authtoken']) {
-        delete this.axios.defaults.headers.common['authtoken'];
+      return this.siteEnv;
+    }
+  }, {
+    key: "registerTypedefs",
+    value: function () {
+      var _registerTypedefs = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(typedefs) {
+        var response;
+        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.prev = 0;
+              _context5.next = 3;
+              return this.axios.post('/api/doctree/registerTypedefs', [{
+                typedefs: typedefs
+              }]);
+            case 3:
+              response = _context5.sent;
+              return _context5.abrupt("return", response.data);
+            case 7:
+              _context5.prev = 7;
+              _context5.t0 = _context5["catch"](0);
+              this._handleError(_context5.t0);
+            case 10:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this, [[0, 7]]);
+      }));
+      function registerTypedefs(_x3) {
+        return _registerTypedefs.apply(this, arguments);
       }
-
-      // Clear localStorage if it's being used
-      if (this.localStorageAdaptor) {
-        await this.localStorageAdaptor.removeItem('authtoken');
+      return registerTypedefs;
+    }()
+    /**
+       * Logs in a user and stores the authToken.
+       *
+       * @param {Object} params - The login parameters.
+       * @param {string} params.email - The email of the user.
+       * @param {string} params.password - The password of the user.
+       * @param {string} params.code - The password of the user.
+       * @returns {Promise<Object>} - The response data from the API.
+       */
+  }, {
+    key: "login",
+    value: (function () {
+      var _login = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(params) {
+        var response, _this$iac_session;
+        return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              _context6.prev = 0;
+              _context6.next = 3;
+              return this.axios.post('/user_service/loginUser', [{
+                email: params.email,
+                password: params.password ? CryptoJS.MD5(params.password).toString(CryptoJS.enc.Hex) : null,
+                // legacy hash password (md5)
+                passwd: params.password || null,
+                // current password
+                code: params.code || null // single-use signon code (password resets)
+              }]);
+            case 3:
+              response = _context6.sent;
+              if (!(response.data.ok === false)) {
+                _context6.next = 6;
+                break;
+              }
+              return _context6.abrupt("return", this._handleError(response));
+            case 6:
+              this.iac_session = response.data;
+              this.currentUser = this.iac_session ? new RbtUser(this.iac_session.user, this.axios) : null;
+              // update axios instance headers with authtoken
+              this.axios.defaults.headers.common['authtoken'] = response.data.authToken;
+              this.authtoken = response.data.authToken;
+              if (!this.localStorageAdaptor) {
+                _context6.next = 16;
+                break;
+              }
+              _context6.next = 13;
+              return this.localStorageAdaptor.setItem('authtoken', response.data.authToken);
+            case 13:
+              if (!((_this$iac_session = this.iac_session) !== null && _this$iac_session !== void 0 && _this$iac_session.user)) {
+                _context6.next = 16;
+                break;
+              }
+              _context6.next = 16;
+              return this.localStorageAdaptor.setItem('rbtUser', JSON.stringify(this.iac_session.user));
+            case 16:
+              return _context6.abrupt("return", response.data);
+            case 19:
+              _context6.prev = 19;
+              _context6.t0 = _context6["catch"](0);
+              this._handleError(_context6.t0);
+            case 22:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this, [[0, 19]]);
+      }));
+      function login(_x4) {
+        return _login.apply(this, arguments);
+      }
+      return login;
+    }())
+  }, {
+    key: "loginWithOauth",
+    value: function () {
+      var _loginWithOauth = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(userData) {
+        var response;
+        return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              _context7.prev = 0;
+              _context7.next = 3;
+              return this.post('/api/account/registerOrSigninOauth', userData);
+            case 3:
+              response = _context7.sent;
+              if (!(response.ok === false)) {
+                _context7.next = 6;
+                break;
+              }
+              return _context7.abrupt("return", this._handleError(response));
+            case 6:
+              this.iac_session = response;
+              this.currentUser = this.iac_session ? new RbtUser(this.iac_session.user, this.axios) : null;
+              // update axios instance headers with authtoken
+              this.axios.defaults.headers.common['authtoken'] = response.authToken;
+              this.authtoken = response.authToken;
+              if (!this.localStorageAdaptor) {
+                _context7.next = 13;
+                break;
+              }
+              _context7.next = 13;
+              return this.localStorageAdaptor.setItem('authtoken', response.authToken);
+            case 13:
+              return _context7.abrupt("return", response);
+            case 16:
+              _context7.prev = 16;
+              _context7.t0 = _context7["catch"](0);
+              this._handleError(_context7.t0);
+            case 19:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this, [[0, 16]]);
+      }));
+      function loginWithOauth(_x5) {
+        return _loginWithOauth.apply(this, arguments);
       }
+      return loginWithOauth;
+    }()
+  }, {
+    key: "logout",
+    value: function () {
+      var _logout = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8() {
+        var response;
+        return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              _context8.prev = 0;
+              _context8.next = 3;
+              return this.axios.post('/user_service/logoutUser');
+            case 3:
+              response = _context8.sent;
+              if (!(response.data.ok === false)) {
+                _context8.next = 6;
+                break;
+              }
+              return _context8.abrupt("return", this._handleError(response));
+            case 6:
+              // Clear the iac_session and remove the auth token from axios headers
+              this.iac_session = null;
+              this.currentUser = null;
+              this.authtoken = null;
+              if (this.axios.defaults.headers.common['authtoken']) {
+                delete this.axios.defaults.headers.common['authtoken'];
+              }
 
-      // Return some kind of success response or the response from the server
-      return response.data;
-    } catch (e) {
-      this._handleError(e);
-    }
-  }
-  getCurrentUser() {
-    if (this.currentUser) {
-      return this.currentUser;
-    }
-  }
-  async loadCurrentUser() {
-    try {
-      if (this._loadCurrentUserPromise) {
-        return this._loadCurrentUserPromise;
+              // Clear localStorage if it's being used
+              if (!this.localStorageAdaptor) {
+                _context8.next = 13;
+                break;
+              }
+              _context8.next = 13;
+              return this.localStorageAdaptor.removeItem('authtoken');
+            case 13:
+              return _context8.abrupt("return", response.data);
+            case 16:
+              _context8.prev = 16;
+              _context8.t0 = _context8["catch"](0);
+              this._handleError(_context8.t0);
+            case 19:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this, [[0, 16]]);
+      }));
+      function logout() {
+        return _logout.apply(this, arguments);
       }
+      return logout;
+    }()
+  }, {
+    key: "getCurrentUser",
+    value: function getCurrentUser() {
       if (this.currentUser) {
         return this.currentUser;
       }
-      if (this.apikey) {
-        // NOT IMPLEMENTED
-        return null;
-      } else if (this.authtoken) {
-        this._loadCurrentUserPromise = (async () => {
-          let response = await this.refreshAuthToken(this.authtoken);
-          if (!response) return null;
-          if (response?.user) {
-            this.currentUser = new RbtUser({
-              id: response?.user?.id
-            }, this.axios);
-            this.currentUser.setData(response.user);
-            if (this.localStorageAdaptor) {
-              await this.localStorageAdaptor.setItem('rbtUser', JSON.stringify(response.user));
-            }
+    }
+  }, {
+    key: "loadCurrentUser",
+    value: function () {
+      var _loadCurrentUser = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10() {
+        var _this2 = this;
+        var result;
+        return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              _context10.prev = 0;
+              if (!this._loadCurrentUserPromise) {
+                _context10.next = 3;
+                break;
+              }
+              return _context10.abrupt("return", this._loadCurrentUserPromise);
+            case 3:
+              if (!this.currentUser) {
+                _context10.next = 5;
+                break;
+              }
+              return _context10.abrupt("return", this.currentUser);
+            case 5:
+              if (!this.apikey) {
+                _context10.next = 9;
+                break;
+              }
+              return _context10.abrupt("return", null);
+            case 9:
+              if (!this.authtoken) {
+                _context10.next = 18;
+                break;
+              }
+              this._loadCurrentUserPromise = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9() {
+                var response, _response$user;
+                return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+                  while (1) switch (_context9.prev = _context9.next) {
+                    case 0:
+                      _context9.next = 2;
+                      return _this2.refreshAuthToken(_this2.authtoken);
+                    case 2:
+                      response = _context9.sent;
+                      if (response) {
+                        _context9.next = 5;
+                        break;
+                      }
+                      return _context9.abrupt("return", null);
+                    case 5:
+                      if (!(response !== null && response !== void 0 && response.user)) {
+                        _context9.next = 11;
+                        break;
+                      }
+                      _this2.currentUser = new RbtUser({
+                        id: response === null || response === void 0 || (_response$user = response.user) === null || _response$user === void 0 ? void 0 : _response$user.id
+                      }, _this2.axios);
+                      _this2.currentUser.setData(response.user);
+                      if (!_this2.localStorageAdaptor) {
+                        _context9.next = 11;
+                        break;
+                      }
+                      _context9.next = 11;
+                      return _this2.localStorageAdaptor.setItem('rbtUser', JSON.stringify(response.user));
+                    case 11:
+                      return _context9.abrupt("return", _this2.currentUser);
+                    case 12:
+                    case "end":
+                      return _context9.stop();
+                  }
+                }, _callee9);
+              }))();
+              _context10.next = 13;
+              return this._loadCurrentUserPromise;
+            case 13:
+              result = _context10.sent;
+              this._loadCurrentUserPromise = null;
+              return _context10.abrupt("return", result);
+            case 18:
+              this.currentUser = null;
+            case 19:
+              return _context10.abrupt("return", null);
+            case 22:
+              _context10.prev = 22;
+              _context10.t0 = _context10["catch"](0);
+              return _context10.abrupt("return", this._handleError(_context10.t0));
+            case 25:
+            case "end":
+              return _context10.stop();
           }
-          return this.currentUser;
-        })();
-        const result = await this._loadCurrentUserPromise;
-        this._loadCurrentUserPromise = null;
-        return result;
-        //this.currentOrg = new RbtObject(response.organization, this.axios);
-        //this.currentOrg.type = '<@iac.organization>';
-      } else {
-        this.currentUser = null;
+        }, _callee10, this, [[0, 22]]);
+      }));
+      function loadCurrentUser() {
+        return _loadCurrentUser.apply(this, arguments);
       }
-      return null;
-    } catch (e) {
-      return this._handleError(e);
-    }
-  }
-  async confirmUserEmail(confirmCode) {
-    let params = {
-      emailConfirmCode: confirmCode
-    };
-    try {
-      const response = await this.axios.post('/user_service/confirmUserEmail', [params]);
-      if (response.data.ok === false) {
-        return this._handleError(response);
+      return loadCurrentUser;
+    }()
+  }, {
+    key: "confirmUserEmail",
+    value: function () {
+      var _confirmUserEmail = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(confirmCode) {
+        var params, response;
+        return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              params = {
+                emailConfirmCode: confirmCode
+              };
+              _context11.prev = 1;
+              _context11.next = 4;
+              return this.axios.post('/user_service/confirmUserEmail', [params]);
+            case 4:
+              response = _context11.sent;
+              if (!(response.data.ok === false)) {
+                _context11.next = 7;
+                break;
+              }
+              return _context11.abrupt("return", this._handleError(response));
+            case 7:
+              return _context11.abrupt("return", response.data);
+            case 10:
+              _context11.prev = 10;
+              _context11.t0 = _context11["catch"](1);
+              return _context11.abrupt("return", this._handleError(_context11.t0));
+            case 13:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11, this, [[1, 10]]);
+      }));
+      function confirmUserEmail(_x6) {
+        return _confirmUserEmail.apply(this, arguments);
       }
-      return response.data;
-    } catch (e) {
-      return this._handleError(e);
-    }
-  }
-  async loadCurrentUserExtended() {
-    if (this._loadCurrentUserExtendedPromise) {
-      return this._loadCurrentUserExtendedPromise;
-    }
-    this._loadCurrentUserExtendedPromise = (async () => {
-      let currentUser = await this.loadCurrentUser();
-      if (currentUser) {
-        return this.loadUser(currentUser.id);
-      } else {
-        return null;
+      return confirmUserEmail;
+    }()
+  }, {
+    key: "loadCurrentUserExtended",
+    value: function () {
+      var _loadCurrentUserExtended = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13() {
+        var _this3 = this;
+        return _regeneratorRuntime().wrap(function _callee13$(_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              if (!this._loadCurrentUserExtendedPromise) {
+                _context13.next = 2;
+                break;
+              }
+              return _context13.abrupt("return", this._loadCurrentUserExtendedPromise);
+            case 2:
+              this._loadCurrentUserExtendedPromise = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12() {
+                var currentUser;
+                return _regeneratorRuntime().wrap(function _callee12$(_context12) {
+                  while (1) switch (_context12.prev = _context12.next) {
+                    case 0:
+                      _context12.next = 2;
+                      return _this3.loadCurrentUser();
+                    case 2:
+                      currentUser = _context12.sent;
+                      if (!currentUser) {
+                        _context12.next = 7;
+                        break;
+                      }
+                      return _context12.abrupt("return", _this3.loadUser(currentUser.id));
+                    case 7:
+                      return _context12.abrupt("return", null);
+                    case 8:
+                    case "end":
+                      return _context12.stop();
+                  }
+                }, _callee12);
+              }))();
+              _context13.prev = 3;
+              _context13.next = 6;
+              return this._loadCurrentUserExtendedPromise;
+            case 6:
+              return _context13.abrupt("return", _context13.sent);
+            case 7:
+              _context13.prev = 7;
+              this._loadCurrentUserExtendedPromise = null;
+              return _context13.finish(7);
+            case 10:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee13, this, [[3,, 7, 10]]);
+      }));
+      function loadCurrentUserExtended() {
+        return _loadCurrentUserExtended.apply(this, arguments);
       }
-    })();
-    try {
-      return await this._loadCurrentUserExtendedPromise;
-    } finally {
-      this._loadCurrentUserExtendedPromise = null;
-    }
-  }
-  async loadUser(userId) {
-    let params = {
-      id: userId
-    };
-    const cacheKey = `loadUser:${userId}`;
-    const now = Date.now();
-    const existing = this.requestCache[cacheKey];
-    if (existing && now - existing.time < 10000) {
-      // 10s TTL
-      return existing.val;
-    }
-    try {
-      const p = (async () => {
-        const response = await this.axios.post('/user_service/loadUser', [params]);
-        let userData = response?.data?.user;
-        let User = new RbtUser({
-          id: userData.id
-        }, this.axios);
-        User.setData(userData);
-        return User;
-      })();
-      this.requestCache[cacheKey] = {
-        val: p,
-        time: now
-      };
-      return await p;
-    } catch (e) {
-      return this._handleError(e);
-    }
-  }
-  async refreshAuthToken(authtoken) {
-    if (!this.appServiceHost) {
-      console.warn('RBTTOK not initialized');
-      return false;
-    }
-    if (this.requestCache[authtoken]) {
-      // If there's already a pending promise to refresh this token, return it
-      //console.log('RBTTOK Using cached promise for token refresh');
-      return this.requestCache[authtoken];
-    }
-    try {
-      //console.log('RBTTOK Req', authtoken);
-      // Create a new promise for the token refresh and store it in the cache
-      const promise = this.axios.post('/user_service/refreshAuthToken', [authtoken]);
-      this.requestCache[authtoken] = promise;
-
-      // Await the promise to get the response
-      const response = await promise;
-
-      //console.log('RBTTOK Response ',response);
-      // Once the promise resolves, delete it from the cache to allow future refreshes
-      delete this.requestCache[authtoken];
-
-      // Return the response data
-      return response.data;
-    } catch (e) {
-      // On error, remove the cached promise to allow retries
-      delete this.requestCache[authtoken];
-      this._handleError(e);
-    }
-  }
-
-  //  async refreshAuthToken(authtoken){
-  //
-  //    if(!this.appServiceHost){
-  //      console.warn('appServiceHost not initialized');
-  //      return false;
-  //    }
-  //
-  //    try {
-  //
-  //      const response = await this.axios.post('/user_service/refreshAuthToken', [authtoken]);
-  //      return response.data;
-  //
-  //    } catch (e) {
-  //
-  //      this._handleError(e);
-  //    }
-  //  }
-
-  /**
-   * Registers a new user.
-   *
-   * @param {Object} dataHash - The data for the new user.
-   * @returns {Promise<RbtObject>} - The newly created user as an RbtObject.
-   *
-   */
-  async registerUser(dataHash = {}) {
-    try {
-      const response = await this.axios.post('/user_service/registerUser', [dataHash]);
-      const record = response.data;
-      return new RbtUser(record, this.axios);
-    } catch (e) {
-      return this._handleError(e);
-    }
-  }
-
-  /**
-   * Creates a new file in the system.
-   *
-   * @param {Object} dataHash - The data for the new file.
-   * @returns {Promise<RbtFile>} - The newly created file as an RbtFile.
-   * 
-   */
-  async createFile(dataHash) {
-    //return this.create('<@filekit.file>', dataHash);
-    try {
-      const response = await this.axios.post('/object_service/createObject', ['<@filekit.file>', dataHash]);
-      const record = response.data;
-      if (dataHash) {
-        record.data = dataHash;
+      return loadCurrentUserExtended;
+    }()
+  }, {
+    key: "loadUser",
+    value: function () {
+      var _loadUser = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee15(userId) {
+        var _this4 = this;
+        var params, cacheKey, now, existing, p;
+        return _regeneratorRuntime().wrap(function _callee15$(_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
+            case 0:
+              params = {
+                id: userId
+              };
+              cacheKey = "loadUser:".concat(userId);
+              now = Date.now();
+              existing = this.requestCache[cacheKey];
+              if (!(existing && now - existing.time < 10000)) {
+                _context15.next = 6;
+                break;
+              }
+              return _context15.abrupt("return", existing.val);
+            case 6:
+              _context15.prev = 6;
+              p = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee14() {
+                var _response$data;
+                var response, userData, User;
+                return _regeneratorRuntime().wrap(function _callee14$(_context14) {
+                  while (1) switch (_context14.prev = _context14.next) {
+                    case 0:
+                      _context14.next = 2;
+                      return _this4.axios.post('/user_service/loadUser', [params]);
+                    case 2:
+                      response = _context14.sent;
+                      userData = response === null || response === void 0 || (_response$data = response.data) === null || _response$data === void 0 ? void 0 : _response$data.user;
+                      User = new RbtUser({
+                        id: userData.id
+                      }, _this4.axios);
+                      User.setData(userData);
+                      return _context14.abrupt("return", User);
+                    case 7:
+                    case "end":
+                      return _context14.stop();
+                  }
+                }, _callee14);
+              }))();
+              this.requestCache[cacheKey] = {
+                val: p,
+                time: now
+              };
+              _context15.next = 11;
+              return p;
+            case 11:
+              return _context15.abrupt("return", _context15.sent);
+            case 14:
+              _context15.prev = 14;
+              _context15.t0 = _context15["catch"](6);
+              return _context15.abrupt("return", this._handleError(_context15.t0));
+            case 17:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee15, this, [[6, 14]]);
+      }));
+      function loadUser(_x7) {
+        return _loadUser.apply(this, arguments);
       }
-      return new RbtFile(record, this.axios, this.localDb);
-    } catch (e) {
-      return this._handleError(e);
-    }
-  }
-  async loadFile(id) {
-    //return this.create('<@filekit.file>', dataHash);
-    try {
-      const response = await this.load('<@filekit.file>', id);
-      if (!response) {
-        return null;
+      return loadUser;
+    }()
+  }, {
+    key: "refreshAuthToken",
+    value: function () {
+      var _refreshAuthToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee16(authtoken) {
+        var promise, response;
+        return _regeneratorRuntime().wrap(function _callee16$(_context16) {
+          while (1) switch (_context16.prev = _context16.next) {
+            case 0:
+              if (this.appServiceHost) {
+                _context16.next = 2;
+                break;
+              }
+              return _context16.abrupt("return", false);
+            case 2:
+              if (!this.requestCache[authtoken]) {
+                _context16.next = 4;
+                break;
+              }
+              return _context16.abrupt("return", this.requestCache[authtoken]);
+            case 4:
+              _context16.prev = 4;
+              //console.log('RBTTOK Req', authtoken);
+              // Create a new promise for the token refresh and store it in the cache
+              promise = this.axios.post('/user_service/refreshAuthToken', [authtoken]);
+              this.requestCache[authtoken] = promise;
+
+              // Await the promise to get the response
+              _context16.next = 9;
+              return promise;
+            case 9:
+              response = _context16.sent;
+              //console.log('RBTTOK Response ',response);
+              // Once the promise resolves, delete it from the cache to allow future refreshes
+              delete this.requestCache[authtoken];
+
+              // Return the response data
+              return _context16.abrupt("return", response.data);
+            case 14:
+              _context16.prev = 14;
+              _context16.t0 = _context16["catch"](4);
+              // On error, remove the cached promise to allow retries
+              delete this.requestCache[authtoken];
+              this._handleError(_context16.t0);
+            case 18:
+            case "end":
+              return _context16.stop();
+          }
+        }, _callee16, this, [[4, 14]]);
+      }));
+      function refreshAuthToken(_x8) {
+        return _refreshAuthToken.apply(this, arguments);
       }
-      const record = response.toRecord();
-      return new RbtFile(record, this.axios, this.localDb);
-    } catch (e) {
-      return this._handleError(e);
-    }
-  }
-  async loadFiles(ids) {
-    try {
-      // Use the bulk load method with the provided IDs
-      const responses = await this.load('<@filekit.file>', ids);
-      if (!responses || !Array.isArray(responses)) {
-        return []; // Return an empty array if no responses or invalid data
+      return refreshAuthToken;
+    }() //  async refreshAuthToken(authtoken){
+    //
+    //    if(!this.appServiceHost){
+    //      console.warn('appServiceHost not initialized');
+    //      return false;
+    //    }
+    //
+    //    try {
+    //
+    //      const response = await this.axios.post('/user_service/refreshAuthToken', [authtoken]);
+    //      return response.data;
+    //
+    //    } catch (e) {
+    //
+    //      this._handleError(e);
+    //    }
+    //  }
+    /**
+     * Registers a new user.
+     *
+     * @param {Object} dataHash - The data for the new user.
+     * @returns {Promise<RbtObject>} - The newly created user as an RbtObject.
+     *
+     */
+  }, {
+    key: "registerUser",
+    value: function () {
+      var _registerUser = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee17() {
+        var dataHash,
+          response,
+          record,
+          _args17 = arguments;
+        return _regeneratorRuntime().wrap(function _callee17$(_context17) {
+          while (1) switch (_context17.prev = _context17.next) {
+            case 0:
+              dataHash = _args17.length > 0 && _args17[0] !== undefined ? _args17[0] : {};
+              _context17.prev = 1;
+              _context17.next = 4;
+              return this.axios.post('/user_service/registerUser', [dataHash]);
+            case 4:
+              response = _context17.sent;
+              record = response.data;
+              return _context17.abrupt("return", new RbtUser(record, this.axios));
+            case 9:
+              _context17.prev = 9;
+              _context17.t0 = _context17["catch"](1);
+              return _context17.abrupt("return", this._handleError(_context17.t0));
+            case 12:
+            case "end":
+              return _context17.stop();
+          }
+        }, _callee17, this, [[1, 9]]);
+      }));
+      function registerUser() {
+        return _registerUser.apply(this, arguments);
       }
-
-      // Map over the responses to create RbtFile instances
-      return responses.map(response => {
-        const record = response.toRecord();
-        return new RbtFile(record, this.axios, this.localDb);
-      });
-    } catch (e) {
-      this._handleError(e); // Handle errors (log or process as needed)
-      return []; // Return an empty array on failure
-    }
-  }
-
-  /**
-   * Creates a new object of the given type.
-   *
-   * @param {string} type - The type of object to create.
-   * @param {Object} dataHash - The data for the new object.
-   * @param {Object} options - Additional options including enableRealtime.
-   * @returns {Promise<RbtObject>} - The newly created object as an RbtObject.
-   */
-  async create(type, dataHash = {}, options = {}) {
-    try {
-      const response = await this.axios.post('/object_service/createObject', [type, dataHash]);
-      const record = response.data;
-      if (dataHash) {
-        record.data = dataHash;
+      return registerUser;
+    }()
+    /**
+     * Creates a new file in the system.
+     *
+     * @param {Object} dataHash - The data for the new file.
+     * @returns {Promise<RbtFile>} - The newly created file as an RbtFile.
+     * 
+     */
+  }, {
+    key: "createFile",
+    value: (function () {
+      var _createFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee18(dataHash) {
+        var response, record;
+        return _regeneratorRuntime().wrap(function _callee18$(_context18) {
+          while (1) switch (_context18.prev = _context18.next) {
+            case 0:
+              _context18.prev = 0;
+              _context18.next = 3;
+              return this.axios.post('/object_service/createObject', ['<@filekit.file>', dataHash]);
+            case 3:
+              response = _context18.sent;
+              record = response.data;
+              if (dataHash) {
+                record.data = dataHash;
+              }
+              return _context18.abrupt("return", new RbtFile(record, this.axios, this.localDb));
+            case 9:
+              _context18.prev = 9;
+              _context18.t0 = _context18["catch"](0);
+              return _context18.abrupt("return", this._handleError(_context18.t0));
+            case 12:
+            case "end":
+              return _context18.stop();
+          }
+        }, _callee18, this, [[0, 9]]);
+      }));
+      function createFile(_x9) {
+        return _createFile.apply(this, arguments);
       }
-      return new RbtObject(record, this.axios, {
-        isNew: true,
-        websocketClient: this.websocketClient,
-        enableRealtime: options.enableRealtime || false
-      });
-    } catch (e) {
-      return this._handleError(e);
-    }
-  }
-
-  /**
-   * Queries objects of a given type based on specified parameters.
-   *
-   * @param {string} type - The type of object to query, specified as a doctree.typedef.
-   * @param {Object} params - The query parameters, including optional filters and configurations.
-   * @returns {Promise<Array<RbtObject>>} - An array of queried objects as RbtObjects.
-   *
-   * The `params` object can include the following properties:
-   * - where: A SQL-like where clause string for filtering the results.
-   * - orderBy: An object specifying the ordering of the results. It should include:
-   *    - column: The attribute name to sort by. This must be either a column in the @doctree.model schema or an indexed type attribute.
-   *    - direction: The sort direction, either 'ASC' for ascending or 'DESC' for descending.
-   * - limit: An object to control the pagination of results. It includes:
-   *    - offset: The starting point from where to fetch the results.
-   *    - results: The maximum number of results to return.
-   * - requestAttrs: An array of attribute paths to include in the response (e.g., ['id', 'configs.title', 'configs.description']).
-   *                 If not provided, all attributes are returned.
-   * - excludeAttrs: An array of attribute paths to exclude from the response (e.g., ['details.log', 'internalData']).
-   *                 Excludes the specified paths and all their subpaths.
-   * - resolveReferences: An array of attribute names whose references should be resolved in the returned objects.
-   * - timeout: A numerical value in milliseconds to set a maximum time limit for the query execution.
-   *
-   * Example usage:
-   *   query("<@testuser>", {
-   *     where: 'email="tom@pospa.com"',
-   *     orderBy: { column: 'timeCreated', direction: 'DESC' },
-   *     limit: { offset: 0, results: 50 },
-   *     requestAttrs: ['id', 'configs.title'],
-   *     excludeAttrs: ['details.log'],
-   *     resolveReferences: ['translatableContent']
-   *   });
-   *
-   * Note: A default orderBy is applied if none is provided, ordering items by 'timeCreated' in descending order.
-   */
-
-  async query(type, params = {}) {
-    let paramsKey;
-    try {
-      //console.log('RBTAPI.query INIT', type, params);
-
-      // Validate parameters - reject invalid parameter names
-      const validParams = ['type', 'where', 'orderBy', 'limit', 'resolveReferences', 'requestAttrs', 'excludeAttrs', 'timeout', 'enableRealtime'];
-      const invalidParams = Object.keys(params).filter(key => !validParams.includes(key));
-      if (invalidParams.length > 0) {
-        throw new Error(`Invalid query parameter(s): ${invalidParams.join(', ')}. Valid parameters are: ${validParams.join(', ')}`);
+      return createFile;
+    }())
+  }, {
+    key: "loadFile",
+    value: function () {
+      var _loadFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee19(id) {
+        var response, record;
+        return _regeneratorRuntime().wrap(function _callee19$(_context19) {
+          while (1) switch (_context19.prev = _context19.next) {
+            case 0:
+              _context19.prev = 0;
+              _context19.next = 3;
+              return this.load('<@filekit.file>', id);
+            case 3:
+              response = _context19.sent;
+              if (response) {
+                _context19.next = 6;
+                break;
+              }
+              return _context19.abrupt("return", null);
+            case 6:
+              record = response.toRecord();
+              return _context19.abrupt("return", new RbtFile(record, this.axios, this.localDb));
+            case 10:
+              _context19.prev = 10;
+              _context19.t0 = _context19["catch"](0);
+              return _context19.abrupt("return", this._handleError(_context19.t0));
+            case 13:
+            case "end":
+              return _context19.stop();
+          }
+        }, _callee19, this, [[0, 10]]);
+      }));
+      function loadFile(_x10) {
+        return _loadFile.apply(this, arguments);
       }
-
-      // Warn if enableRealtime is passed to query() - it should only be used by load()
-      if (params.enableRealtime) {
-        console.warn('[roboto-js] enableRealtime should not be passed to query(), only to load(). This parameter will be ignored.');
+      return loadFile;
+    }()
+  }, {
+    key: "loadFiles",
+    value: function () {
+      var _loadFiles = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee20(ids) {
+        var _this5 = this;
+        var responses;
+        return _regeneratorRuntime().wrap(function _callee20$(_context20) {
+          while (1) switch (_context20.prev = _context20.next) {
+            case 0:
+              _context20.prev = 0;
+              _context20.next = 3;
+              return this.load('<@filekit.file>', ids);
+            case 3:
+              responses = _context20.sent;
+              if (!(!responses || !Array.isArray(responses))) {
+                _context20.next = 6;
+                break;
+              }
+              return _context20.abrupt("return", []);
+            case 6:
+              return _context20.abrupt("return", responses.map(function (response) {
+                var record = response.toRecord();
+                return new RbtFile(record, _this5.axios, _this5.localDb);
+              }));
+            case 9:
+              _context20.prev = 9;
+              _context20.t0 = _context20["catch"](0);
+              this._handleError(_context20.t0); // Handle errors (log or process as needed)
+              return _context20.abrupt("return", []);
+            case 13:
+            case "end":
+              return _context20.stop();
+          }
+        }, _callee20, this, [[0, 9]]);
+      }));
+      function loadFiles(_x11) {
+        return _loadFiles.apply(this, arguments);
       }
-      params.type = type;
+      return loadFiles;
+    }()
+    /**
+     * Creates a new object of the given type.
+     *
+     * @param {string} type - The type of object to create.
+     * @param {Object} dataHash - The data for the new object.
+     * @param {Object} options - Additional options including enableRealtime.
+     * @returns {Promise<RbtObject>} - The newly created object as an RbtObject.
+     */
+  }, {
+    key: "create",
+    value: (function () {
+      var _create = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee21(type) {
+        var dataHash,
+          options,
+          response,
+          record,
+          _args21 = arguments;
+        return _regeneratorRuntime().wrap(function _callee21$(_context21) {
+          while (1) switch (_context21.prev = _context21.next) {
+            case 0:
+              dataHash = _args21.length > 1 && _args21[1] !== undefined ? _args21[1] : {};
+              options = _args21.length > 2 && _args21[2] !== undefined ? _args21[2] : {};
+              _context21.prev = 2;
+              _context21.next = 5;
+              return this.axios.post('/object_service/createObject', [type, dataHash]);
+            case 5:
+              response = _context21.sent;
+              record = response.data;
+              if (dataHash) {
+                record.data = dataHash;
+              }
+              return _context21.abrupt("return", new RbtObject(record, this.axios, {
+                isNew: true,
+                websocketClient: this.websocketClient,
+                enableRealtime: options.enableRealtime || false
+              }));
+            case 11:
+              _context21.prev = 11;
+              _context21.t0 = _context21["catch"](2);
+              return _context21.abrupt("return", this._handleError(_context21.t0));
+            case 14:
+            case "end":
+              return _context21.stop();
+          }
+        }, _callee21, this, [[2, 11]]);
+      }));
+      function create(_x12) {
+        return _create.apply(this, arguments);
+      }
+      return create;
+    }()
+    /**
+     * Queries objects of a given type based on specified parameters.
+     *
+     * @param {string} type - The type of object to query, specified as a doctree.typedef.
+     * @param {Object} params - The query parameters, including optional filters and configurations.
+     * @returns {Promise<Array<RbtObject>>} - An array of queried objects as RbtObjects.
+     *
+     * The `params` object can include the following properties:
+     * - where: A SQL-like where clause string for filtering the results.
+     * - orderBy: An object specifying the ordering of the results. It should include:
+     *    - column: The attribute name to sort by. This must be either a column in the @doctree.model schema or an indexed type attribute.
+     *    - direction: The sort direction, either 'ASC' for ascending or 'DESC' for descending.
+     * - limit: An object to control the pagination of results. It includes:
+     *    - offset: The starting point from where to fetch the results.
+     *    - results: The maximum number of results to return.
+     * - requestAttrs: An array of attribute paths to include in the response (e.g., ['id', 'configs.title', 'configs.description']).
+     *                 If not provided, all attributes are returned.
+     * - excludeAttrs: An array of attribute paths to exclude from the response (e.g., ['details.log', 'internalData']).
+     *                 Excludes the specified paths and all their subpaths.
+     * - resolveReferences: An array of attribute names whose references should be resolved in the returned objects.
+     * - timeout: A numerical value in milliseconds to set a maximum time limit for the query execution.
+     *
+     * Example usage:
+     *   query("<@testuser>", {
+     *     where: 'email="tom@pospa.com"',
+     *     orderBy: { column: 'timeCreated', direction: 'DESC' },
+     *     limit: { offset: 0, results: 50 },
+     *     requestAttrs: ['id', 'configs.title'],
+     *     excludeAttrs: ['details.log'],
+     *     resolveReferences: ['translatableContent']
+     *   });
+     *
+     * Note: A default orderBy is applied if none is provided, ordering items by 'timeCreated' in descending order.
+     */
+    )
+  }, {
+    key: "query",
+    value: (function () {
+      var _query = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee22(type) {
+        var _this6 = this;
+        var params,
+          paramsKey,
+          validParams,
+          invalidParams,
+          defaultOrderBy,
+          defaultLimit,
+          mergedParams,
+          currentTime,
+          cacheEntry,
+          responsePromise,
+          processingPromise,
+          _args22 = arguments;
+        return _regeneratorRuntime().wrap(function _callee22$(_context22) {
+          while (1) switch (_context22.prev = _context22.next) {
+            case 0:
+              params = _args22.length > 1 && _args22[1] !== undefined ? _args22[1] : {};
+              _context22.prev = 1;
+              //console.log('RBTAPI.query INIT', type, params);
+              // Validate parameters - reject invalid parameter names
+              validParams = ['type', 'where', 'orderBy', 'limit', 'resolveReferences', 'requestAttrs', 'excludeAttrs', 'timeout', 'enableRealtime'];
+              invalidParams = Object.keys(params).filter(function (key) {
+                return !validParams.includes(key);
+              });
+              if (!(invalidParams.length > 0)) {
+                _context22.next = 6;
+                break;
+              }
+              throw new Error("Invalid query parameter(s): ".concat(invalidParams.join(', '), ". Valid parameters are: ").concat(validParams.join(', ')));
+            case 6:
+              // Warn if enableRealtime is passed to query() - it should only be used by load()
+              if (params.enableRealtime) {}
+              params.type = type;
+
+              // Default ordering and pagination
+              defaultOrderBy = {
+                orderBy: {
+                  column: 'timeCreated',
+                  direction: 'DESC'
+                }
+              };
+              defaultLimit = {
+                limit: {
+                  offset: 0,
+                  results: 50
+                }
+              }; // Merge defaults with provided params
+              mergedParams = _objectSpread(_objectSpread(_objectSpread({}, defaultOrderBy), defaultLimit), params); // Check cache for an existing request
+              currentTime = Date.now();
+              paramsKey = JSON.stringify(mergedParams);
+              cacheEntry = this.requestCache[paramsKey];
+              if (!(cacheEntry && currentTime - cacheEntry.time < 10000)) {
+                _context22.next = 16;
+                break;
+              }
+              return _context22.abrupt("return", cacheEntry.val);
+            case 16:
+              // Create the response promise
+              responsePromise = this.axios.post('/object_service/queryObjects', [mergedParams]); // Cache the promise of processing data, not just the raw response
+              processingPromise = responsePromise.then(function (response) {
+                return _this6._processResponseData(response, params);
+              })["catch"](function (e) {
+                delete _this6.requestCache[paramsKey]; // Ensure cache cleanup on failure
+                //console.log('RBTAPI.query ERROR (Processing)', paramsKey, e);
+                return _this6._handleError(e);
+              }); // Store the promise of the processed data in the cache
+              this.requestCache[paramsKey] = {
+                val: processingPromise,
+                time: currentTime
+              };
+
+              // Await the processing promise for this call to get processed data
+              _context22.next = 21;
+              return processingPromise;
+            case 21:
+              return _context22.abrupt("return", _context22.sent);
+            case 24:
+              _context22.prev = 24;
+              _context22.t0 = _context22["catch"](1);
+              delete this.requestCache[paramsKey]; // Ensure cache cleanup on error
+              //console.log('RBTAPI.query ERROR', paramsKey, e);
+              return _context22.abrupt("return", this._handleError(_context22.t0));
+            case 28:
+            case "end":
+              return _context22.stop();
+          }
+        }, _callee22, this, [[1, 24]]);
+      }));
+      function query(_x13) {
+        return _query.apply(this, arguments);
+      }
+      return query;
+    }())
+  }, {
+    key: "_processResponseData",
+    value: function _processResponseData(response) {
+      var _this7 = this;
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (response.data.ok === false) {
+        return this._handleError(response);
+      }
+      if (Array.isArray(response.data.items)) {
+        //console.log('RBTAPI.query RESPONSE PRE', response.data.items);
 
-      // Default ordering and pagination
-      const defaultOrderBy = {
-        orderBy: {
-          column: 'timeCreated',
-          direction: 'DESC'
-        }
-      };
-      const defaultLimit = {
-        limit: {
-          offset: 0,
-          results: 50
+        // Ensure WebSocket client is available if realtime is requested
+        var websocketClient = this.websocketClient;
+        if (options.enableRealtime && !websocketClient) {
+          websocketClient = this.getWebSocketClient();
         }
-      };
-
-      // Merge defaults with provided params
-      const mergedParams = {
-        ...defaultOrderBy,
-        ...defaultLimit,
-        ...params
-      };
-
-      // Check cache for an existing request
-      const currentTime = Date.now();
-      paramsKey = JSON.stringify(mergedParams);
-      const cacheEntry = this.requestCache[paramsKey];
-      if (cacheEntry && currentTime - cacheEntry.time < 10000) {
-        // 10000 ms = 10 seconds
-        //console.log('RBTAPI.query CACHED', type, paramsKey);
-        return cacheEntry.val;
+        response.data.items = response.data.items.map(function (record) {
+          return new RbtObject(record, _this7.axios, {
+            websocketClient: websocketClient,
+            enableRealtime: options.enableRealtime || false
+          });
+        });
       }
 
-      // Create the response promise
-      const responsePromise = this.axios.post('/object_service/queryObjects', [mergedParams]);
-
-      // Cache the promise of processing data, not just the raw response
-      const processingPromise = responsePromise.then(response => this._processResponseData(response, params)).catch(e => {
-        delete this.requestCache[paramsKey]; // Ensure cache cleanup on failure
-        //console.log('RBTAPI.query ERROR (Processing)', paramsKey, e);
-        return this._handleError(e);
-      });
-
-      // Store the promise of the processed data in the cache
-      this.requestCache[paramsKey] = {
-        val: processingPromise,
-        time: currentTime
-      };
-
-      // Await the processing promise for this call to get processed data
-      return await processingPromise;
-    } catch (e) {
-      delete this.requestCache[paramsKey]; // Ensure cache cleanup on error
-      //console.log('RBTAPI.query ERROR', paramsKey, e);
-      return this._handleError(e);
-    }
-  }
-  _processResponseData(response, options = {}) {
-    if (response.data.ok === false) {
-      return this._handleError(response);
-    }
-    if (Array.isArray(response.data.items)) {
-      //console.log('RBTAPI.query RESPONSE PRE', response.data.items);
-
-      // Ensure WebSocket client is available if realtime is requested
-      let websocketClient = this.websocketClient;
-      if (options.enableRealtime && !websocketClient) {
-        console.log('[AgentProviderSync] Creating WebSocket client for realtime objects');
-        websocketClient = this.getWebSocketClient();
-      }
-      console.log('[AgentProviderSync] _processResponseData creating objects with:', {
-        enableRealtime: options.enableRealtime || false,
-        hasWebSocketClient: !!websocketClient,
-        itemCount: response.data.items.length
-      });
-      response.data.items = response.data.items.map(record => {
-        return new RbtObject(record, this.axios, {
-          websocketClient: websocketClient,
-          enableRealtime: options.enableRealtime || false
-        });
-      });
+      //console.log('RBTAPI.query RESPONSE POST', response.data.items);
+      return response.data.items;
     }
 
-    //console.log('RBTAPI.query RESPONSE POST', response.data.items);
-    return response.data.items;
-  }
+    /**
+     * Loads one or multiple objects of a given type by their IDs.
+     *
+     * @param {string} type - The type of object to load.
+     * @param {Array<string>|string} ids - The ID(s) of the object(s) to load.
+     * 
+     * @returns {Promise<RbtObject|RbtObject[]>} - The loaded object(s) as RbtObject(s).
+     */
+  }, {
+    key: "load",
+    value: (function () {
+      var _load = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee24(type, ids) {
+        var _this8 = this;
+        var params,
+          mergedParams,
+          cachedObjects,
+          missingIds,
+          _iterator3,
+          _step3,
+          id,
+          _cacheKey,
+          cached,
+          hitLogKey,
+          loadedObjects,
+          bulkMissLogKey,
+          enableRealtime,
+          queryParams,
+          _iterator4,
+          _step4,
+          obj,
+          cacheKey,
+          setLogKey,
+          result,
+          _iterator5,
+          _step5,
+          _id,
+          _cacheKey2,
+          _obj,
+          _cacheKey3,
+          _cached,
+          _hitLogKey,
+          pendingKey,
+          missLogKey,
+          loadPromise,
+          _args24 = arguments;
+        return _regeneratorRuntime().wrap(function _callee24$(_context24) {
+          while (1) switch (_context24.prev = _context24.next) {
+            case 0:
+              params = _args24.length > 2 && _args24[2] !== undefined ? _args24[2] : {};
+              if (type == '<@iac.user>') {
+                debugger;
+              }
+              _context24.prev = 2;
+              if (!Array.isArray(ids)) {
+                _context24.next = 25;
+                break;
+              }
+              // For array requests, check cache for each ID and only load missing ones
+              cachedObjects = [];
+              missingIds = [];
+              _iterator3 = _createForOfIteratorHelper(ids);
+              try {
+                for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                  id = _step3.value;
+                  _cacheKey = "".concat(type, ":").concat(id);
+                  cached = this._objectCache.get(_cacheKey);
+                  if (cached) {
+                    // Only log cache hits once per object to reduce spam
+                    hitLogKey = "hit:".concat(_cacheKey);
+                    if (!this._loggedCacheEvents.has(hitLogKey)) {
+                      this._loggedCacheEvents.add(hitLogKey);
+                    }
+
+                    // If realtime is requested but cached object doesn't have it, upgrade it
+                    if (params.enableRealtime && !cached._realtime) {
+                      cached._initRealtime();
+                    }
+                    cachedObjects.push(cached);
+                  } else {
+                    missingIds.push(id);
+                  }
+                }
+
+                // Load missing objects
+              } catch (err) {
+                _iterator3.e(err);
+              } finally {
+                _iterator3.f();
+              }
+              loadedObjects = [];
+              if (!(missingIds.length > 0)) {
+                _context24.next = 19;
+                break;
+              }
+              // Only log bulk cache miss once
+              bulkMissLogKey = "bulk-miss:".concat(type, ":").concat(missingIds.join(','));
+              if (!this._loggedCacheEvents.has(bulkMissLogKey)) {
+                this._loggedCacheEvents.add(bulkMissLogKey);
+              }
 
-  /**
-   * Loads one or multiple objects of a given type by their IDs.
-   *
-   * @param {string} type - The type of object to load.
-   * @param {Array<string>|string} ids - The ID(s) of the object(s) to load.
-   * 
-   * @returns {Promise<RbtObject|RbtObject[]>} - The loaded object(s) as RbtObject(s).
-   */
-  async load(type, ids, params = {}) {
-    if (type == '<@iac.user>') {
-      debugger;
-    }
-    try {
-      let mergedParams;
-      if (Array.isArray(ids)) {
-        // For array requests, check cache for each ID and only load missing ones
-        const cachedObjects = [];
-        const missingIds = [];
-        for (const id of ids) {
-          const cacheKey = `${type}:${id}`;
-          const cached = this._objectCache.get(cacheKey);
-          if (cached) {
-            // Only log cache hits once per object to reduce spam
-            const hitLogKey = `hit:${cacheKey}`;
-            if (!this._loggedCacheEvents.has(hitLogKey)) {
-              console.log('[AgentProviderSync] 🎯 roboto.load cache HIT:', {
-                type,
-                id,
-                hasRealtime: !!cached._realtime,
-                requestedRealtime: !!params.enableRealtime
+              // Remove load-specific params that shouldn't be passed to query
+              enableRealtime = params.enableRealtime, queryParams = _objectWithoutProperties(params, _excluded);
+              mergedParams = _objectSpread(_objectSpread({}, queryParams), {}, {
+                where: "id IN (\"".concat(missingIds.join("\",\""), "\")")
               });
-              this._loggedCacheEvents.add(hitLogKey);
-            }
+              _context24.next = 16;
+              return this.query(type, mergedParams);
+            case 16:
+              loadedObjects = _context24.sent;
+              // Cache the newly loaded objects
+              _iterator4 = _createForOfIteratorHelper(loadedObjects);
+              try {
+                for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                  obj = _step4.value;
+                  cacheKey = "".concat(type, ":").concat(obj.id);
+                  this._objectCache.set(cacheKey, obj);
+
+                  // Only log cache set once per object to reduce spam
+                  setLogKey = "set:".concat(cacheKey);
+                  if (!this._loggedCacheEvents.has(setLogKey)) {
+                    this._loggedCacheEvents.add(setLogKey);
+                  }
+                }
+              } catch (err) {
+                _iterator4.e(err);
+              } finally {
+                _iterator4.f();
+              }
+            case 19:
+              // Return combined results in original order
+              result = [];
+              _iterator5 = _createForOfIteratorHelper(ids);
+              try {
+                for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+                  _id = _step5.value;
+                  _cacheKey2 = "".concat(type, ":").concat(_id);
+                  _obj = this._objectCache.get(_cacheKey2);
+                  if (_obj) {
+                    // Ensure realtime is enabled if requested
+                    if (params.enableRealtime && !_obj._realtime) {
+                      _obj._initRealtime();
+                    }
+                    result.push(_obj);
+                  }
+                }
+              } catch (err) {
+                _iterator5.e(err);
+              } finally {
+                _iterator5.f();
+              }
+              return _context24.abrupt("return", result);
+            case 25:
+              // For single object requests, check cache first
+              _cacheKey3 = "".concat(type, ":").concat(ids);
+              _cached = this._objectCache.get(_cacheKey3);
+              if (!_cached) {
+                _context24.next = 32;
+                break;
+              }
+              // Only log cache hits once per object to reduce spam
+              _hitLogKey = "hit:".concat(_cacheKey3);
+              if (!this._loggedCacheEvents.has(_hitLogKey) || void 0) {
+                this._loggedCacheEvents.add(_hitLogKey);
+              }
 
-            // If realtime is requested but cached object doesn't have it, upgrade it
-            if (params.enableRealtime && !cached._realtime) {
-              console.log('[AgentProviderSync] 🔄 Upgrading cached object to realtime:', {
-                type,
-                id
-              });
-              cached._initRealtime();
-            }
-            cachedObjects.push(cached);
-          } else {
-            missingIds.push(id);
-          }
-        }
+              // If realtime is requested but cached object doesn't have it, upgrade it
+              if (params.enableRealtime && !_cached._realtime) {
+                _cached._initRealtime();
+              }
+              return _context24.abrupt("return", _cached);
+            case 32:
+              // Check if we're already loading this object
+              pendingKey = "".concat(type, ":").concat(ids);
+              if (!this._pendingLoads.has(pendingKey)) {
+                _context24.next = 37;
+                break;
+              }
+              _context24.next = 36;
+              return this._pendingLoads.get(pendingKey);
+            case 36:
+              return _context24.abrupt("return", _context24.sent);
+            case 37:
+              // Only log cache miss once per object to reduce spam
+              missLogKey = "miss:".concat(_cacheKey3);
+              if (!this._loggedCacheEvents.has(missLogKey)) {
+                this._loggedCacheEvents.add(missLogKey);
+              }
 
-        // Load missing objects
-        let loadedObjects = [];
-        if (missingIds.length > 0) {
-          // Only log bulk cache miss once
-          const bulkMissLogKey = `bulk-miss:${type}:${missingIds.join(',')}`;
-          if (!this._loggedCacheEvents.has(bulkMissLogKey)) {
-            console.log('[AgentProviderSync] 📦 roboto.load cache MISS, loading:', {
-              type,
-              ids: missingIds
-            });
-            this._loggedCacheEvents.add(bulkMissLogKey);
+              // Create the loading promise and store it to prevent duplicate requests
+              loadPromise = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee23() {
+                var _enableRealtime, _queryParams, res, _obj2, _setLogKey;
+                return _regeneratorRuntime().wrap(function _callee23$(_context23) {
+                  while (1) switch (_context23.prev = _context23.next) {
+                    case 0:
+                      _context23.prev = 0;
+                      // Remove load-specific params that shouldn't be passed to query
+                      _enableRealtime = params.enableRealtime, _queryParams = _objectWithoutProperties(params, _excluded2);
+                      mergedParams = _objectSpread(_objectSpread({}, _queryParams), {}, {
+                        where: "id=\"".concat(ids, "\"")
+                      });
+                      _context23.next = 5;
+                      return _this8.query(type, mergedParams);
+                    case 5:
+                      res = _context23.sent;
+                      _obj2 = res[0];
+                      if (_obj2) {
+                        // Cache the loaded object
+                        _this8._objectCache.set(_cacheKey3, _obj2);
+
+                        // Only log cache set once per object to reduce spam
+                        _setLogKey = "set:".concat(_cacheKey3);
+                        if (!_this8._loggedCacheEvents.has(_setLogKey)) {
+                          _this8._loggedCacheEvents.add(_setLogKey);
+                        }
+                      }
+                      return _context23.abrupt("return", _obj2);
+                    case 9:
+                      _context23.prev = 9;
+                      // Remove from pending loads
+                      _this8._pendingLoads["delete"](pendingKey);
+                      return _context23.finish(9);
+                    case 12:
+                    case "end":
+                      return _context23.stop();
+                  }
+                }, _callee23, null, [[0,, 9, 12]]);
+              }))(); // Store the promise so other concurrent requests can await it
+              this._pendingLoads.set(pendingKey, loadPromise);
+              _context24.next = 43;
+              return loadPromise;
+            case 43:
+              return _context24.abrupt("return", _context24.sent);
+            case 44:
+              _context24.next = 49;
+              break;
+            case 46:
+              _context24.prev = 46;
+              _context24.t0 = _context24["catch"](2);
+              return _context24.abrupt("return", this._handleError(_context24.t0));
+            case 49:
+            case "end":
+              return _context24.stop();
           }
-
-          // Remove load-specific params that shouldn't be passed to query
-          const {
-            enableRealtime,
-            ...queryParams
-          } = params;
-          mergedParams = {
-            ...queryParams,
-            where: `id IN ("${missingIds.join(`","`)}")`
-          };
-          loadedObjects = await this.query(type, mergedParams);
-
-          // Cache the newly loaded objects
-          for (const obj of loadedObjects) {
-            const cacheKey = `${type}:${obj.id}`;
-            this._objectCache.set(cacheKey, obj);
-
-            // Only log cache set once per object to reduce spam
-            const setLogKey = `set:${cacheKey}`;
-            if (!this._loggedCacheEvents.has(setLogKey)) {
-              console.log('[AgentProviderSync] 💾 roboto.load cached object:', {
-                type,
-                id: obj.id
-              });
-              this._loggedCacheEvents.add(setLogKey);
+        }, _callee24, this, [[2, 46]]);
+      }));
+      function load(_x14, _x15) {
+        return _load.apply(this, arguments);
+      }
+      return load;
+    }()
+    /**
+     * Clears the object cache. Useful for cache invalidation.
+     * @param {string} type - Optional object type to clear. If not provided, clears all.
+     * @param {string} id - Optional object ID to clear. If not provided with type, clears all objects of that type.
+     */
+    )
+  }, {
+    key: "clearCache",
+    value: function clearCache() {
+      var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      var id = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      if (type && id) {
+        // Clear specific object
+        var cacheKey = "".concat(type, ":").concat(id);
+        var removed = this._objectCache["delete"](cacheKey);
+
+        // Clear related log tracking
+        this._loggedCacheEvents["delete"]("hit:".concat(cacheKey));
+        this._loggedCacheEvents["delete"]("miss:".concat(cacheKey));
+        this._loggedCacheEvents["delete"]("set:".concat(cacheKey));
+      } else if (type) {
+        // Clear all objects of a specific type
+        var removedCount = 0;
+        var _iterator6 = _createForOfIteratorHelper(this._objectCache),
+          _step6;
+        try {
+          for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+            var _step6$value = _slicedToArray(_step6.value, 1),
+              key = _step6$value[0];
+            if (key.startsWith("".concat(type, ":"))) {
+              this._objectCache["delete"](key);
+              removedCount++;
             }
           }
-        }
 
-        // Return combined results in original order
-        const result = [];
-        for (const id of ids) {
-          const cacheKey = `${type}:${id}`;
-          const obj = this._objectCache.get(cacheKey);
-          if (obj) {
-            // Ensure realtime is enabled if requested
-            if (params.enableRealtime && !obj._realtime) {
-              obj._initRealtime();
+          // Clear related log tracking for this type
+        } catch (err) {
+          _iterator6.e(err);
+        } finally {
+          _iterator6.f();
+        }
+        var _iterator7 = _createForOfIteratorHelper(this._loggedCacheEvents),
+          _step7;
+        try {
+          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+            var logKey = _step7.value;
+            if (logKey.includes("".concat(type, ":"))) {
+              this._loggedCacheEvents["delete"](logKey);
             }
-            result.push(obj);
           }
+        } catch (err) {
+          _iterator7.e(err);
+        } finally {
+          _iterator7.f();
         }
-        return result;
       } else {
-        // For single object requests, check cache first
-        const cacheKey = `${type}:${ids}`;
-        const cached = this._objectCache.get(cacheKey);
-        if (cached) {
-          // Only log cache hits once per object to reduce spam
-          const hitLogKey = `hit:${cacheKey}`;
-          if (!this._loggedCacheEvents.has(hitLogKey) || console.log('[AgentProviderSync] 🎯 roboto.load cache HIT:', {
-            type,
-            id: ids,
-            hasRealtime: !!cached._realtime,
-            requestedRealtime: !!params.enableRealtime
-          })) {
-            this._loggedCacheEvents.add(hitLogKey);
-          }
-
-          // If realtime is requested but cached object doesn't have it, upgrade it
-          if (params.enableRealtime && !cached._realtime) {
-            console.log('[AgentProviderSync] 🔄 Upgrading cached object to realtime:', {
-              type,
-              id: ids
-            });
-            cached._initRealtime();
-          }
-          return cached;
-        }
-
-        // Check if we're already loading this object
-        const pendingKey = `${type}:${ids}`;
-        if (this._pendingLoads.has(pendingKey)) {
-          // Wait for the existing request to complete
-          return await this._pendingLoads.get(pendingKey);
-        }
-
-        // Only log cache miss once per object to reduce spam
-        const missLogKey = `miss:${cacheKey}`;
-        if (!this._loggedCacheEvents.has(missLogKey)) {
-          console.log('[AgentProviderSync] 📦 roboto.load cache MISS, loading:', {
-            type,
-            id: ids
-          });
-          this._loggedCacheEvents.add(missLogKey);
-        }
-
-        // Create the loading promise and store it to prevent duplicate requests
-        const loadPromise = (async () => {
-          try {
-            // Remove load-specific params that shouldn't be passed to query
-            const {
-              enableRealtime,
-              ...queryParams
-            } = params;
-            mergedParams = {
-              ...queryParams,
-              where: `id="${ids}"`
-            };
-            let res = await this.query(type, mergedParams);
-            const obj = res[0];
-            if (obj) {
-              // Cache the loaded object
-              this._objectCache.set(cacheKey, obj);
-
-              // Only log cache set once per object to reduce spam
-              const setLogKey = `set:${cacheKey}`;
-              if (!this._loggedCacheEvents.has(setLogKey)) {
-                console.log('[AgentProviderSync] 💾 roboto.load cached object:', {
-                  type,
-                  id: ids
-                });
-                this._loggedCacheEvents.add(setLogKey);
-              }
-            }
-            return obj;
-          } finally {
-            // Remove from pending loads
-            this._pendingLoads.delete(pendingKey);
-          }
-        })();
-
-        // Store the promise so other concurrent requests can await it
-        this._pendingLoads.set(pendingKey, loadPromise);
-        return await loadPromise;
+        // Clear all cached objects
+        var size = this._objectCache.size;
+        this._objectCache.clear();
+        this._loggedCacheEvents.clear();
+        this._pendingLoads.clear();
       }
-    } catch (e) {
-      return this._handleError(e);
     }
-  }
-
-  /**
-   * Clears the object cache. Useful for cache invalidation.
-   * @param {string} type - Optional object type to clear. If not provided, clears all.
-   * @param {string} id - Optional object ID to clear. If not provided with type, clears all objects of that type.
-   */
-  clearCache(type = null, id = null) {
-    if (type && id) {
-      // Clear specific object
-      const cacheKey = `${type}:${id}`;
-      const removed = this._objectCache.delete(cacheKey);
-
-      // Clear related log tracking
-      this._loggedCacheEvents.delete(`hit:${cacheKey}`);
-      this._loggedCacheEvents.delete(`miss:${cacheKey}`);
-      this._loggedCacheEvents.delete(`set:${cacheKey}`);
-      console.log('[AgentProviderSync] 🗑️ roboto.clearCache specific object:', {
-        type,
-        id,
-        removed
-      });
-    } else if (type) {
-      // Clear all objects of a specific type
-      let removedCount = 0;
-      for (const [key] of this._objectCache) {
-        if (key.startsWith(`${type}:`)) {
-          this._objectCache.delete(key);
-          removedCount++;
-        }
-      }
 
-      // Clear related log tracking for this type
-      for (const logKey of this._loggedCacheEvents) {
-        if (logKey.includes(`${type}:`)) {
-          this._loggedCacheEvents.delete(logKey);
-        }
-      }
-      console.log('[AgentProviderSync] 🗑️ roboto.clearCache by type:', {
-        type,
-        removedCount
-      });
-    } else {
-      // Clear all cached objects
-      const size = this._objectCache.size;
-      this._objectCache.clear();
-      this._loggedCacheEvents.clear();
-      this._pendingLoads.clear();
-      console.log('[AgentProviderSync] 🗑️ roboto.clearCache all objects:', {
-        clearedCount: size
+    /**
+     * Gets cache status for debugging
+     * @returns {Object} Cache status information
+     */
+  }, {
+    key: "getCacheStatus",
+    value: function getCacheStatus() {
+      var cacheEntries = Array.from(this._objectCache.entries()).map(function (_ref6) {
+        var _obj$_internalData;
+        var _ref7 = _slicedToArray(_ref6, 2),
+          key = _ref7[0],
+          obj = _ref7[1];
+        return {
+          key: key,
+          id: obj.id,
+          type: ((_obj$_internalData = obj._internalData) === null || _obj$_internalData === void 0 ? void 0 : _obj$_internalData.type) || 'unknown'
+        };
       });
+      var pendingLoads = Array.from(this._pendingLoads.keys());
+      return {
+        cacheSize: this._objectCache.size,
+        pendingLoads: pendingLoads.length,
+        loggedEvents: this._loggedCacheEvents.size,
+        entries: cacheEntries,
+        pendingKeys: pendingLoads
+      };
     }
-  }
-
-  /**
-   * Gets cache status for debugging
-   * @returns {Object} Cache status information
-   */
-  getCacheStatus() {
-    const cacheEntries = Array.from(this._objectCache.entries()).map(([key, obj]) => ({
-      key,
-      id: obj.id,
-      type: obj._internalData?.type || 'unknown'
-    }));
-    const pendingLoads = Array.from(this._pendingLoads.keys());
-    return {
-      cacheSize: this._objectCache.size,
-      pendingLoads: pendingLoads.length,
-      loggedEvents: this._loggedCacheEvents.size,
-      entries: cacheEntries,
-      pendingKeys: pendingLoads
-    };
-  }
-
-  /**
-   * Makes a POST request to a specific endpoint to run a task and handle progress updates.
-   *
-   * @param params.id (optional) IF the client is MONITORING the job with WS ClientMonitor, 
-   *                             the client should generate a jobId and connect to the ClientMonitor
-   *                             BEFORE starting the job, to make sure no messages are missed - 
-   *                             otherwise we'd have to delay the task start.
-   *                             
-   * @param {Object} params - The parameters to be sent in the POST request.
-   * @param {Object} callbacks - An object containing callback functions for progress and error handling.
-   * 
-   * The function expects a response in the following format:
-   * {
-   *   ok: boolean, // Indicates if the request was successful or not
-   *   jobId: string, // The job identifier
-   *   status: string // Can be 'RUNNING', 'DONE', or 'ERROR'
-   * }
-   */
-  async runTask(params = {}, callbacks = {}) {
-    const {
-      onProgress,
-      onError,
-      onStopped,
-      onWaiting,
-      onDone
-    } = callbacks;
-    try {
-      const response = await this.post('/task_service/runChain', params);
-
-      // Check if response and response.data are defined
-      if (!response) {
-        throw new Error('Invalid server response');
-      }
-
-      // Validate response structure
-      const {
-        ok,
-        jobId,
-        status,
-        message,
-        output
-      } = response;
-      if (!ok || typeof jobId !== 'string' || typeof status !== 'string') {
-        throw new Error('Invalid response structure');
-      }
 
-      // If the task is still in progress, start polling for updates
-      if (status === 'RUNNING' || status === 'SCHEDULED' || status === 'QUEUED' || status === 'STOPPING') {
-        this.pollTaskProgress(jobId, callbacks);
-      }
-      if (status === 'ERROR' && onError) {
-        // Normalize error response to have consistent message/label at top level
-        onError(this._normalizeErrorResponse(response));
-      }
-      if (status === 'STOPPED' && onStopped) {
-        // Provide the current progress to the callback function
-        onStopped(response);
-      }
-      if (status === 'WAITING' && onWaiting) {
-        // Provide the current progress to the callback function
-        onWaiting(response);
-      }
-      if (status === 'DONE' && onDone) {
-        // Provide the current progress to the callback function
-        //console.log('Finish (request) ',response);  s
-        onDone(response);
+    /**
+     * Makes a POST request to a specific endpoint to run a task and handle progress updates.
+     *
+     * @param params.id (optional) IF the client is MONITORING the job with WS ClientMonitor, 
+     *                             the client should generate a jobId and connect to the ClientMonitor
+     *                             BEFORE starting the job, to make sure no messages are missed - 
+     *                             otherwise we'd have to delay the task start.
+     *                             
+     * @param {Object} params - The parameters to be sent in the POST request.
+     * @param {Object} callbacks - An object containing callback functions for progress and error handling.
+     * 
+     * The function expects a response in the following format:
+     * {
+     *   ok: boolean, // Indicates if the request was successful or not
+     *   jobId: string, // The job identifier
+     *   status: string // Can be 'RUNNING', 'DONE', or 'ERROR'
+     * }
+     */
+  }, {
+    key: "runTask",
+    value: (function () {
+      var _runTask = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee25() {
+        var params,
+          callbacks,
+          onProgress,
+          onError,
+          onStopped,
+          onWaiting,
+          onDone,
+          response,
+          ok,
+          jobId,
+          status,
+          message,
+          output,
+          errorResponse,
+          _args25 = arguments;
+        return _regeneratorRuntime().wrap(function _callee25$(_context25) {
+          while (1) switch (_context25.prev = _context25.next) {
+            case 0:
+              params = _args25.length > 0 && _args25[0] !== undefined ? _args25[0] : {};
+              callbacks = _args25.length > 1 && _args25[1] !== undefined ? _args25[1] : {};
+              onProgress = callbacks.onProgress, onError = callbacks.onError, onStopped = callbacks.onStopped, onWaiting = callbacks.onWaiting, onDone = callbacks.onDone;
+              _context25.prev = 3;
+              _context25.next = 6;
+              return this.post('/task_service/runChain', params);
+            case 6:
+              response = _context25.sent;
+              if (response) {
+                _context25.next = 9;
+                break;
+              }
+              throw new Error('Invalid server response');
+            case 9:
+              // Validate response structure
+              ok = response.ok, jobId = response.jobId, status = response.status, message = response.message, output = response.output;
+              if (!(!ok || typeof jobId !== 'string' || typeof status !== 'string')) {
+                _context25.next = 12;
+                break;
+              }
+              throw new Error('Invalid response structure');
+            case 12:
+              // If the task is still in progress, start polling for updates
+              if (status === 'RUNNING' || status === 'SCHEDULED' || status === 'QUEUED' || status === 'STOPPING') {
+                this.pollTaskProgress(jobId, callbacks);
+              }
+              if (status === 'ERROR' && onError) {
+                // Normalize error response to have consistent message/label at top level
+                onError(this._normalizeErrorResponse(response));
+              }
+              if (status === 'STOPPED' && onStopped) {
+                // Provide the current progress to the callback function
+                onStopped(response);
+              }
+              if (status === 'WAITING' && onWaiting) {
+                // Provide the current progress to the callback function
+                onWaiting(response);
+              }
+              if (status === 'DONE' && onDone) {
+                // Provide the current progress to the callback function
+                //console.log('Finish (request) ',response);  s
+                onDone(response);
+              }
+              return _context25.abrupt("return", {
+                ok: ok,
+                jobId: jobId,
+                status: status,
+                message: message,
+                output: output
+              });
+            case 20:
+              _context25.prev = 20;
+              _context25.t0 = _context25["catch"](3);
+              // Standardize error format to match task response object
+              // Support RbtError format with label and message
+              errorResponse = {
+                ok: false,
+                jobId: null,
+                status: 'ERROR',
+                message: _context25.t0.message || _context25.t0.toString() || 'Unknown error',
+                label: _context25.t0.label || _context25.t0.name || 'Error',
+                output: {
+                  error: _context25.t0.message,
+                  label: _context25.t0.label,
+                  stack: _context25.t0.stack,
+                  originalError: _context25.t0
+                }
+              };
+              if (typeof onError === 'function') {
+                onError(errorResponse);
+              } else {
+                console.error('Error in runTask:', errorResponse.message);
+              }
+              return _context25.abrupt("return", errorResponse);
+            case 25:
+            case "end":
+              return _context25.stop();
+          }
+        }, _callee25, this, [[3, 20]]);
+      }));
+      function runTask() {
+        return _runTask.apply(this, arguments);
       }
-      return {
-        ok,
-        jobId,
-        status,
-        message,
-        output
-      };
-    } catch (e) {
-      // Standardize error format to match task response object
-      // Support RbtError format with label and message
-      const errorResponse = {
-        ok: false,
-        jobId: null,
-        status: 'ERROR',
-        message: e.message || e.toString() || 'Unknown error',
-        label: e.label || e.name || 'Error',
-        output: {
-          error: e.message,
-          label: e.label,
-          stack: e.stack,
-          originalError: e
-        }
-      };
-      if (typeof onError === 'function') {
-        onError(errorResponse);
-      } else {
-        console.error('Error in runTask:', errorResponse.message);
+      return runTask;
+    }())
+  }, {
+    key: "stopJob",
+    value: function () {
+      var _stopJob = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee26() {
+        var params,
+          callbacks,
+          response,
+          _args26 = arguments;
+        return _regeneratorRuntime().wrap(function _callee26$(_context26) {
+          while (1) switch (_context26.prev = _context26.next) {
+            case 0:
+              params = _args26.length > 0 && _args26[0] !== undefined ? _args26[0] : {};
+              callbacks = _args26.length > 1 && _args26[1] !== undefined ? _args26[1] : {};
+              _context26.prev = 2;
+              _context26.next = 5;
+              return this.post('/task_service/stopJob', params);
+            case 5:
+              response = _context26.sent;
+              if (response) {
+                _context26.next = 8;
+                break;
+              }
+              throw new Error('Invalid server response');
+            case 8:
+              return _context26.abrupt("return", true);
+            case 11:
+              _context26.prev = 11;
+              _context26.t0 = _context26["catch"](2);
+              throw 'Error in stopJob';
+            case 14:
+            case "end":
+              return _context26.stop();
+          }
+        }, _callee26, this, [[2, 11]]);
+      }));
+      function stopJob() {
+        return _stopJob.apply(this, arguments);
       }
-      return errorResponse;
-    }
-  }
-  async stopJob(params = {}, callbacks = {}) {
-    try {
-      const response = await this.post('/task_service/stopJob', params);
-      // Check if response and response.data are defined
-      if (!response) {
-        throw new Error('Invalid server response');
+      return stopJob;
+    }()
+    /**
+     * Normalize error response to have consistent message/label at top level
+     * Extracts from messages array if present (from chain execution)
+     */
+  }, {
+    key: "_normalizeErrorResponse",
+    value: function _normalizeErrorResponse(response) {
+      // If response already has message/label at top level and no messages array, return as-is
+      if ((response.message || response.label) && !response.messages) {
+        return response;
       }
-      return true;
-    } catch (e) {
-      throw 'Error in stopJob';
-    }
-  }
-
-  /**
-   * Normalize error response to have consistent message/label at top level
-   * Extracts from messages array if present (from chain execution)
-   */
-  _normalizeErrorResponse(response) {
-    // If response already has message/label at top level and no messages array, return as-is
-    if ((response.message || response.label) && !response.messages) {
-      return response;
-    }
-
-    // Extract the most recent error from messages array
-    if (response.messages && response.messages.length > 0) {
-      const lastMessage = response.messages[response.messages.length - 1];
-      return {
-        ...response,
-        message: lastMessage.message || response.message || 'Unknown error',
-        label: lastMessage.label || response.label || 'Error'
-      };
-    }
 
-    // Fallback: ensure we have at least message/label fields
-    return {
-      ...response,
-      message: response.message || 'Unknown error',
-      label: response.label || 'Error'
-    };
-  }
-
-  /**
-   * Polls the progress of a long-running task.
-   * 
-   * @param {string} jobId - The ID of the job to poll for progress.
-   * @param {function} onProgress - Callback function that receives progress updates.
-   * 
-   * The function periodically sends GET requests to check the task's progress
-   * and reports back via the provided callback function . The polling stops when
-   * the task is completed or an error occurs.
-   */
-  async pollTaskProgress(jobId, callbacks) {
-    const {
-      onProgress,
-      onError,
-      onStopped,
-      onWaiting,
-      onDone,
-      pollingInterval = 2000
-    } = callbacks;
-    try {
-      const checkProgress = async () => {
-        const response = await this.get(`/task_service/pollChainProgress`, {
-          jobId: jobId
+      // Extract the most recent error from messages array
+      if (response.messages && response.messages.length > 0) {
+        var lastMessage = response.messages[response.messages.length - 1];
+        return _objectSpread(_objectSpread({}, response), {}, {
+          message: lastMessage.message || response.message || 'Unknown error',
+          label: lastMessage.label || response.label || 'Error'
         });
-
-        // If the task is still in progress, start polling for updates
-        if (response.status === 'DONE' && onDone) {
-          // Provide the current progress to the callback function
-          //console.log('Finish (progress) ',response);
-          onDone(response);
-        }
-        if (response.status === 'ERROR' && onError) {
-          // Normalize error response to have consistent message/label at top level
-          onError(this._normalizeErrorResponse(response));
-        }
-        if (response.status === 'STOPPED' && onStopped) {
-          // Provide the current progress to the callback function
-          onStopped(response);
-        }
-        if (response.status === 'WAITING' && onWaiting) {
-          // Provide the current progress to the callback function
-          onWaiting(response);
-        }
-
-        // Provide the current progress to the callback function
-        if (response.status == 'RUNNING' && onProgress) {
-          onProgress(response);
-        }
-
-        // Continue polling if the status is 'RUNNING' or STOPPING
-        if (['RUNNING', 'STOPPING'].includes(response.status)) {
-          setTimeout(checkProgress, pollingInterval); // Poll every 2 seconds
-        }
-      };
-      checkProgress();
-    } catch (e) {
-      // Handle error based on your application's logic
-      return this._handleError(e);
-    }
-  }
-
-  /**
-   * Performs a GET request to the specified endpoint.
-   * 
-   * This method uses the Axios instance to make an authenticated GET request.
-   * The `authtoken` stored in the class instance is included in the request headers
-   * for authorization. It handles any errors and returns the response data.
-   *
-   * @param {string} endpoint - The endpoint URL to which the GET request is made.
-   * @param {Object} [params={}] - Optional parameters to be sent with the request.
-   * @returns {Promise<Object>} - The response data from the API.
-   */
-  async get(endpoint, params = {}) {
-    try {
-      // Add the authToken to the headers
-      const headers = {
-        authtoken: this.authtoken
-      };
-
-      // Make the GET request using Axios
-      const response = await this.axios.get(endpoint, {
-        params,
-        headers
-      });
-
-      // Check if the response is not okay
-      if (response.data.ok === false) {
-        return this._handleError(response);
       }
 
-      // Return the response data
-      return response.data;
-    } catch (e) {
-      // Handle any errors
-      return this._handleError(e);
-    }
-  }
-
-  /**
-   * Performs a POST request to the specified endpoint.
-   * 
-   * This method uses the Axios instance to make an authenticated POST request.
-   * It includes the `authtoken` in the request headers for authorization. The method
-   * sends the provided data as the request body. It handles any errors and returns
-   * the response data.
-   *
-   * @param {string} endpoint - The endpoint URL to which the POST request is made.
-   * @param {Object} [data={}] - Data to be sent in the body of the POST request.
-   * @returns {Promise<Object>} - The response data from the API.
-   */
-  async post(endpoint, data = {}) {
-    try {
-      // Add the authToken to the headers
-      const headers = {
-        authtoken: this.authtoken
-      };
-
-      // Make the POST request using Axios
-      const response = await this.axios.post(endpoint, data, {
-        headers
+      // Fallback: ensure we have at least message/label fields
+      return _objectSpread(_objectSpread({}, response), {}, {
+        message: response.message || 'Unknown error',
+        label: response.label || 'Error'
       });
+    }
 
-      // Check if the response is not okay
-      if (response.data.ok === false) {
-        return this._handleError(response);
+    /**
+     * Polls the progress of a long-running task.
+     * 
+     * @param {string} jobId - The ID of the job to poll for progress.
+     * @param {function} onProgress - Callback function that receives progress updates.
+     * 
+     * The function periodically sends GET requests to check the task's progress
+     * and reports back via the provided callback function . The polling stops when
+     * the task is completed or an error occurs.
+     */
+  }, {
+    key: "pollTaskProgress",
+    value: (function () {
+      var _pollTaskProgress = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee28(jobId, callbacks) {
+        var _this9 = this;
+        var onProgress, onError, onStopped, onWaiting, onDone, _callbacks$pollingInt, pollingInterval, checkProgress;
+        return _regeneratorRuntime().wrap(function _callee28$(_context28) {
+          while (1) switch (_context28.prev = _context28.next) {
+            case 0:
+              onProgress = callbacks.onProgress, onError = callbacks.onError, onStopped = callbacks.onStopped, onWaiting = callbacks.onWaiting, onDone = callbacks.onDone, _callbacks$pollingInt = callbacks.pollingInterval, pollingInterval = _callbacks$pollingInt === void 0 ? 2000 : _callbacks$pollingInt;
+              _context28.prev = 1;
+              checkProgress = /*#__PURE__*/function () {
+                var _ref8 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee27() {
+                  var response;
+                  return _regeneratorRuntime().wrap(function _callee27$(_context27) {
+                    while (1) switch (_context27.prev = _context27.next) {
+                      case 0:
+                        _context27.next = 2;
+                        return _this9.get("/task_service/pollChainProgress", {
+                          jobId: jobId
+                        });
+                      case 2:
+                        response = _context27.sent;
+                        // If the task is still in progress, start polling for updates
+                        if (response.status === 'DONE' && onDone) {
+                          // Provide the current progress to the callback function
+                          //console.log('Finish (progress) ',response);
+                          onDone(response);
+                        }
+                        if (response.status === 'ERROR' && onError) {
+                          // Normalize error response to have consistent message/label at top level
+                          onError(_this9._normalizeErrorResponse(response));
+                        }
+                        if (response.status === 'STOPPED' && onStopped) {
+                          // Provide the current progress to the callback function
+                          onStopped(response);
+                        }
+                        if (response.status === 'WAITING' && onWaiting) {
+                          // Provide the current progress to the callback function
+                          onWaiting(response);
+                        }
+
+                        // Provide the current progress to the callback function
+                        if (response.status == 'RUNNING' && onProgress) {
+                          onProgress(response);
+                        }
+
+                        // Continue polling if the status is 'RUNNING' or STOPPING
+                        if (['RUNNING', 'STOPPING'].includes(response.status)) {
+                          setTimeout(checkProgress, pollingInterval); // Poll every 2 seconds
+                        }
+                      case 9:
+                      case "end":
+                        return _context27.stop();
+                    }
+                  }, _callee27);
+                }));
+                return function checkProgress() {
+                  return _ref8.apply(this, arguments);
+                };
+              }();
+              checkProgress();
+              _context28.next = 9;
+              break;
+            case 6:
+              _context28.prev = 6;
+              _context28.t0 = _context28["catch"](1);
+              return _context28.abrupt("return", this._handleError(_context28.t0));
+            case 9:
+            case "end":
+              return _context28.stop();
+          }
+        }, _callee28, this, [[1, 6]]);
+      }));
+      function pollTaskProgress(_x16, _x17) {
+        return _pollTaskProgress.apply(this, arguments);
       }
-
-      // Return the response data
-      return response.data;
-    } catch (e) {
-      // Handle any errors
-      return this._handleError(e);
-    }
-  }
-  setErrorHandler(customErrorHandler) {
-    this.customErrorHandler = customErrorHandler;
-  }
-  _handleError(err) {
-    // Invoke the custom error handler if provided
-    if (this.customErrorHandler) {
-      let res = this.customErrorHandler(err);
-      if (res) return;
+      return pollTaskProgress;
+    }()
+    /**
+     * Performs a GET request to the specified endpoint.
+     * 
+     * This method uses the Axios instance to make an authenticated GET request.
+     * The `authtoken` stored in the class instance is included in the request headers
+     * for authorization. It handles any errors and returns the response data.
+     *
+     * @param {string} endpoint - The endpoint URL to which the GET request is made.
+     * @param {Object} [params={}] - Optional parameters to be sent with the request.
+     * @returns {Promise<Object>} - The response data from the API.
+     */
+    )
+  }, {
+    key: "get",
+    value: (function () {
+      var _get = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee29(endpoint) {
+        var params,
+          headers,
+          response,
+          _args29 = arguments;
+        return _regeneratorRuntime().wrap(function _callee29$(_context29) {
+          while (1) switch (_context29.prev = _context29.next) {
+            case 0:
+              params = _args29.length > 1 && _args29[1] !== undefined ? _args29[1] : {};
+              _context29.prev = 1;
+              // Add the authToken to the headers
+              headers = {
+                authtoken: this.authtoken
+              }; // Make the GET request using Axios
+              _context29.next = 5;
+              return this.axios.get(endpoint, {
+                params: params,
+                headers: headers
+              });
+            case 5:
+              response = _context29.sent;
+              if (!(response.data.ok === false)) {
+                _context29.next = 8;
+                break;
+              }
+              return _context29.abrupt("return", this._handleError(response));
+            case 8:
+              return _context29.abrupt("return", response.data);
+            case 11:
+              _context29.prev = 11;
+              _context29.t0 = _context29["catch"](1);
+              return _context29.abrupt("return", this._handleError(_context29.t0));
+            case 14:
+            case "end":
+              return _context29.stop();
+          }
+        }, _callee29, this, [[1, 11]]);
+      }));
+      function get(_x18) {
+        return _get.apply(this, arguments);
+      }
+      return get;
+    }()
+    /**
+     * Performs a POST request to the specified endpoint.
+     * 
+     * This method uses the Axios instance to make an authenticated POST request.
+     * It includes the `authtoken` in the request headers for authorization. The method
+     * sends the provided data as the request body. It handles any errors and returns
+     * the response data.
+     *
+     * @param {string} endpoint - The endpoint URL to which the POST request is made.
+     * @param {Object} [data={}] - Data to be sent in the body of the POST request.
+     * @returns {Promise<Object>} - The response data from the API.
+     */
+    )
+  }, {
+    key: "post",
+    value: (function () {
+      var _post = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee30(endpoint) {
+        var data,
+          headers,
+          response,
+          _args30 = arguments;
+        return _regeneratorRuntime().wrap(function _callee30$(_context30) {
+          while (1) switch (_context30.prev = _context30.next) {
+            case 0:
+              data = _args30.length > 1 && _args30[1] !== undefined ? _args30[1] : {};
+              _context30.prev = 1;
+              // Add the authToken to the headers
+              headers = {
+                authtoken: this.authtoken
+              }; // Make the POST request using Axios
+              _context30.next = 5;
+              return this.axios.post(endpoint, data, {
+                headers: headers
+              });
+            case 5:
+              response = _context30.sent;
+              if (!(response.data.ok === false)) {
+                _context30.next = 8;
+                break;
+              }
+              return _context30.abrupt("return", this._handleError(response));
+            case 8:
+              return _context30.abrupt("return", response.data);
+            case 11:
+              _context30.prev = 11;
+              _context30.t0 = _context30["catch"](1);
+              return _context30.abrupt("return", this._handleError(_context30.t0));
+            case 14:
+            case "end":
+              return _context30.stop();
+          }
+        }, _callee30, this, [[1, 11]]);
+      }));
+      function post(_x19) {
+        return _post.apply(this, arguments);
+      }
+      return post;
+    }())
+  }, {
+    key: "setErrorHandler",
+    value: function setErrorHandler(customErrorHandler) {
+      this.customErrorHandler = customErrorHandler;
     }
-    if (_.isObject(err) && _.get(err, 'response')) {
-      if (err.response) {
-        console.log('Error response:', {
-          data: err.response.data,
-          status: err.response.status,
-          headers: err.response.headers
-        });
+  }, {
+    key: "_handleError",
+    value: function _handleError(err) {
+      // Invoke the custom error handler if provided
+      if (this.customErrorHandler) {
+        var res = this.customErrorHandler(err);
+        if (res) return;
       }
-      const msg = _.get(err, 'response.data.message', 'Error in API response');
-      if (msg.key) {
-        //throw new Error(msg.key);
-        throw {
-          message: msg.key
-        };
+      if (_.isObject(err) && _.get(err, 'response')) {
+        if (err.response) {}
+        var msg = _.get(err, 'response.data.message', 'Error in API response');
+        if (msg.key) {
+          //throw new Error(msg.key);
+          throw {
+            message: msg.key
+          };
+        } else {
+          //throw new Error(msg);
+          throw {
+            message: msg
+          };
+        }
       } else {
-        //throw new Error(msg);
+        //throw new Error(err.message || 'Unknown error');
         throw {
-          message: msg
+          code: err.code,
+          message: err.message
+        } || {
+          message: err
+        } || {
+          message: 'Unknown error'
         };
       }
-    } else {
-      //throw new Error(err.message || 'Unknown error');
-      throw {
-        code: err.code,
-        message: err.message
-      } || {
-        message: err
-      } || {
-        message: 'Unknown error'
-      };
     }
-  }
-}
+  }]);
+  return RbtApi;
+}();
+export { RbtApi as default };