@auxilium/datalynk-client 1.4.1 → 1.5.1

package/dist/index.cjs

@@ -1,902 +1,276 @@
-(function(global2, factory) {
-  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.utils = {}));
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.utils = {}));
 })(this, function(exports2) {
   "use strict";var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
-  var __defProp2 = Object.defineProperty;
-  var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
-  function clean(obj, undefinedOnly = false) {
-    if (obj == null) throw new Error("Cannot clean a NULL value");
-    if (Array.isArray(obj)) {
-      obj = obj.filter((o) => undefinedOnly ? o !== void 0 : o != null);
-    } else {
-      Object.entries(obj).forEach(([key, value]) => {
-        if (undefinedOnly && value === void 0 || !undefinedOnly && value == null) delete obj[key];
-      });
-    }
-    return obj;
+  function clean(value, undefinedOnly = false) {
+    if (value == null) throw new Error("Cannot clean a NULL value");
+    if (Array.isArray(value)) return value.filter((item) => undefinedOnly ? item !== void 0 : item != null);
+    Object.entries(value).forEach(([key, item]) => {
+      if (undefinedOnly && item === void 0 || !undefinedOnly && item == null) delete value[key];
+    });
+    return value;
   }
   function deepCopy(value) {
     try {
       return structuredClone(value);
     } catch {
-      return JSON.parse(JSONSanitize(value));
+      const seen = [];
+      return JSON.parse(JSON.stringify(value, (_key, item) => {
+        if (typeof item === "object" && item !== null) {
+          if (seen.includes(item)) return "[Circular]";
+          seen.push(item);
+        }
+        return item;
+      }));
     }
   }
-  function dotNotation(obj, prop, set) {
-    if (obj == null || !prop) return void 0;
-    return prop.split(/[.[\]]/g).filter((prop2) => prop2.length).reduce((obj2, prop2, i, arr) => {
-      if (prop2[0] == '"' || prop2[0] == "'") prop2 = prop2.slice(1, -1);
-      if (!(obj2 == null ? void 0 : obj2.hasOwnProperty(prop2))) {
-        return void 0;
-      }
-      return obj2[prop2];
-    }, obj);
-  }
-  function isEqual(a, b) {
-    const ta = typeof a, tb = typeof b;
-    if (ta != "object" || a == null || (tb != "object" || b == null))
-      return ta == "function" && tb == "function" ? a.toString() == b.toString() : a === b;
-    const keys = Object.keys(a);
-    if (keys.length != Object.keys(b).length) return false;
-    return Object.keys(a).every((key) => isEqual(a[key], b[key]));
-  }
-  function JSONAttemptParse(json) {
+  function JSONAttemptParse(value) {
     try {
-      return JSON.parse(json);
+      return JSON.parse(value);
     } catch {
-      return json;
-    }
-  }
-  function JSONSanitize(obj, space) {
-    const cache = [];
-    return JSON.stringify(obj, (key, value) => {
-      if (typeof value === "object" && value !== null) {
-        if (cache.includes(value)) return "[Circular]";
-        cache.push(value);
-      }
       return value;
-    }, space);
-  }
-  class ASet extends Array {
-    /** Number of elements in set */
-    get size() {
-      return this.length;
-    }
-    /**
-     * Array to create set from, duplicate values will be removed
-     * @param {T[]} elements Elements which will be added to set
-     */
-    constructor(elements = []) {
-      super();
-      if (!!(elements == null ? void 0 : elements["forEach"]))
-        elements.forEach((el) => this.add(el));
-    }
-    /**
-     * Add elements to set if unique
-     * @param items
-     */
-    add(...items) {
-      items.filter((el) => !this.has(el)).forEach((el) => this.push(el));
-      return this;
-    }
-    /**
-     * Remove all elements
-     */
-    clear() {
-      this.splice(0, this.length);
-      return this;
-    }
-    /**
-     * Delete elements from set
-     * @param items Elements that will be deleted
-     */
-    delete(...items) {
-      items.forEach((el) => {
-        const index = this.indexOf(el);
-        if (index != -1) this.splice(index, 1);
-      });
-      return this;
-    }
-    /**
-     * Create list of elements this set has which the comparison set does not
-     * @param {ASet<T>} set Set to compare against
-     * @return {ASet<T>} Different elements
-     */
-    difference(set) {
-      return new ASet(this.filter((el) => !set.has(el)));
-    }
-    /**
-     * Check if set includes element
-     * @param {T} el Element to look for
-     * @return {boolean} True if element was found, false otherwise
-     */
-    has(el) {
-      return this.indexOf(el) != -1;
-    }
-    /**
-     * Find index number of element, or -1 if it doesn't exist. Matches by equality not reference
-     *
-     * @param {T} search Element to find
-     * @param {number} fromIndex Starting index position
-     * @return {number} Element index number or -1 if missing
-     */
-    indexOf(search2, fromIndex) {
-      return super.findIndex((el) => isEqual(el, search2), fromIndex);
-    }
-    /**
-     * Create list of elements this set has in common with the comparison set
-     * @param {ASet<T>} set Set to compare against
-     * @return {boolean} Set of common elements
-     */
-    intersection(set) {
-      return new ASet(this.filter((el) => set.has(el)));
-    }
-    /**
-     * Check if this set has no elements in common with the comparison set
-     * @param {ASet<T>} set Set to compare against
-     * @return {boolean} True if nothing in common, false otherwise
-     */
-    isDisjointFrom(set) {
-      return this.intersection(set).size == 0;
-    }
-    /**
-     * Check if all elements in this set are included in the comparison set
-     * @param {ASet<T>} set Set to compare against
-     * @return {boolean} True if all elements are included, false otherwise
-     */
-    isSubsetOf(set) {
-      return this.findIndex((el) => !set.has(el)) == -1;
-    }
-    /**
-     * Check if all elements from comparison set are included in this set
-     * @param {ASet<T>} set Set to compare against
-     * @return {boolean} True if all elements are included, false otherwise
-     */
-    isSuperset(set) {
-      return set.findIndex((el) => !this.has(el)) == -1;
-    }
-    /**
-     * Create list of elements that are only in one set but not both (XOR)
-     * @param {ASet<T>} set Set to compare against
-     * @return {ASet<T>} New set of unique elements
-     */
-    symmetricDifference(set) {
-      return new ASet([...this.difference(set), ...set.difference(this)]);
-    }
-    /**
-     * Create joined list of elements included in this & the comparison set
-     * @param {ASet<T>} set Set join
-     * @return {ASet<T>} New set of both previous sets combined
-     */
-    union(set) {
-      return new ASet([...this, ...set]);
     }
   }
-  function sortByProp(prop, reverse = false) {
-    return function(a, b) {
-      const aVal = dotNotation(a, prop);
-      const bVal = dotNotation(b, prop);
-      if (typeof aVal == "number" && typeof bVal == "number")
-        return (reverse ? -1 : 1) * (aVal - bVal);
-      if (aVal > bVal) return reverse ? -1 : 1;
-      if (aVal < bVal) return reverse ? 1 : -1;
-      return 0;
-    };
-  }
   function makeArray(value) {
     return Array.isArray(value) ? value : [value];
   }
-  class Database {
-    constructor(database, tables, version2) {
-      __publicField2(this, "connection");
-      __publicField2(this, "tables");
-      this.database = database;
-      this.version = version2;
-      this.connection = new Promise((resolve, reject) => {
-        const req = indexedDB.open(this.database, this.version);
-        this.tables = tables.map((t) => {
-          t = typeof t == "object" ? t : { name: t };
-          return { ...t, name: t.name.toString() };
-        });
-        const tableNames = new ASet(this.tables.map((t) => t.name));
-        req.onerror = () => reject(req.error);
-        req.onsuccess = () => {
-          const db = req.result;
-          if (tableNames.symmetricDifference(new ASet(Array.from(db.objectStoreNames))).length) {
-            db.close();
-            Object.assign(this, new Database(this.database, this.tables, db.version + 1));
-          } else {
-            this.version = db.version;
-            resolve(db);
-          }
-        };
-        req.onupgradeneeded = () => {
-          const db = req.result;
-          const existingTables = new ASet(Array.from(db.objectStoreNames));
-          existingTables.difference(tableNames).forEach((name) => db.deleteObjectStore(name));
-          tableNames.difference(existingTables).forEach((name) => db.createObjectStore(name));
-        };
-      });
-    }
-    includes(name) {
-      return !!this.tables.find((t) => t.name == name.toString());
-    }
-    table(name) {
-      return new Table(this, name.toString());
-    }
+  function property(value, path) {
+    return path.split(".").reduce((current, key) => current == null ? void 0 : current[key], value);
   }
-  class Table {
-    constructor(database, name) {
-      this.database = database;
-      this.name = name;
-    }
-    async tx(table, fn2, readonly = false) {
-      const db = await this.database.connection;
-      const tx = db.transaction(table, readonly ? "readonly" : "readwrite");
-      const store = tx.objectStore(table);
-      return new Promise((resolve, reject) => {
-        const request = fn2(store);
-        request.onsuccess = () => resolve(request.result);
-        request.onerror = () => reject(request.error);
-      });
-    }
-    add(value, key) {
-      return this.tx(this.name, (store) => store.add(value, key));
-    }
-    count() {
-      return this.tx(this.name, (store) => store.count(), true);
-    }
-    put(key, value) {
-      return this.tx(this.name, (store) => store.put(value, key));
-    }
-    getAll() {
-      return this.tx(this.name, (store) => store.getAll(), true);
-    }
-    getAllKeys() {
-      return this.tx(this.name, (store) => store.getAllKeys(), true);
-    }
-    get(key) {
-      return this.tx(this.name, (store) => store.get(key), true);
-    }
-    delete(key) {
-      return this.tx(this.name, (store) => store.delete(key));
-    }
-    clear() {
-      return this.tx(this.name, (store) => store.clear());
-    }
+  function sortByProp(path, reverse = false) {
+    return (a, b) => {
+      const aValue = property(a, path);
+      const bValue = property(b, path);
+      if (typeof aValue == "number" && typeof bValue == "number")
+        return (reverse ? -1 : 1) * (aValue - bValue);
+      if (aValue > bValue) return reverse ? -1 : 1;
+      if (aValue < bValue) return reverse ? 1 : -1;
+      return 0;
+    };
+  }
+  async function sleepWhile(condition, interval = 100) {
+    while (await condition()) await new Promise((resolve) => setTimeout(resolve, interval));
   }
   function contrast(background) {
-    const exploded = background == null ? void 0 : background.match(background.length >= 6 ? /[0-9a-fA-F]{2}/g : /[0-9a-fA-F]/g);
-    if (!exploded || (exploded == null ? void 0 : exploded.length) < 3) return "black";
-    const [r, g, b] = exploded.map((hex) => parseInt(hex.length == 1 ? `${hex}${hex}` : hex, 16));
-    const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
-    return luminance > 0.5 ? "black" : "white";
+    const parts = background == null ? void 0 : background.match(background.length >= 6 ? /[0-9a-fA-F]{2}/g : /[0-9a-fA-F]/g);
+    if (!parts || parts.length < 3) return "black";
+    const [red, green, blue] = parts.map((hex) => parseInt(hex.length === 1 ? hex + hex : hex, 16));
+    return (0.299 * red + 0.587 * green + 0.114 * blue) / 255 > 0.5 ? "black" : "white";
   }
-  const LETTER_LIST = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-  const NUMBER_LIST = "0123456789";
-  const SYMBOL_LIST = "~`!@#$%^&*()_-+={[}]|\\:;\"'<,>.?/";
   function randomStringBuilder(length, letters = false, numbers = false, symbols = false) {
+    const LETTER_LIST = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    const NUMBER_LIST = "0123456789";
+    const SYMBOL_LIST = "~`!@#$%^&*()_-+={[}]|\\:;\"'<,>.?/";
     if (!letters && !numbers && !symbols) throw new Error("Must enable at least one: letters, numbers, symbols");
     return Array(length).fill(null).map(() => {
-      let c;
+      let character;
       do {
         const type = ~~(Math.random() * 3);
-        if (letters && type == 0) {
-          c = LETTER_LIST[~~(Math.random() * LETTER_LIST.length)];
-        } else if (numbers && type == 1) {
-          c = NUMBER_LIST[~~(Math.random() * NUMBER_LIST.length)];
-        } else if (symbols && type == 2) {
-          c = SYMBOL_LIST[~~(Math.random() * SYMBOL_LIST.length)];
-        }
-      } while (!c);
-      return c;
+        if (letters && type == 0) character = LETTER_LIST[~~(Math.random() * LETTER_LIST.length)];
+        else if (numbers && type == 1) character = NUMBER_LIST[~~(Math.random() * NUMBER_LIST.length)];
+        else if (symbols && type == 2) character = SYMBOL_LIST[~~(Math.random() * SYMBOL_LIST.length)];
+      } while (!character);
+      return character;
     }).join("");
   }
-  class PromiseProgress extends Promise {
-    constructor(executor) {
-      super((resolve, reject) => executor(
-        (value) => resolve(value),
-        (reason) => reject(reason),
-        (progress) => this.progress = progress
-      ));
-      __publicField2(this, "listeners", []);
-      __publicField2(this, "_progress", 0);
-    }
-    get progress() {
-      return this._progress;
-    }
-    set progress(p) {
-      if (p == this._progress) return;
-      this._progress = p;
-      this.listeners.forEach((l) => l(p));
-    }
-    static from(promise) {
-      if (promise instanceof PromiseProgress) return promise;
-      return new PromiseProgress((res, rej) => promise.then((...args) => res(...args)).catch((...args) => rej(...args)));
-    }
-    from(promise) {
-      const newPromise = PromiseProgress.from(promise);
-      this.onProgress((p) => newPromise.progress = p);
-      return newPromise;
-    }
-    onProgress(callback) {
-      this.listeners.push(callback);
-      return this;
-    }
-    then(res, rej) {
-      const resp = super.then(res, rej);
-      return this.from(resp);
-    }
-    catch(rej) {
-      return this.from(super.catch(rej));
-    }
-    finally(res) {
-      return this.from(super.finally(res));
-    }
-  }
-  function sleep(ms) {
-    return new Promise((res) => setTimeout(res, ms));
-  }
-  async function sleepWhile(fn2, checkInterval = 100) {
-    while (await fn2()) await sleep(checkInterval);
-  }
-  class TypedEmitter {
-    constructor() {
-      __publicField2(this, "listeners", {});
-    }
-    static emit(event, ...args) {
-      (this.listeners["*"] || []).forEach((l) => l(event, ...args));
-      (this.listeners[event.toString()] || []).forEach((l) => l(...args));
-    }
-    static off(event, listener) {
-      const e = event.toString();
-      this.listeners[e] = (this.listeners[e] || []).filter((l) => l != listener);
-    }
-    static on(event, listener) {
-      var _a;
-      const e = event.toString();
-      if (!this.listeners[e]) this.listeners[e] = [];
-      (_a = this.listeners[e]) == null ? void 0 : _a.push(listener);
-      return () => this.off(event, listener);
-    }
-    static once(event, listener) {
-      return new Promise((res) => {
-        const unsubscribe = this.on(event, (...args) => {
-          res(args.length == 1 ? args[0] : args);
-          if (listener) listener(...args);
-          unsubscribe();
-        });
-      });
-    }
-    emit(event, ...args) {
-      (this.listeners["*"] || []).forEach((l) => l(event, ...args));
-      (this.listeners[event] || []).forEach((l) => l(...args));
-    }
-    off(event, listener) {
-      this.listeners[event] = (this.listeners[event] || []).filter((l) => l != listener);
-    }
-    on(event, listener) {
-      var _a;
-      if (!this.listeners[event]) this.listeners[event] = [];
-      (_a = this.listeners[event]) == null ? void 0 : _a.push(listener);
-      return () => this.off(event, listener);
-    }
-    once(event, listener) {
-      return new Promise((res) => {
-        const unsubscribe = this.on(event, (...args) => {
-          res(args.length == 1 ? args[0] : args);
-          if (listener) listener(...args);
-          unsubscribe();
-        });
-      });
-    }
-  }
-  __publicField2(TypedEmitter, "listeners", {});
   class CustomError extends Error {
     constructor(message, code) {
       super(message);
-      __publicField2(this, "_code");
+      __publicField(this, "_code");
       if (code != null) this._code = code;
     }
     get code() {
       return this._code || this.constructor.code;
     }
-    set code(c) {
-      this._code = c;
-    }
-    static from(err) {
-      const code = Number(err.statusCode) ?? Number(err.code);
-      const newErr = new this(err.message || err.toString());
-      return Object.assign(newErr, {
-        stack: err.stack,
-        ...err,
-        code: code ?? void 0
-      });
-    }
-    static instanceof(err) {
-      return err.constructor.code != void 0;
+    set code(code) {
+      this._code = code;
     }
     toString() {
       return this.message || super.toString();
     }
   }
-  __publicField2(CustomError, "code", 500);
+  __publicField(CustomError, "code", 500);
   class BadRequestError extends CustomError {
     constructor(message = "Bad Request") {
       super(message);
     }
-    static instanceof(err) {
-      return err.constructor.code == this.code;
-    }
   }
-  __publicField2(BadRequestError, "code", 400);
+  __publicField(BadRequestError, "code", 400);
   class UnauthorizedError extends CustomError {
     constructor(message = "Unauthorized") {
       super(message);
     }
-    static instanceof(err) {
-      return err.constructor.code == this.code;
-    }
   }
-  __publicField2(UnauthorizedError, "code", 401);
+  __publicField(UnauthorizedError, "code", 401);
   class PaymentRequiredError extends CustomError {
     constructor(message = "Payment Required") {
       super(message);
     }
-    static instanceof(err) {
-      return err.constructor.code == this.code;
-    }
   }
-  __publicField2(PaymentRequiredError, "code", 402);
+  __publicField(PaymentRequiredError, "code", 402);
   class ForbiddenError extends CustomError {
     constructor(message = "Forbidden") {
       super(message);
     }
-    static instanceof(err) {
-      return err.constructor.code == this.code;
-    }
   }
-  __publicField2(ForbiddenError, "code", 403);
+  __publicField(ForbiddenError, "code", 403);
   class NotFoundError extends CustomError {
     constructor(message = "Not Found") {
       super(message);
     }
-    static instanceof(err) {
-      return err.constructor.code == this.code;
-    }
   }
-  __publicField2(NotFoundError, "code", 404);
+  __publicField(NotFoundError, "code", 404);
   class MethodNotAllowedError extends CustomError {
     constructor(message = "Method Not Allowed") {
       super(message);
     }
-    static instanceof(err) {
-      return err.constructor.code == this.code;
-    }
   }
-  __publicField2(MethodNotAllowedError, "code", 405);
+  __publicField(MethodNotAllowedError, "code", 405);
   class NotAcceptableError extends CustomError {
     constructor(message = "Not Acceptable") {
       super(message);
     }
-    static instanceof(err) {
-      return err.constructor.code == this.code;
-    }
   }
-  __publicField2(NotAcceptableError, "code", 406);
+  __publicField(NotAcceptableError, "code", 406);
   class InternalServerError extends CustomError {
     constructor(message = "Internal Server Error") {
       super(message);
     }
-    static instanceof(err) {
-      return err.constructor.code == this.code;
-    }
   }
-  __publicField2(InternalServerError, "code", 500);
+  __publicField(InternalServerError, "code", 500);
   class NotImplementedError extends CustomError {
     constructor(message = "Not Implemented") {
       super(message);
     }
-    static instanceof(err) {
-      return err.constructor.code == this.code;
-    }
   }
-  __publicField2(NotImplementedError, "code", 501);
+  __publicField(NotImplementedError, "code", 501);
   class BadGatewayError extends CustomError {
     constructor(message = "Bad Gateway") {
       super(message);
     }
-    static instanceof(err) {
-      return err.constructor.code == this.code;
-    }
   }
-  __publicField2(BadGatewayError, "code", 502);
+  __publicField(BadGatewayError, "code", 502);
   class ServiceUnavailableError extends CustomError {
     constructor(message = "Service Unavailable") {
       super(message);
     }
-    static instanceof(err) {
-      return err.constructor.code == this.code;
-    }
   }
-  __publicField2(ServiceUnavailableError, "code", 503);
+  __publicField(ServiceUnavailableError, "code", 503);
   class GatewayTimeoutError extends CustomError {
     constructor(message = "Gateway Timeout") {
       super(message);
     }
-    static instanceof(err) {
-      return err.constructor.code == this.code;
-    }
   }
-  __publicField2(GatewayTimeoutError, "code", 504);
+  __publicField(GatewayTimeoutError, "code", 504);
   function errorFromCode(code, message) {
-    switch (code) {
-      case 400:
-        return new BadRequestError(message);
-      case 401:
-        return new UnauthorizedError(message);
-      case 402:
-        return new PaymentRequiredError(message);
-      case 403:
-        return new ForbiddenError(message);
-      case 404:
-        return new NotFoundError(message);
-      case 405:
-        return new MethodNotAllowedError(message);
-      case 406:
-        return new NotAcceptableError(message);
-      case 500:
-        return new InternalServerError(message);
-      case 501:
-        return new NotImplementedError(message);
-      case 502:
-        return new BadGatewayError(message);
-      case 503:
-        return new ServiceUnavailableError(message);
-      case 504:
-        return new GatewayTimeoutError(message);
-      default:
-        return new CustomError(message, code);
-    }
-  }
-  class HttpResponse extends Response {
-    constructor(resp, stream) {
-      const body = [204, 205, 304].includes(resp.status) ? null : stream;
-      super(body, {
-        headers: resp.headers,
-        status: resp.status,
-        statusText: resp.statusText
-      });
-      __publicField2(this, "data");
-      __publicField2(this, "ok");
-      __publicField2(this, "redirected");
-      __publicField2(this, "type");
-      __publicField2(this, "url");
-      this.ok = resp.ok;
-      this.redirected = resp.redirected;
-      this.type = resp.type;
-      this.url = resp.url;
-    }
+    const errors = {
+      400: BadRequestError,
+      401: UnauthorizedError,
+      402: PaymentRequiredError,
+      403: ForbiddenError,
+      404: NotFoundError,
+      405: MethodNotAllowedError,
+      406: NotAcceptableError,
+      500: InternalServerError,
+      501: NotImplementedError,
+      502: BadGatewayError,
+      503: ServiceUnavailableError,
+      504: GatewayTimeoutError
+    };
+    const ErrorType = errors[code];
+    return ErrorType ? new ErrorType(message) : new CustomError(message, code);
   }
-  const _Http = class _Http2 {
-    constructor(defaults = {}) {
-      __publicField2(this, "interceptors", {});
-      __publicField2(this, "headers", {});
-      __publicField2(this, "url");
-      this.url = defaults.url ?? null;
-      this.headers = defaults.headers || {};
-      if (defaults.interceptors) {
-        defaults.interceptors.forEach((i) => _Http2.addInterceptor(i));
-      }
-    }
-    static addInterceptor(fn2) {
-      const key = Object.keys(_Http2.interceptors).length.toString();
-      _Http2.interceptors[key] = fn2;
-      return () => {
-        _Http2.interceptors[key] = null;
-      };
-    }
-    addInterceptor(fn2) {
-      const key = Object.keys(this.interceptors).length.toString();
-      this.interceptors[key] = fn2;
-      return () => {
-        this.interceptors[key] = null;
-      };
-    }
-    request(opts = {}) {
-      var _a;
-      if (!this.url && !opts.url) throw new Error("URL needs to be set");
-      let url = ((_a = opts.url) == null ? void 0 : _a.startsWith("http")) ? opts.url : (this.url || "") + (opts.url || "");
-      url = url.replaceAll(/([^:]\/)\/+/g, "$1");
-      if (opts.fragment) url.includes("#") ? url.replace(/#.*(\?|\n)/g, (match, arg1) => `#${opts.fragment}${arg1}`) : `${url}#${opts.fragment}`;
-      if (opts.query) {
-        const q = Array.isArray(opts.query) ? opts.query : Object.keys(opts.query).map((k) => ({ key: k, value: opts.query[k] }));
-        url += (url.includes("?") ? "&" : "?") + q.map((q2) => `${q2.key}=${q2.value}`).join("&");
-      }
-      const headers = clean({
-        "Content-Type": !opts.body ? void 0 : opts.body instanceof FormData ? "multipart/form-data" : "application/json",
-        ..._Http2.headers,
-        ...this.headers,
-        ...opts.headers
-      });
-      if (typeof opts.body == "object" && opts.body != null && headers["Content-Type"] == "application/json")
-        opts.body = JSON.stringify(opts.body);
-      return new PromiseProgress((res, rej, prog) => {
-        try {
-          fetch(url, {
-            headers,
-            method: opts.method || (opts.body ? "POST" : "GET"),
-            body: opts.body
-          }).then(async (resp) => {
-            var _a2, _b;
-            for (let fn2 of [...Object.values(_Http2.interceptors), ...Object.values(this.interceptors)]) {
-              await new Promise((res2) => fn2(resp, () => res2()));
-            }
-            const contentLength = resp.headers.get("Content-Length");
-            const total = contentLength ? parseInt(contentLength, 10) : 0;
-            let loaded = 0;
-            const reader = (_a2 = resp.body) == null ? void 0 : _a2.getReader();
-            const stream = new ReadableStream({
-              start(controller) {
-                function push() {
-                  reader == null ? void 0 : reader.read().then((event) => {
-                    if (event.done) return controller.close();
-                    loaded += event.value.byteLength;
-                    prog(loaded / total);
-                    controller.enqueue(event.value);
-                    push();
-                  }).catch((error) => controller.error(error));
-                }
-                push();
-              }
-            });
-            resp = new HttpResponse(resp, stream);
-            if (opts.decode !== false) {
-              const content = (_b = resp.headers.get("Content-Type")) == null ? void 0 : _b.toLowerCase();
-              if (content == null ? void 0 : content.includes("form")) resp.data = await resp.formData();
-              else if (content == null ? void 0 : content.includes("json")) resp.data = await resp.json();
-              else if (content == null ? void 0 : content.includes("text")) resp.data = await resp.text();
-              else if (content == null ? void 0 : content.includes("application")) resp.data = await resp.blob();
-            }
-            if (resp.ok) res(resp);
-            else rej(resp);
-          }).catch((err) => rej(err));
-        } catch (err) {
-          rej(err);
-        }
-      });
-    }
-  };
-  __publicField2(_Http, "interceptors", {});
-  __publicField2(_Http, "headers", {});
   function decodeJwt(token) {
     const base64 = token.split(".")[1].replace(/-/g, "+").replace(/_/g, "/");
-    return JSONAttemptParse(decodeURIComponent(atob(base64).split("").map(function(c) {
-      return "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2);
-    }).join("")));
+    return JSONAttemptParse(decodeURIComponent(atob(base64).split("").map(
+      (character) => "%" + ("00" + character.charCodeAt(0).toString(16)).slice(-2)
+    ).join("")));
   }
-  const CliEffects = {
-    CLEAR: "\x1B[0m"
-  };
-  const CliForeground = {
-    RED: "\x1B[31m",
-    YELLOW: "\x1B[33m",
-    BLUE: "\x1B[34m",
-    LIGHT_GREY: "\x1B[37m"
-  };
-  const _Logger = class _Logger2 extends TypedEmitter {
-    constructor(namespace) {
-      super();
-      this.namespace = namespace;
-    }
-    format(...text) {
-      const now = /* @__PURE__ */ new Date();
-      const timestamp = `${now.getFullYear()}-${now.getMonth() + 1}-${now.getDate()} ${now.getHours().toString().padStart(2, "0")}:${now.getMinutes().toString().padStart(2, "0")}:${now.getSeconds().toString().padStart(2, "0")}.${now.getMilliseconds().toString().padEnd(3, "0")}`;
-      return `${timestamp}${this.namespace ? ` [${this.namespace}]` : ""} ${text.map((t) => typeof t == "string" ? t : JSONSanitize(t, 2)).join(" ")}`;
-    }
-    debug(...args) {
-      if (_Logger2.LOG_LEVEL < 4) return;
-      const str = this.format(...args);
-      _Logger2.emit(4, str);
-      console.debug(CliForeground.LIGHT_GREY + str + CliEffects.CLEAR);
-    }
-    log(...args) {
-      if (_Logger2.LOG_LEVEL < 3) return;
-      const str = this.format(...args);
-      _Logger2.emit(3, str);
-      console.log(CliEffects.CLEAR + str);
-    }
-    info(...args) {
-      if (_Logger2.LOG_LEVEL < 2) return;
-      const str = this.format(...args);
-      _Logger2.emit(2, str);
-      console.info(CliForeground.BLUE + str + CliEffects.CLEAR);
-    }
-    warn(...args) {
-      if (_Logger2.LOG_LEVEL < 1) return;
-      const str = this.format(...args);
-      _Logger2.emit(1, str);
-      console.warn(CliForeground.YELLOW + str + CliEffects.CLEAR);
-    }
-    error(...args) {
-      if (_Logger2.LOG_LEVEL < 0) return;
-      const str = this.format(...args);
-      _Logger2.emit(0, str);
-      console.error(CliForeground.RED + str + CliEffects.CLEAR);
-    }
-  };
-  __publicField2(_Logger, "LOG_LEVEL", 4);
-  var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-  var dist = {};
-  var persist$1 = {};
-  Object.defineProperty(persist$1, "__esModule", { value: true });
-  persist$1.persist = persist$1.Persist = void 0;
-  class Persist {
-    /**
-     * @param {string} key Primary key value will be stored under
-     * @param {PersistOptions<T>} options Configure using {@link PersistOptions}
-     */
-    constructor(key, options = {}) {
-      __publicField2(this, "key");
-      __publicField2(this, "options");
-      __publicField2(this, "storage");
-      __publicField2(this, "watches", {});
-      __publicField2(this, "_value");
-      this.key = key;
-      this.options = options;
-      this.storage = options.storage || localStorage;
-      this.load();
-    }
-    /** Current value or default if undefined */
-    get value() {
-      var _a;
-      return this._value !== void 0 ? this._value : (_a = this.options) == null ? void 0 : _a.default;
-    }
-    /** Set value with proxy object wrapper to sync future changes */
-    set value(v) {
-      if (v == null || typeof v != "object")
-        this._value = v;
-      else
-        this._value = new Proxy(v, {
-          get: (target, p) => {
-            const f = typeof target[p] == "function";
-            if (!f)
-              return target[p];
-            return (...args) => {
-              const value = target[p](...args);
-              this.save();
-              return value;
-            };
-          },
-          set: (target, p, newValue) => {
-            target[p] = newValue;
-            this.save();
-            return true;
+  class Database {
+    constructor(database, tables, version2) {
+      __publicField(this, "connection");
+      __publicField(this, "tables");
+      this.database = database;
+      this.version = version2;
+      this.tables = tables.map((table) => typeof table === "object" ? { ...table, name: table.name.toString() } : { name: table.toString() });
+      this.connection = new Promise((resolve, reject) => {
+        const request = indexedDB.open(this.database, this.version);
+        const requested = new Set(this.tables.map((table) => table.name));
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => {
+          const db = request.result;
+          const existing = new Set(Array.from(db.objectStoreNames));
+          if ([...requested].some((name) => !existing.has(name)) || [...existing].some((name) => !requested.has(name))) {
+            db.close();
+            const upgraded = new Database(this.database, this.tables, db.version + 1);
+            this.version = upgraded.version;
+            this.connection = upgraded.connection;
+            this.connection.then(resolve, reject);
+          } else {
+            this.version = db.version;
+            resolve(db);
           }
-        });
-      this.save();
+        };
+        request.onupgradeneeded = () => {
+          const db = request.result;
+          const existing = new Set(Array.from(db.objectStoreNames));
+          existing.forEach((name) => {
+            if (!requested.has(name)) db.deleteObjectStore(name);
+          });
+          requested.forEach((name) => {
+            if (!existing.has(name)) db.createObjectStore(name);
+          });
+        };
+      });
     }
-    /** Notify listeners of change */
-    notify(value) {
-      Object.values(this.watches).forEach((watch) => watch(value));
+    includes(name) {
+      return this.tables.some((table) => table.name === name.toString());
     }
-    /** Delete value from storage */
-    clear() {
-      this.storage.removeItem(this.key);
-    }
-    /** Save current value to storage */
-    save() {
-      if (this._value === void 0)
-        this.clear();
-      else
-        this.storage.setItem(this.key, JSON.stringify(this._value));
-      this.notify(this.value);
-    }
-    /** Load value from storage */
-    load() {
-      if (this.storage[this.key] != void 0) {
-        let value = JSON.parse(this.storage.getItem(this.key));
-        if (value != null && typeof value == "object" && this.options.type)
-          value.__proto__ = this.options.type.prototype;
-        this.value = value;
-      } else
-        this.value = this.options.default || void 0;
+    table(name) {
+      return new Table(this, name.toString());
     }
-    /**
-     * Callback function which is run when there are changes
-     *
-     * @param {(value: T) => any} fn Callback will run on each change; it's passed the next value & it's return is ignored
-     * @returns {() => void} Function which will unsubscribe the watch/callback when called
-     */
-    watch(fn2) {
-      const index = Object.keys(this.watches).length;
-      this.watches[index] = fn2;
-      return () => {
-        delete this.watches[index];
-      };
+  }
+  class Table {
+    constructor(database, name) {
+      this.database = database;
+      this.name = name;
     }
-    /**
-     * Return value as JSON string
-     *
-     * @returns {string} Stringified object as JSON
-     */
-    toString() {
-      return JSON.stringify(this.value);
+    async tx(operation, readonly = false) {
+      const db = await this.database.connection;
+      return new Promise((resolve, reject) => {
+        const request = operation(db.transaction(this.name, readonly ? "readonly" : "readwrite").objectStore(this.name));
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+      });
     }
-    /**
-     * Return current value
-     *
-     * @returns {T} Current value
-     */
-    valueOf() {
-      return this.value;
+    add(value, key) {
+      return this.tx((store) => store.add(value, key));
     }
-  }
-  persist$1.Persist = Persist;
-  function persist(options) {
-    return (target, prop) => {
-      const key = (options == null ? void 0 : options.key) || `${target.constructor.name}.${prop.toString()}`;
-      const wrapper = new Persist(key, options);
-      Object.defineProperty(target, prop, {
-        get: function() {
-          return wrapper.value;
-        },
-        set: function(v) {
-          wrapper.value = v;
-        }
-      });
-    };
-  }
-  persist$1.persist = persist;
-  var memoryStorage = {};
-  Object.defineProperty(memoryStorage, "__esModule", { value: true });
-  memoryStorage.MemoryStorage = void 0;
-  class MemoryStorage {
-    get length() {
-      return Object.keys(this).length;
+    put(key, value) {
+      return this.tx((store) => store.put(value, key));
     }
-    clear() {
-      Object.keys(this).forEach((k) => this.removeItem(k));
+    get(key) {
+      return this.tx((store) => store.get(key), true);
     }
-    getItem(key) {
-      return this[key];
+    getAll() {
+      return this.tx((store) => store.getAll(), true);
     }
-    key(index) {
-      return Object.keys(this)[index];
+    getAllKeys() {
+      return this.tx((store) => store.getAllKeys(), true);
     }
-    removeItem(key) {
-      delete this[key];
+    delete(key) {
+      return this.tx((store) => store.delete(key));
     }
-    setItem(key, value) {
-      this[key] = value;
+    clear() {
+      return this.tx((store) => store.clear());
+    }
+    count() {
+      return this.tx((store) => store.count(), true);
     }
   }
-  memoryStorage.MemoryStorage = MemoryStorage;
-  (function(exports3) {
-    var __createBinding = commonjsGlobal && commonjsGlobal.__createBinding || (Object.create ? function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc);
-    } : function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o[k2] = m[k];
-    });
-    var __exportStar = commonjsGlobal && commonjsGlobal.__exportStar || function(m, exports22) {
-      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports22, p)) __createBinding(exports22, m, p);
-    };
-    Object.defineProperty(exports3, "__esModule", { value: true });
-    __exportStar(persist$1, exports3);
-    __exportStar(memoryStorage, exports3);
-  })(dist);
   var extendStatics = function(d, b) {
     extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
       d2.__proto__ = b2;
@@ -1751,6 +1125,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       __publicField(this, "alert");
       __publicField(this, "button");
       __publicField(this, "form");
+      __publicField(this, "forgotLink");
       __publicField(this, "password");
       __publicField(this, "persist");
       __publicField(this, "username");
@@ -1779,8 +1154,14 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       this.password = document.querySelector('#datalynk-login-form input[name="password"]');
       this.persist = document.querySelector('#datalynk-login-form input[name="persist"]');
       this.username = document.querySelector('#datalynk-login-form input[name="username"]');
+      this.forgotLink = document.querySelector("#datalynk-login-forgot");
       if (this.options.persist === false) this.persist.parentElement.remove();
       this.form.onsubmit = (event) => this.login(event);
+      this.forgotLink.onclick = (event) => this.forgotPassword(event);
+      const toggleForgotVisibility = () => this.forgotLink.classList.toggle("hidden", !this.username.value.trim());
+      this.username.addEventListener("input", toggleForgotVisibility);
+      const passwordToggle = document.querySelector("#datalynk-password-toggle");
+      if (passwordToggle) passwordToggle.onclick = () => this.password.type = this.password.type === "password" ? "text" : "password";
       const pwaLink = document.querySelector("#pwa-install-link");
       if (pwaLink) {
         pwaLink.addEventListener("click", async (e) => {
@@ -1852,6 +1233,19 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         this.button.disabled = false;
       });
     }
+    /** Forgot password link click event */
+    forgotPassword(event) {
+      event.preventDefault();
+      const login = this.username.value.trim() || prompt("Enter your email or username") || "";
+      if (!login) return;
+      this.alert.classList.remove("hidden");
+      this.alert.innerHTML = "Sending reset email...";
+      return this.api.auth.resetRequest(login, "email").then(() => {
+        this.alert.innerHTML = "If an account exists, a reset email has been sent.";
+      }).catch((err) => {
+        this.alert.innerHTML = err.message || "Unable to send reset email.";
+      });
+    }
   };
   /** Dynamically create CSS style */
   __publicField(_LoginPrompt, "css", (options) => `
@@ -2004,6 +1398,35 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 			text-decoration: none;
 		}
 
+		#datalynk-login .login-forgot {
+			display: block;
+			text-align: left;
+			margin-bottom: 0.75rem;
+			color: var(--theme-text);
+			font-size: 14px;
+			text-decoration: none;
+		}
+
+		#datalynk-login .login-forgot:hover {
+			text-decoration: underline;
+		}
+
+		#datalynk-login .password-wrapper {
+			position: relative;
+		}
+
+		#datalynk-login .password-toggle {
+			position: absolute;
+			right: 30px;
+			top: 50%;
+			transform: translateY(-50%);
+			background: none;
+			border: none;
+			padding: 0;
+			color: #333;
+			cursor: pointer;
+		}
+
 		#datalynk-login #pwa-install-link {
 			display: inline-flex;
 			align-items: center;
@@ -2061,7 +1484,6 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 			</div>
 			<div class="login-content">
 				<div class="login-body" style="max-width: 300px">
-					<div id="datalynk-login-alert" class="hidden"></div>
 					<form id="datalynk-login-form">
 						<div>
 							<label for="username">Email or Username</label>
@@ -2070,12 +1492,19 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 						<br>
 						<div>
 							<label for="password">Password</label>
-							<input id="password" name="password" type="password" autocomplete="current-password">
+							<div class="password-wrapper">
+								<input id="password" name="password" type="password" autocomplete="current-password">
+								<button type="button" id="datalynk-password-toggle" class="password-toggle" tabindex="-1">
+									<svg xmlns="http://www.w3.org/2000/svg" height="20px" viewBox="0 0 24 24" width="20px" fill="currentColor"><path d="M12 4.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5zm0 12.5c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5zm0-8a3 3 0 100 6 3 3 0 000-6z"/></svg>
+								</button>
+							</div>
 						</div>
+						<a href="#" id="datalynk-login-forgot" class="login-forgot hidden">Forgot Password?</a>
 						<br>
 						<label style="display: block; margin-bottom: 0.75rem;">
 							<input type="checkbox" name="persist" style="width: 20px"> Stay Logged In
 						</label>
+						<div id="datalynk-login-alert" class="hidden"></div>
 						<button type="submit">Login</button>
 					</form>
 				</div>
@@ -2116,7 +1545,12 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       this.api = api;
       this.api.token$.subscribe(async (token) => {
         if (token === void 0) return;
-        this.user = await this.current(token);
+        try {
+          this.user = await this.current(token);
+        } catch (error) {
+          if (this.api.status === "unauthorized") this.user = null;
+          else console.error("Unable to refresh the current Datalynk user", error);
+        }
       });
       if ((_a = this.api.options.offline) == null ? void 0 : _a.length)
         this.user$.pipe(filter((u) => u !== void 0)).subscribe((u) => localStorage.setItem("datalynk-user", JSON.stringify(u)));
@@ -2636,9 +2070,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         document.head.append(style);
       }
       const iconUrl = this.resolvedIconUrl || "https://datalynk-client.primary.auxilium.world/logo.png";
-      const prompt = document.createElement("div");
-      prompt.classList.add("pwa-prompt");
-      prompt.innerHTML = `
+      const prompt2 = document.createElement("div");
+      prompt2.classList.add("pwa-prompt");
+      prompt2.innerHTML = `
 			<div class="pwa-prompt-header">
 				<img src="${iconUrl}" alt="Logo" />
 				<h1>Install ${this.api.options.name}</h1>
@@ -2654,14 +2088,14 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 				${this.nativeInstallPrompt ? `<button id="installPwaBtn">Install App</button>` : stepsHtml}
 			</div>
 		`;
-      const closeBtn = prompt.querySelector(".pwa-prompt-close");
+      const closeBtn = prompt2.querySelector(".pwa-prompt-close");
       closeBtn.onclick = () => {
         var _a2;
         !!((_a2 = this.api.options.pwaSettings) == null ? void 0 : _a2.dismissExpiry) ? localStorage.setItem(storageKey, Date.now().toString()) : localStorage.removeItem(storageKey);
-        prompt.remove();
+        prompt2.remove();
       };
-      document.body.append(prompt);
-      const img = prompt.querySelector(".pwa-prompt-header img");
+      document.body.append(prompt2);
+      const img = prompt2.querySelector(".pwa-prompt-header img");
       if (img) img.onerror = () => img.src = "https://datalynk-client.primary.auxilium.world/logo.png";
       if (this.nativeInstallPrompt) this.bindInstallButton();
     }
@@ -3249,7 +2683,13 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     set cache(cache) {
       this.cache$.next(cache);
     }
-    /** Is slice offline support enabled */
+    /**
+     * Whether this slice has local IndexedDB/offline support enabled.
+     *
+     * Offline-enabled slices can fall back to their local cache when either the
+     * browser loses network connectivity or the Datalynk client enters an
+     * unavailable recovery state after a returned server/API failure.
+     */
     get offlineEnabled() {
       var _a;
       return (_a = this.api.database) == null ? void 0 : _a.includes(this.slice.toString());
@@ -3262,7 +2702,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       const onlineExec = call.exec.bind(call);
       return async () => {
         const offlineSupported = this.offlineEnabled && typeof navigator !== "undefined";
-        const offlineNow = offlineSupported && !(navigator == null ? void 0 : navigator.onLine);
+        const offlineNow = offlineSupported && (!this.api.online || !(navigator == null ? void 0 : navigator.onLine));
         const offlineSim = async () => {
           var _a, _b, _c;
           const where = (row, condition) => {
@@ -3561,24 +3001,39 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       return this.info;
     }
     /**
-     * Synchronize cache with server
+     * Synchronize the local slice cache with the server and subscribe to socket changes.
+     *
+     * For an offline-enabled slice, synchronization failures caused by network or
+     * API unavailability are contained in the background rather than becoming
+     * unhandled promise rejections. Local cached data remains usable while the
+     * {@link Api} recovery loop determines when the failed API path works again.
+     * When the client becomes online again, pending local changes are scheduled
+     * for upload without overlapping push operations.
+     *
+     * Calling `sync(false)` unsubscribes from slice socket events.
+     *
      * @example
      * ```ts
      * const slice: Slice = new Slice<T>(Slices.Contact);
-     * slice.sync().subscribe((rows: T[]) => {});
+     * const rows$ = slice.sync();
+     * rows$?.subscribe((rows: T[]) => console.log(rows));
      * ```
-     * @param {boolean} on Enable/disable events
-     * @return {BehaviorSubject<T[]>} Cache which can be subscribed to
+     * @param on Enable or disable synchronization/socket events.
+     * @returns The observable local cache when synchronization is enabled.
      */
     sync(on = true) {
       if (on) {
-        this.pushChanges().then(() => this.select().rows().exec().then((rows) => {
+        void this.pushChanges().then(() => this.select().rows().exec()).then((rows) => {
           this.cache = rows;
           this.loaded = true;
-        }));
+        }).catch((error) => {
+          if (this.api.online) console.warn("Unable to synchronize offline slice", error);
+        });
         if (!this.unsubscribe) this.unsubscribe = this.api.socket.sliceEvents(this.slice, (event) => {
           const ids = [...event.data.new, ...event.data.changed];
-          this.select(ids).rows().exec().then((rows) => this.cache = [...this.cache.filter((c) => c.id != null && !ids.includes(c.id)), ...rows]);
+          void this.select(ids).rows().exec().then((rows) => this.cache = [...this.cache.filter((c) => c.id != null && !ids.includes(c.id)), ...rows]).catch((error) => {
+            if (this.api.online) console.warn("Unable to refresh offline slice from socket event", error);
+          });
           this.cache = this.cache.filter((v) => v.id && !event.data.lost.includes(v.id));
         });
         return this.cache$;
@@ -3651,7 +3106,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       this.options = options;
       if (!options.url && options.url !== false) {
         const origin = new URL(this.api.url).origin;
-        this.options.url = origin.replace("http", "ws").replace(/:\d+/g, "") + `:9390`;
+        this.options.url = origin.replace("http", "ws").replace(/:\d+/g, "") + `/s/`;
       }
       if (this.options.url !== false)
         api.token$.pipe(filter((u) => u !== void 0), distinctUntilChanged()).subscribe(() => this.connect());
@@ -3774,7 +3229,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       } });
     }
   }
-  const version = "1.4.1";
+  const version = "1.5.1";
   class WebRtc {
     constructor(api) {
       __publicField(this, "ice");
@@ -4289,6 +3744,14 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   };
   __publicField(_Gps, "GPS_ACK_TIMEOUT_MS", 15e3);
   let Gps = _Gps;
+  class UnexpectedApiResponseError extends Error {
+    constructor(response, body) {
+      super(`Unexpected API response (${response.status} ${response.statusText})`);
+      this.response = response;
+      this.body = body;
+      this.name = "UnexpectedApiResponseError";
+    }
+  }
   const _Api = class _Api {
     /**
      * Connect to Datalynk & send requests
@@ -4312,8 +3775,16 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         target: "version.php",
         timeout: 6e4
       });
+      __publicField(this, "authenticationInvalid", false);
+      __publicField(this, "tokenExpiryTimeout", null);
+      /** Request-specific recovery after a server response proves an API call is broken. */
+      __publicField(this, "recovery", null);
+      /** Retry the failed request twice immediately, then this long after each failed recovery response. */
+      __publicField(this, "recoveryRetryInterval", 3e4);
+      __publicField(this, "recoveryImmediateRetries", 2);
       /** LocalStorage key for persisting logins */
       __publicField(this, "localStorageKey", "datalynk-token");
+      __publicField(this, "tokenStorageListener", null);
       /** Pending requests cache */
       __publicField(this, "pending", {});
       /** Helpers */
@@ -4344,18 +3815,33 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       /** Client library version */
       __publicField(this, "version", version);
       __publicField(this, "onlineOverride", false);
-      __publicField(this, "online$", new BehaviorSubject(typeof navigator == "undefined" || typeof navigator.onLine == "undefined" ? true : navigator.onLine));
+      __publicField(this, "initialOnline", typeof navigator == "undefined" || typeof navigator.onLine == "undefined" ? true : navigator.onLine);
+      /**
+       * Detailed API connection state.
+       *
+       * Subscribe to this when callers need to distinguish physical/network
+       * offline state from authentication failure or server/API unavailability.
+       */
+      __publicField(this, "status$", new BehaviorSubject(this.initialOnline ? "online" : "offline"));
+      /**
+       * Backwards-compatible boolean connection state.
+       *
+       * `false` includes `offline`, `unauthorized`, and `unavailable` states.
+       */
+      __publicField(this, "online$", new BehaviorSubject(this.initialOnline));
       /** API Session token */
       __publicField(this, "token$", new BehaviorSubject(void 0));
       var _a, _b;
       this.origin = origin;
       this.url = `${new URL(origin).origin}/api/`;
+      const development = this.isDevelopmentEnvironment(origin);
       this.options = {
         manifest: {},
         name: typeof document != "undefined" ? document.title : "Datalynk",
         offline: [],
         origin: typeof location !== "undefined" ? location.host : "Unknown",
         saveSession: true,
+        watchTokenExpiry: true,
         serviceWorker: "/service.worker.mjs",
         ...options,
         webrtc: {
@@ -4365,14 +3851,28 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           ...options.webrtc || {}
         }
       };
-      if (this.options.saveSession) {
-        if (typeof localStorage == "undefined") return;
+      if (development) this.options.watchTokenExpiry = false;
+      if (this.options.saveSession && typeof localStorage != "undefined") {
         this.token = localStorage.getItem(this.localStorageKey) || null;
         this.token$.pipe(distinctUntilChanged()).subscribe((token) => {
           if (token) localStorage.setItem(this.localStorageKey, token);
           else localStorage.removeItem(this.localStorageKey);
         });
+        if (typeof window != "undefined") {
+          this.tokenStorageListener = (event) => {
+            if (event.storageArea === localStorage && event.key == null) {
+              this.token = null;
+              return;
+            }
+            if (event.key !== this.localStorageKey || event.newValue === this.token) return;
+            if (event.newValue && this.canAdoptToken(event.newValue, this.token)) this.token = event.newValue;
+            else if (event.newValue == null) this.token = null;
+          };
+          window.addEventListener("storage", this.tokenStorageListener);
+        }
       }
+      if (this.options.watchTokenExpiry)
+        this.token$.pipe(distinctUntilChanged()).subscribe((token) => this.scheduleTokenExpiry(token));
       this.socket = new Socket(this, { url: options.socket });
       this.gps = new Gps(this, options.gps);
       this.auth = new Auth(this);
@@ -4395,12 +3895,10 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         });
       }
       if (typeof window !== "undefined") {
-        const handleOffline = (state = this.offline) => {
-          if (this.online != state) this.online$.next(state);
-        };
-        window.addEventListener("online", () => handleOffline(true));
-        window.addEventListener("offline", () => handleOffline(false));
+        window.addEventListener("online", () => this.checkConnection());
+        window.addEventListener("offline", () => this.setConnectionStatus("offline"));
         this.online$.subscribe(() => this.offlineBanner());
+        this.startHeartbeat();
       }
       if ((_a = this.options.offline) == null ? void 0 : _a.length) {
         this.pwa.setup();
@@ -4433,26 +3931,50 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     /** Get session info from JWT payload */
     get jwtPayload() {
       if (!this.token) return null;
-      return decodeJwt(this.token);
+      try {
+        return decodeJwt(this.token);
+      } catch {
+        return null;
+      }
+    }
+    /** Current detailed Datalynk API connection state. */
+    get status() {
+      return this.status$.getValue();
     }
-    /** Check if we are connected */
+    /**
+     * Whether normal Datalynk network requests are currently available.
+     *
+     * This becomes `false` for network outages, rejected/expired sessions, and
+     * request-owned server recovery. It therefore describes Datalynk
+     * availability rather than only `navigator.onLine`.
+     */
     get online() {
       return this.online$.getValue();
     }
+    /**
+     * Whether normal Datalynk API access is currently unavailable.
+     *
+     * This is the inverse of {@link online}. It can be `true` while the browser
+     * still has Internet access, for example during MySQL/HTTP 5xx recovery.
+     */
     get offline() {
       return !this.online;
     }
-    /** Override connection status */
+    /**
+     * Override the boolean connection state.
+     *
+     * Set `true` or `false` to force the corresponding state. Set `null` to
+     * remove the override and resume normal connection checking. This is a
+     * manual override and can supersede the current recovery state, so normal
+     * applications should generally observe {@link status} instead of forcing it.
+     */
     set online(value) {
       if (value == null) {
         this.onlineOverride = false;
-        this.online$.next(typeof navigator == "undefined" ? true : navigator.onLine);
+        this.checkConnection();
       } else {
         this.onlineOverride = true;
-        if (value == this.online) return;
-        this.online$.next(value);
-        if (value) this.startHeartbeat();
-        else this.stopHeartbeat();
+        this.setConnectionStatus(value ? "online" : "offline");
       }
     }
     /** Logged in spoke */
@@ -4464,56 +3986,285 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       return this.token$.getValue();
     }
     set token(token) {
+      if (this.recovery && token !== this.recovery.token)
+        this.cancelRecovery(errorFromCode(401, "Session changed during API recovery"));
+      if (token && this.isTokenExpired(token)) {
+        if (this.adoptStoredToken(token)) return;
+        this.authenticationInvalid = true;
+        this.token$.next(null);
+        this.setConnectionStatus("unauthorized");
+        return;
+      }
+      this.authenticationInvalid = false;
       this.token$.next(token);
+      if (token && !this.online && !this.recovery) {
+        const browserOnline = typeof navigator == "undefined" || typeof navigator.onLine == "undefined" || navigator.onLine;
+        this.setConnectionStatus(browserOnline ? "online" : "offline");
+      }
     }
-    _request(req, options = {}) {
+    async _request(req, options = {}) {
+      if (this.recovery) throw errorFromCode(503, "Datalynk is unavailable");
+      const retryRequest = deepCopy(req);
+      const retryOptions = { ...options };
       const token = options.token || this.token;
-      return fetch(this.url, {
-        method: "POST",
-        headers: clean({
-          Authorization: token ? `Bearer ${token}` : void 0,
-          "Content-Type": "application/json",
-          "X-Date-Return-Format": this.options.legacyDates ? void 0 : "ISO8601"
-        }),
-        body: JSON.stringify(_Api.translateTokens(req))
-      }).then(async (resp) => {
-        const warning = resp.headers["X-Warning"];
-        if (warning) console.warn(warning);
-        const banner = resp.headers["X-User-Notice"];
-        if (banner) {
-          createBanner(banner);
-          setTimeout(() => removeBanner(), 1e4);
+      try {
+        return await this._requestOnce(req, options, false);
+      } catch (error) {
+        if (!this.isRecoverableResponseError(error)) throw error;
+        this.beginRecovery(retryRequest, retryOptions, token);
+        throw error;
+      }
+    }
+    /** Execute exactly one HTTP API attempt. Recovery uses this directly to avoid recursive retry loops. */
+    async _requestOnce(req, options = {}, recoveryAttempt = false) {
+      const token = options.token || this.token;
+      if (token && this.isTokenExpired(token)) {
+        this.markUnauthorized(token);
+        throw errorFromCode(401, "Session token expired");
+      }
+      let resp;
+      try {
+        resp = await fetch(this.url, {
+          method: "POST",
+          headers: clean({
+            Authorization: token ? `Bearer ${token}` : void 0,
+            "Content-Type": "application/json",
+            "X-Date-Return-Format": this.options.legacyDates ? void 0 : "ISO8601"
+          }),
+          body: JSON.stringify(_Api.translateTokens(req))
+        });
+      } catch (error) {
+        this.setConnectionStatus("offline");
+        throw error;
+      }
+      const warning = resp.headers.get("X-Warning");
+      if (warning) console.warn(warning);
+      const banner = resp.headers.get("X-User-Notice");
+      if (banner) {
+        createBanner(banner);
+        setTimeout(() => removeBanner(), 1e4);
+      }
+      const body = await resp.text();
+      let data;
+      try {
+        data = JSON.parse(body);
+      } catch {
+        throw new UnexpectedApiResponseError(resp, body);
+      }
+      if (resp.status === 401) this.markUnauthorized(token);
+      if (!resp.ok || (data == null ? void 0 : data.error)) {
+        const error = Object.assign(errorFromCode(resp.status, data == null ? void 0 : data.error), data);
+        Object.defineProperty(error, "response", { value: resp, configurable: true });
+        if (!recoveryAttempt && resp.status < 500 && resp.status !== 401 && !this.isMysqlError(error))
+          this.setConnectionStatus("online");
+        throw error;
+      }
+      if (!options.raw) data = _Api.translateTokens(data);
+      if (!recoveryAttempt) this.setConnectionStatus("online");
+      return data;
+    }
+    /** Only server-response failures own global recovery; auth and ordinary 4xx errors do not. */
+    isRecoverableResponseError(error) {
+      var _a;
+      if (error instanceof UnexpectedApiResponseError) return true;
+      if ((error == null ? void 0 : error.code) === 401) return false;
+      const status = ((_a = error == null ? void 0 : error.response) == null ? void 0 : _a.status) ?? (error == null ? void 0 : error.code);
+      return status >= 500 || this.isMysqlError(error);
+    }
+    isMysqlError(error) {
+      const message = String((error == null ? void 0 : error.error) ?? (error == null ? void 0 : error.message) ?? "");
+      return /\bSQLSTATE\[[A-Z0-9]+\]/i.test(message);
+    }
+    /**
+     * A returned server failure immediately makes the client unavailable. The exact
+     * failed request is then retried twice back-to-back. After that, retries are
+     * scheduled 30 seconds after each completed failed attempt, never with overlap.
+     */
+    beginRecovery(req, options, token) {
+      if (this.recovery) return;
+      this.setConnectionStatus("unavailable");
+      this.recovery = {
+        request: deepCopy(req),
+        options: { ...options },
+        token,
+        timer: null,
+        running: false
+      };
+      void this.runImmediateRecovery();
+    }
+    async runImmediateRecovery() {
+      for (let attempt = 0; attempt < this.recoveryImmediateRetries; attempt++) {
+        const result = await this.tryRecoveryOnce();
+        if (result.ok) {
+          this.finishRecovery();
+          return;
         }
-        this.online = true;
-        let data = JSONAttemptParse(await resp.text());
-        if (!resp.ok || (data == null ? void 0 : data.error)) throw Object.assign(errorFromCode(resp.status, data.error), data);
-        if (!options.raw) data = _Api.translateTokens(data);
-        return data;
-      });
+        if (!this.recovery || this.status === "unauthorized") return;
+      }
+      if (this.recovery) this.scheduleRecovery();
+    }
+    async tryRecoveryOnce() {
+      const recovery = this.recovery;
+      if (!recovery) return { ok: false, error: errorFromCode(503, "API recovery was cancelled") };
+      if (recovery.running) return { ok: false, error: errorFromCode(503, "API recovery request is already running") };
+      if (recovery.token !== (recovery.options.token || this.token)) {
+        const error = errorFromCode(401, "Session changed during API recovery");
+        this.cancelRecovery(error);
+        return { ok: false, error };
+      }
+      recovery.running = true;
+      try {
+        const value = await this._requestOnce(
+          deepCopy(recovery.request),
+          { ...recovery.options, token: recovery.token || void 0 },
+          true
+        );
+        return { ok: true, value };
+      } catch (error) {
+        return { ok: false, error };
+      } finally {
+        if (this.recovery === recovery) recovery.running = false;
+      }
+    }
+    scheduleRecovery() {
+      const recovery = this.recovery;
+      if (!recovery) return;
+      if (recovery.timer) clearTimeout(recovery.timer);
+      recovery.timer = setTimeout(async () => {
+        const current = this.recovery;
+        if (!current || current !== recovery) return;
+        current.timer = null;
+        const result = await this.tryRecoveryOnce();
+        if (result.ok) {
+          this.finishRecovery();
+          return;
+        }
+        if (this.recovery && this.status !== "unauthorized") this.scheduleRecovery();
+      }, this.recoveryRetryInterval);
+    }
+    finishRecovery() {
+      const recovery = this.recovery;
+      if (!recovery) return;
+      if (recovery.timer) clearTimeout(recovery.timer);
+      this.recovery = null;
+      this.setConnectionStatus("online");
+    }
+    cancelRecovery(_error) {
+      const recovery = this.recovery;
+      if (!recovery) return;
+      if (recovery.timer) clearTimeout(recovery.timer);
+      this.recovery = null;
     }
     async checkConnection() {
+      if (this.recovery) return;
       if (typeof navigator != "undefined" && !navigator.onLine) {
-        this.online$.next(false);
+        this.setConnectionStatus("offline");
         return;
       }
       if (this.onlineOverride) return;
+      if (this.authenticationInvalid) {
+        this.setConnectionStatus("unauthorized");
+        return;
+      }
+      if (this.token && this.isTokenExpired(this.token)) {
+        this.markUnauthorized(this.token);
+        return;
+      }
       const controller = new AbortController();
       const timeout = setTimeout(() => controller.abort(), this.heartbeat.timeout);
       try {
         const response = await fetch(this.url + this.heartbeat.target, { signal: controller.signal });
-        this.online$.next(response.ok);
+        if (this.recovery) return;
+        this.setConnectionStatus(response.ok ? "online" : "unavailable");
       } catch (error) {
-        this.online$.next(false);
+        if (!this.recovery) this.setConnectionStatus("offline");
       } finally {
         clearTimeout(timeout);
       }
     }
+    isTokenExpired(token) {
+      var _a;
+      try {
+        return (((_a = decodeJwt(token)) == null ? void 0 : _a.exp) ?? 0) * 1e3 <= Date.now();
+      } catch {
+        return true;
+      }
+    }
+    isDevelopmentEnvironment(origin) {
+      var _a;
+      const isDevHost = (hostname) => {
+        hostname = hostname.toLowerCase();
+        return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname.endsWith(".datalynk") || hostname.endsWith(".test");
+      };
+      const configuredDev = typeof window != "undefined" && ((_a = window.dojoConfig) == null ? void 0 : _a.isDev) === true;
+      const pageHost = typeof location == "undefined" ? "" : location.hostname;
+      return configuredDev || isDevHost(new URL(origin).hostname) || !!pageHost && isDevHost(pageHost);
+    }
+    canAdoptToken(candidate, rejected) {
+      if (!candidate || candidate === rejected || this.isTokenExpired(candidate)) return false;
+      try {
+        const next = decodeJwt(candidate);
+        const previous = rejected ? decodeJwt(rejected) : null;
+        if ((previous == null ? void 0 : previous.realm) && (next == null ? void 0 : next.realm) && previous.realm !== next.realm) return false;
+        const previousUser = (previous == null ? void 0 : previous.uid) ?? (previous == null ? void 0 : previous.sub);
+        const nextUser = (next == null ? void 0 : next.uid) ?? (next == null ? void 0 : next.sub);
+        return previousUser == null || String(previousUser) === String(nextUser);
+      } catch {
+        return false;
+      }
+    }
+    /** Adopt a newer canonical token written by another auth path before expiring this session. */
+    adoptStoredToken(rejected) {
+      var _a;
+      if (!((_a = this.options) == null ? void 0 : _a.saveSession) || typeof localStorage == "undefined") return false;
+      const stored = localStorage.getItem(this.localStorageKey);
+      if (!stored || !this.canAdoptToken(stored, rejected)) return false;
+      this.token = stored;
+      return true;
+    }
+    scheduleTokenExpiry(token) {
+      var _a, _b, _c;
+      if (this.tokenExpiryTimeout) clearTimeout(this.tokenExpiryTimeout);
+      this.tokenExpiryTimeout = null;
+      if (!token) return;
+      let expiresAt = 0;
+      try {
+        expiresAt = (((_a = decodeJwt(token)) == null ? void 0 : _a.exp) ?? 0) * 1e3;
+      } catch {
+        if (!this.adoptStoredToken(token)) this.markUnauthorized(token);
+        return;
+      }
+      const delay = expiresAt - Date.now();
+      if (delay <= 0) {
+        if (!this.adoptStoredToken(token)) this.markUnauthorized(token);
+        return;
+      }
+      this.tokenExpiryTimeout = setTimeout(() => {
+        if (delay > 2147e6) this.scheduleTokenExpiry(token);
+        else if (!this.adoptStoredToken(token)) this.markUnauthorized(token);
+      }, Math.min(delay, 2147e6));
+      (_c = (_b = this.tokenExpiryTimeout) == null ? void 0 : _b.unref) == null ? void 0 : _c.call(_b);
+    }
+    markUnauthorized(token) {
+      if (token && token !== this.token) return;
+      if (this.adoptStoredToken(token)) return;
+      this.authenticationInvalid = true;
+      this.cancelRecovery(errorFromCode(401, "Session expired"));
+      if (this.token != null) this.token$.next(null);
+      this.setConnectionStatus("unauthorized");
+    }
+    setConnectionStatus(status) {
+      if (this.status !== status) this.status$.next(status);
+      const online = status === "online";
+      if (this.online !== online) this.online$.next(online);
+    }
     offlineBanner() {
       if (this.options.offlineBanner === false || typeof document == "undefined") return;
-      if (this.online) {
+      if (this.status === "online") {
         removeBanner("datalynk-offline-banner");
       } else {
-        createBanner("⚠️ You are offline, please reconnect to sync changes", {
+        const message = this.status === "unauthorized" ? "⚠️ Your session expired, please sign in again" : this.status === "unavailable" ? "⚠️ Datalynk is currently unavailable" : "⚠️ You are offline, please reconnect to sync changes";
+        createBanner(message, {
           id: "datalynk-offline-banner",
           position: this.options.offlineBanner === "top" ? "top" : "bottom"
         });
@@ -4625,9 +4376,13 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       var _a, _b;
       data = typeof data == "string" ? { [data]: {} } : data;
       let key = JSON.stringify(data);
-      if (this.offline) {
-        (_b = (_a = this.database) == null ? void 0 : _a.table("pending")) == null ? void 0 : _b.add(data, key);
-        return Promise.resolve();
+      if (this.offline && typeof navigator != "undefined") {
+        if (this.status === "unauthorized") return Promise.reject(errorFromCode(401, "Session expired"));
+        if (options.offline) {
+          (_b = (_a = this.database) == null ? void 0 : _a.table("pending")) == null ? void 0 : _b.add(data, key);
+          return Promise.resolve();
+        }
+        return Promise.reject(errorFromCode(503, this.status === "unavailable" ? "Datalynk is unavailable" : "You are offline"));
       }
       if (options.noOptimize) {
         return new Promise((res, rej) => {
@@ -4638,7 +4393,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       }
       if (!this.pending[key]) {
         this.pending[key] = new Promise((res, rej) => this.bundle.push({ data, res, rej }));
-        this.pending[key].catch().then(() => delete this.pending[key]);
+        this.pending[key].then(() => delete this.pending[key], () => delete this.pending[key]);
         if (!this.bundleOngoing) {
           this.bundleOngoing = true;
           setTimeout(() => {
@@ -4648,7 +4403,10 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
             data = originalBundle.map((row) => row.data);
             this._request(data, options).then((resp) => {
               if (!(resp instanceof Array)) resp = [resp];
-              resp.forEach((row, i) => (row == null ? void 0 : row.error) ? originalBundle[i].rej(row.error) : originalBundle[i].res(row));
+              originalBundle.forEach((request, index) => {
+                const row = resp[index];
+                (row == null ? void 0 : row.error) ? request.rej(row.error) : request.res(row);
+              });
             }).catch((err) => originalBundle.forEach((req) => req.rej(err)));
           }, this.options.bundleTime);
         }
@@ -4688,6 +4446,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   exports2.Slice = Slice;
   exports2.Socket = Socket;
   exports2.Superuser = Superuser;
+  exports2.UnexpectedApiResponseError = UnexpectedApiResponseError;
   exports2.getTheme = getTheme;
   Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
 });