memorio 4.6.7 → 4.6.9

package/index.cjs

@@ -0,0 +1,2244 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// core/internal.ts
+var state, internal, protect; exports.propertyName = void 0; exports.internal = void 0;
+var init_internal = __esm({
+  "core/internal.ts"() {
+    state = {
+      debug: false,
+      tracking: false,
+      trackedPaths: /* @__PURE__ */ new Set(),
+      locked: false,
+      lastAccessedPath: "",
+      stateVersion: 0,
+      currentContext: null
+    };
+    internal = {
+      get debug() {
+        return state.debug;
+      },
+      set debug(value) {
+        state.debug = value;
+      },
+      get tracking() {
+        return state.tracking;
+      },
+      set tracking(value) {
+        state.tracking = value;
+      },
+      get trackedPaths() {
+        return state.trackedPaths;
+      },
+      clearTrackedPaths() {
+        state.trackedPaths.clear();
+      },
+      get locked() {
+        return state.locked;
+      },
+      set locked(value) {
+        state.locked = value;
+      },
+      get lastAccessedPath() {
+        return state.lastAccessedPath;
+      },
+      set lastAccessedPath(value) {
+        state.lastAccessedPath = value;
+      },
+      get stateVersion() {
+        return state.stateVersion;
+      },
+      bumpStateVersion() {
+        state.stateVersion = (state.stateVersion || 0) + 1;
+        return state.stateVersion;
+      },
+      get currentContext() {
+        return state.currentContext;
+      },
+      set currentContext(value) {
+        state.currentContext = value;
+      }
+    };
+    protect = [
+      "list",
+      "state",
+      "store",
+      "idb",
+      "observer",
+      "useObserver",
+      "remove",
+      "removeAll",
+      // Platform-related protected keys
+      "_platform",
+      "_capabilities",
+      "_sessionId"
+    ];
+    exports.propertyName = (container, object) => {
+      const target = object !== void 0 ? object : container;
+      return String(target).replace("() => ", "");
+    };
+    exports.internal = internal;
+  }
+});
+
+// functions/message/index.ts
+exports.message = void 0; var message_default;
+var init_message = __esm({
+  "functions/message/index.ts"() {
+    init_internal();
+    exports.message = (...args) => {
+      if (exports.internal.debug === true) {
+        console.debug(...args);
+      }
+    };
+    message_default = exports.message;
+  }
+});
+
+// core/platform.ts
+function generateSessionId() {
+  const anyGlobal = globalThis;
+  if (typeof anyGlobal.crypto !== "undefined" && anyGlobal.crypto.randomUUID) {
+    return anyGlobal.crypto.randomUUID();
+  }
+  if (typeof anyGlobal.crypto !== "undefined" && anyGlobal.crypto.getRandomValues) {
+    const array = new Uint8Array(16);
+    anyGlobal.crypto.getRandomValues(array);
+    return Array.from(array, (b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  return `session_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+}
+function detectPlatform() {
+  const globalAny = globalThis;
+  if (globalAny.Deno && globalAny.Deno.version) {
+    return "deno";
+  }
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    return "node";
+  }
+  if (typeof globalThis !== "undefined" && typeof globalThis.ServiceWorkerGlobalScope !== "undefined") {
+    return "edge";
+  }
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    return "browser";
+  }
+  return "unknown";
+}
+function isBrowser() {
+  const platform = detectPlatform();
+  return platform === "browser";
+}
+function isNode() {
+  const platform = detectPlatform();
+  return platform === "node";
+}
+function isDeno() {
+  const platform = detectPlatform();
+  return platform === "deno";
+}
+function isEdge() {
+  const platform = detectPlatform();
+  return platform === "edge";
+}
+function getSessionStorage() {
+  try {
+    if (typeof sessionStorage !== "undefined") {
+      const testKey = "__memorio_test__";
+      sessionStorage.setItem(testKey, "1");
+      sessionStorage.removeItem(testKey);
+      return sessionStorage;
+    }
+  } catch (_) {
+  }
+  return null;
+}
+function getLocalStorage() {
+  try {
+    if (typeof localStorage !== "undefined") {
+      const testKey = "__memorio_test__";
+      localStorage.setItem(testKey, "1");
+      localStorage.removeItem(testKey);
+      return localStorage;
+    }
+  } catch (_) {
+  }
+  return null;
+}
+function hasIndexedDB() {
+  if (typeof indexedDB !== "undefined") {
+    return true;
+  }
+  return false;
+}
+function hasDispatchEvent() {
+  return typeof globalThis.dispatchEvent === "function";
+}
+function getCapabilities() {
+  const platform = detectPlatform();
+  const isSecure = typeof globalThis.isSecureContext !== "undefined" ? globalThis.isSecureContext : platform === "browser";
+  return {
+    platform,
+    hasSessionStorage: getSessionStorage() !== null,
+    hasLocalStorage: getLocalStorage() !== null,
+    hasIndexedDB: hasIndexedDB(),
+    hasDispatchEvent: hasDispatchEvent(),
+    hasNavigator: typeof navigator !== "undefined",
+    hasProcess: typeof process !== "undefined",
+    isSecureContext: isSecure,
+    sessionId: generateSessionId()
+  };
+}
+function initializePlatform() {
+  const capabilities = getCapabilities();
+  const anyGlobal = globalThis;
+  if (!capabilities.hasDispatchEvent) {
+    anyGlobal.dispatchEvent = function(_event) {
+      return true;
+    };
+    if (typeof CustomEvent === "undefined") {
+      anyGlobal.CustomEvent = class CustomEvent {
+        type;
+        detail;
+        constructor(type, detail = {}) {
+          this.type = type;
+          this.detail = detail;
+        }
+      };
+    }
+  }
+  if (typeof anyGlobal.addEventListener !== "function") {
+    anyGlobal.addEventListener = function(type, listener) {
+      if (!_eventListenerStorage.has(type)) {
+        _eventListenerStorage.set(type, []);
+      }
+      _eventListenerStorage.get(type).push(listener);
+    };
+    anyGlobal.removeEventListener = function(type, listener) {
+      const listeners = _eventListenerStorage.get(type);
+      if (listeners) {
+        const index = listeners.indexOf(listener);
+        if (index > -1) {
+          listeners.splice(index, 1);
+        }
+      }
+    };
+    anyGlobal.dispatchEvent = function(event) {
+      const listeners = _eventListenerStorage.get(event.type);
+      if (listeners) {
+        listeners.forEach((listener) => {
+          try {
+            listener(event);
+          } catch (e) {
+            console.error("Event listener error:", e);
+          }
+        });
+      }
+      return true;
+    };
+  }
+}
+function createContext(name) {
+  const contextId = name || `context_${generateSessionId()}`;
+  setCurrentContext(contextId);
+  const contextStorage = {
+    state: {},
+    store: /* @__PURE__ */ new Map(),
+    session: /* @__PURE__ */ new Map(),
+    cache: /* @__PURE__ */ new Map()
+  };
+  _contexts.set(contextId, contextStorage);
+  return {
+    id: contextId,
+    state: contextStorage.state,
+    store: {
+      get: (key) => {
+        const data = contextStorage.store.get(key);
+        return data ? JSON.parse(data) : null;
+      },
+      set: (key, value) => {
+        contextStorage.store.set(key, JSON.stringify(value));
+      },
+      remove: (key) => contextStorage.store.delete(key),
+      removeAll: () => contextStorage.store.clear(),
+      clearAll: () => contextStorage.store.clear(),
+      size: () => contextStorage.store.size,
+      isPersistent: false
+    },
+    session: {
+      get: (key) => {
+        const data = contextStorage.session.get(key);
+        return data ? JSON.parse(data) : null;
+      },
+      set: (key, value) => {
+        contextStorage.session.set(key, JSON.stringify(value));
+      },
+      remove: (key) => contextStorage.session.delete(key),
+      removeAll: () => contextStorage.session.clear(),
+      clearAll: () => contextStorage.session.clear(),
+      size: () => contextStorage.session.size,
+      isPersistent: false
+    },
+    cache: {
+      get: (key) => contextStorage.cache.get(key),
+      set: (key, value) => contextStorage.cache.set(key, value),
+      remove: (key) => contextStorage.cache.delete(key),
+      removeAll: () => contextStorage.cache.clear(),
+      clear: () => contextStorage.cache.clear()
+    }
+  };
+}
+function listContexts() {
+  return Array.from(_contexts.keys());
+}
+function deleteContext(id) {
+  return _contexts.delete(id);
+}
+function setCurrentContext(id) {
+  exports.internal.currentContext = id;
+}
+var _eventListenerStorage, _contexts;
+var init_platform = __esm({
+  "core/platform.ts"() {
+    init_internal();
+    _eventListenerStorage = /* @__PURE__ */ new Map();
+    _contexts = /* @__PURE__ */ new Map();
+  }
+});
+
+// functions/idb/tools/db.create.ts
+var db_create_exports = {};
+var init_db_create = __esm({
+  "functions/idb/tools/db.create.ts"() {
+    init_idb();
+    init_message();
+    exports.idb.db.create = (dbName, ver = 1) => {
+      return new Promise((resolve, reject) => {
+        if (!exports.idb.db.support()) {
+          return reject(new Error("IndexedDB not supported"));
+        }
+        const request = globalThis.indexedDB.open(dbName, ver);
+        request.onerror = () => {
+          message_default(`IndexedDB error: ${request.error?.message}`);
+          reject(request.error);
+        };
+        request.onsuccess = () => {
+          message_default(`Database ${dbName} connected successfully`);
+          resolve(request.result);
+        };
+        request.onupgradeneeded = () => {
+          message_default(`Database ${dbName} upgrade/creation initiated`);
+        };
+      });
+    };
+  }
+});
+
+// functions/idb/tools/db.list.ts
+var db_list_exports = {};
+var init_db_list = __esm({
+  "functions/idb/tools/db.list.ts"() {
+    init_idb();
+    exports.idb.db.list = async () => {
+      if (!("indexedDB" in globalThis) || !indexedDB.databases) return [];
+      try {
+        const result = await indexedDB.databases();
+        globalThis.idbases = result || [];
+        await exports.idb.db.size();
+        return globalThis.idbases;
+      } catch (err) {
+        console.error("Error listing databases:", err);
+        return [];
+      }
+    };
+  }
+});
+
+// functions/idb/tools/db.exist.ts
+var db_exist_exports = {};
+var init_db_exist = __esm({
+  "functions/idb/tools/db.exist.ts"() {
+    init_idb();
+    exports.idb.db.exist = (storeName) => {
+      return idbases?.some((db) => db.name === storeName);
+    };
+  }
+});
+
+// functions/idb/tools/db.quota.ts
+var db_quota_exports = {};
+var init_db_quota = __esm({
+  "functions/idb/tools/db.quota.ts"() {
+    init_idb();
+    exports.idb.db.quota = () => {
+      return navigator.storage.estimate();
+    };
+  }
+});
+
+// functions/idb/tools/db.delete.ts
+var db_delete_exports = {};
+var init_db_delete = __esm({
+  "functions/idb/tools/db.delete.ts"() {
+    init_idb();
+    init_message();
+    exports.idb.db.delete = (storeName) => {
+      return new Promise((resolve, reject) => {
+        message_default(`Removing database ${storeName}...`);
+        const performDelete = () => {
+          const request = indexedDB.deleteDatabase(storeName);
+          request.onsuccess = () => {
+            message_default(`${storeName} database removed successfully`);
+            exports.idb.db.list();
+            resolve();
+          };
+          request.onerror = () => {
+            console.error(`Error removing ${storeName}:`, request.error);
+            reject(request.error);
+          };
+          request.onblocked = () => {
+            console.warn(`Deletion of ${storeName} is blocked. Please close other tabs.`);
+          };
+        };
+        performDelete();
+      });
+    };
+  }
+});
+
+// functions/idb/tools/db.size.ts
+var db_size_exports = {};
+var init_db_size = __esm({
+  "functions/idb/tools/db.size.ts"() {
+    init_idb();
+    init_message();
+    exports.idb.db.size = async () => {
+      if (!idbases || idbases.length === 0) return;
+      for (let i = 0; i < idbases.length; i++) {
+        const dbInfo = idbases[i];
+        try {
+          const db = await exports.idb.db.create(dbInfo.name, dbInfo.version);
+          const tableNames = Array.from(db.objectStoreNames);
+          let totalDbSize = 0;
+          for (const tableName of tableNames) {
+            const tableSize = await exports.idb.table.size(db, tableName);
+            totalDbSize += tableSize;
+          }
+          dbInfo.size = totalDbSize;
+          db.close();
+        } catch (err) {
+          message_default(`Could not calculate size for ${dbInfo.name}:${err}`);
+        }
+      }
+    };
+  }
+});
+
+// functions/idb/tools/db.version.ts
+var db_version_exports = {};
+var init_db_version = __esm({
+  "functions/idb/tools/db.version.ts"() {
+    init_idb();
+    exports.idb.db.version = (storeName) => {
+      let idbVer = 0;
+      for (const v of idbases) {
+        if (v.name === storeName) idbVer = v.version;
+        break;
+      }
+      return idbVer;
+    };
+  }
+});
+
+// functions/idb/tools/db.support.ts
+var db_support_exports = {};
+var init_db_support = __esm({
+  "functions/idb/tools/db.support.ts"() {
+    init_idb();
+    init_message();
+    exports.idb.db.support = () => {
+      const isSupported = "indexedDB" in globalThis;
+      if (!isSupported) {
+        message_default("Your environment doesn't support IndexedDB");
+      }
+      return isSupported;
+    };
+  }
+});
+
+// functions/idb/tools/table.create.ts
+var table_create_exports = {};
+var init_table_create = __esm({
+  "functions/idb/tools/table.create.ts"() {
+    init_idb();
+    init_message();
+    exports.idb.table.create = (dbName, dbTable) => {
+      return new Promise((resolve, reject) => {
+        try {
+          const currentVersion = Number(exports.idb.db.version(dbName)) || 0;
+          const nextVersion = currentVersion + 1;
+          const request = indexedDB.open(dbName, nextVersion);
+          request.onupgradeneeded = (e) => {
+            const db = e.target.result;
+            if (!db.objectStoreNames.contains(dbTable)) {
+              const store2 = db.createObjectStore(dbTable, {
+                keyPath: "id",
+                autoIncrement: true
+              });
+              store2.createIndex("id", "id", { unique: true });
+              store2.createIndex("data", "data", { unique: false });
+              message_default(`Table ${dbTable} created in ${dbName}`);
+            }
+          };
+          request.onsuccess = () => {
+            request.result.close();
+            exports.idb.db.list();
+            resolve();
+          };
+          request.onerror = () => {
+            console.error(`Error creating table ${dbTable}:`, request.error);
+            reject(request.error);
+          };
+        } catch (err) {
+          console.error("Critical error in table.create:", err);
+          reject(err);
+        }
+      });
+    };
+  }
+});
+
+// functions/idb/tools/table.size.ts
+var table_size_exports = {};
+var init_table_size = __esm({
+  "functions/idb/tools/table.size.ts"() {
+    init_idb();
+    init_message();
+    exports.idb.table.size = (db, table) => {
+      return new Promise((resolve, reject) => {
+        if (!db) return reject(new Error("Database instance is required"));
+        if (!db.objectStoreNames.contains(table)) return resolve(0);
+        let size = 0;
+        let count = 0;
+        const transaction = db.transaction([table], "readonly");
+        const store2 = transaction.objectStore(table);
+        const request = store2.openCursor();
+        request.onsuccess = async (event) => {
+          const cursor = event.target.result;
+          if (cursor) {
+            try {
+              const value = cursor.value;
+              size += JSON.stringify(value).length;
+            } catch (err) {
+              message_default(`Error stringifying IDB value tracking size:${err}`);
+            }
+            count++;
+            if (count % 200 === 0) {
+              await new Promise((resolve2) => setTimeout(resolve2, 0));
+            }
+            cursor.continue();
+          } else {
+            resolve(size);
+          }
+        };
+        request.onerror = () => {
+          reject(request.error);
+        };
+      });
+    };
+  }
+});
+
+// functions/idb/crud/data.delete.ts
+var data_delete_exports = {};
+var init_data_delete = __esm({
+  "functions/idb/crud/data.delete.ts"() {
+    init_idb();
+    init_message();
+    exports.idb.data.delete = (storeName, table, key) => {
+      return new Promise((resolve, reject) => {
+        const request = indexedDB.open(storeName);
+        request.onsuccess = () => {
+          const db = request.result;
+          if (!db.objectStoreNames.contains(table)) {
+            db.close();
+            return reject(new Error(`Table ${table} not found`));
+          }
+          const transaction = db.transaction(table, "readwrite");
+          const objectStore = transaction.objectStore(table);
+          const deleteRequest = objectStore.delete(key);
+          deleteRequest.onsuccess = () => {
+            db.close();
+            message_default(`Record ${key} deleted from ${table}`);
+            resolve();
+          };
+          deleteRequest.onerror = () => {
+            db.close();
+            reject(deleteRequest.error);
+          };
+        };
+        request.onerror = () => reject(request.error);
+      });
+    };
+    exports.idb.data.delete.all = (storeName, table) => {
+      return new Promise((resolve, reject) => {
+        const request = indexedDB.open(storeName);
+        request.onsuccess = (event) => {
+          const db = event.target.result;
+          if (!db.objectStoreNames.contains(table)) {
+            db.close();
+            return reject(new Error(`Table ${table} not found`));
+          }
+          const transaction = db.transaction(table, "readwrite");
+          const store2 = transaction.objectStore(table);
+          const clearRequest = store2.clear();
+          clearRequest.onsuccess = () => {
+            db.close();
+            message_default(`All data cleared from ${table}`);
+            resolve();
+          };
+          clearRequest.onerror = () => {
+            db.close();
+            reject(clearRequest.error);
+          };
+        };
+        request.onerror = () => reject(request.error);
+      });
+    };
+  }
+});
+
+// functions/idb/crud/data.set.ts
+var data_set_exports = {};
+var init_data_set = __esm({
+  "functions/idb/crud/data.set.ts"() {
+    init_idb();
+    init_message();
+    exports.idb.data.set = (storeName, table, value) => {
+      return new Promise((resolve, reject) => {
+        const request = indexedDB.open(storeName);
+        request.onsuccess = () => {
+          const db = request.result;
+          if (!db.objectStoreNames.contains(table)) {
+            db.close();
+            return reject(new Error(`Table ${table} does not exist in ${storeName}`));
+          }
+          const transaction = db.transaction(table, "readwrite");
+          const objectStore = transaction.objectStore(table);
+          const putRequest = objectStore.put(value);
+          putRequest.onsuccess = () => {
+            db.close();
+            message_default(`Data saved in ${storeName}.${table}`);
+            resolve(putRequest.result);
+          };
+          putRequest.onerror = (_) => {
+            db.close();
+            message_default(`Database insert error: ${putRequest.error?.message}`);
+            reject(putRequest.error);
+          };
+        };
+        request.onerror = () => {
+          reject(request.error);
+        };
+      });
+    };
+  }
+});
+
+// functions/idb/crud/data.get.ts
+var data_get_exports = {};
+var init_data_get = __esm({
+  "functions/idb/crud/data.get.ts"() {
+    init_idb();
+    exports.idb.data.get = (storeName, table, key) => {
+      return new Promise((resolve, reject) => {
+        const request = indexedDB.open(storeName);
+        request.onsuccess = (event) => {
+          const db = event.target.result;
+          if (!db.objectStoreNames.contains(table)) {
+            db.close();
+            return reject(new Error(`Table ${table} not found in ${storeName}`));
+          }
+          const transaction = db.transaction(table, "readonly");
+          const store2 = transaction.objectStore(table);
+          const getRequest = store2.get(key);
+          getRequest.onsuccess = () => {
+            db.close();
+            resolve(getRequest.result);
+          };
+          getRequest.onerror = () => {
+            db.close();
+            reject(getRequest.error);
+          };
+        };
+        request.onerror = () => {
+          reject(request.error);
+        };
+      });
+    };
+  }
+});
+
+// functions/idb/index.ts
+var _hasIDB; exports.idb = void 0;
+var init_idb = __esm({
+  "functions/idb/index.ts"() {
+    init_platform();
+    _hasIDB = hasIndexedDB();
+    exports.idb = {
+      db: {},
+      table: {},
+      data: {}
+    };
+    if (_hasIDB) {
+      (async () => {
+        Object.defineProperty(exports.idb, "db", { value: {}, writable: true, configurable: true });
+        Object.defineProperty(exports.idb, "table", { value: {}, writable: true, configurable: true });
+        Object.defineProperty(exports.idb, "data", { value: {}, writable: true, configurable: true });
+        Object.defineProperty(globalThis, "idbases", {
+          value: [],
+          writable: true,
+          configurable: true,
+          enumerable: false
+        });
+        await Promise.all([
+          Promise.resolve().then(() => (init_db_create(), db_create_exports)),
+          Promise.resolve().then(() => (init_db_list(), db_list_exports)),
+          Promise.resolve().then(() => (init_db_exist(), db_exist_exports)),
+          Promise.resolve().then(() => (init_db_quota(), db_quota_exports)),
+          Promise.resolve().then(() => (init_db_delete(), db_delete_exports)),
+          Promise.resolve().then(() => (init_db_size(), db_size_exports)),
+          Promise.resolve().then(() => (init_db_version(), db_version_exports)),
+          Promise.resolve().then(() => (init_db_support(), db_support_exports)),
+          Promise.resolve().then(() => (init_table_create(), table_create_exports)),
+          Promise.resolve().then(() => (init_table_size(), table_size_exports)),
+          Promise.resolve().then(() => (init_data_delete(), data_delete_exports)),
+          Promise.resolve().then(() => (init_data_set(), data_set_exports)),
+          Promise.resolve().then(() => (init_data_get(), data_get_exports))
+        ]);
+        Object.preventExtensions(exports.idb);
+        Object.seal(exports.idb);
+        Object.freeze(exports.idb);
+      })();
+    } else {
+      exports.idb._disabled = true;
+      exports.idb._warning = "IndexedDB is not available in this environment (Node.js/Deno). Use store or session for persistence.";
+      console.warn("Memorio IDB: IndexedDB is not available in this environment. Use store or session for data persistence.");
+    }
+  }
+});
+
+// functions/state/index.ts
+init_internal();
+init_message();
+
+// core/dispatch.ts
+var dispatch = {
+  /**
+   * Dispatches a custom event with the specified name and value.
+   * @param name The name of the event.
+   * @param value The value to pass with the event.
+   */
+  set: (name, value = {}) => {
+    globalThis.dispatchEvent(new CustomEvent(String(name), value));
+  },
+  ///
+  /**
+   * Listens for the specified event names and executes the callback when the event is triggered.
+   * @param name The name of the event to listen for.
+   * @param cb The callback function to execute when the event is triggered.
+   */
+  listen: (name, cb = null, _flag) => {
+    if (globalThis.events?.[name]) return;
+    const exec = cb ? (e) => {
+      const target = e;
+      return globalThis.queueMicrotask ? globalThis.queueMicrotask(() => cb(target)) : Promise.resolve().then(() => cb(target));
+    } : void 0;
+    if (exec) globalThis.addEventListener(name, exec);
+    if (exec) globalThis.events[name] = exec;
+  },
+  ///
+  /**
+   * Removes the event listener for the specified event names.
+   * @param name The name of the event to remove the listener for.
+   */
+  remove: (name) => {
+    const listener = globalThis.events?.[name];
+    if (listener) {
+      globalThis.removeEventListener(name, listener);
+      delete globalThis.events[name];
+    }
+  }
+};
+
+// functions/state/index.ts
+var TARGET = Symbol("memorio.target");
+var wrapperCache = /* @__PURE__ */ new WeakMap();
+var deepRaw = (val, seen = null) => {
+  if (val === null || typeof val !== "object") return val;
+  if (val[TARGET] !== void 0) return deepRaw(val[TARGET], seen);
+  if (seen) {
+    if (seen.has(val)) return val;
+    seen.add(val);
+  }
+  const ctor = val.constructor?.name;
+  if (ctor !== "Object" && ctor !== "Array") return val;
+  const copy = Array.isArray(val) ? [] : {};
+  for (const k of Reflect.ownKeys(val)) {
+    copy[k] = deepRaw(val[k], seen);
+  }
+  return copy;
+};
+var objPath = (prop, object, separator = ".") => {
+  return object.concat(prop).join(separator);
+};
+var buildProxy = (obj, callback, tree = []) => {
+  const event = (name) => {
+    try {
+      dispatch.set(name, { detail: { name } });
+    } catch (_) {
+    }
+    return;
+  };
+  return new Proxy(
+    obj,
+    {
+      get(target, prop) {
+        if (prop === "__path") {
+          return tree.length > 0 ? "state." + tree.join(".") : "state";
+        }
+        if (prop === TARGET) {
+          return target;
+        }
+        if (target[TARGET] !== void 0) {
+          return target;
+        }
+        if (prop === "list") {
+          message_default('Some state could be hidden when you use "state.list". Use "state" to see the complete list ');
+          return JSON.parse(JSON.stringify(target));
+        }
+        if (typeof prop === "string") {
+          const path = tree.length > 0 ? "state." + tree.concat(prop).join(".") : "state." + prop;
+          exports.internal.lastAccessedPath = path;
+          if (exports.internal.tracking) {
+            exports.internal.trackedPaths.add(path);
+          }
+        }
+        if (prop === "_lastPath") {
+          return exports.internal.lastAccessedPath;
+        }
+        if (prop === "remove") {
+          return (key) => {
+            delete target[key];
+            return true;
+          };
+        }
+        if (prop === "removeAll") {
+          return () => {
+            try {
+              for (const key in target) {
+                if (typeof target[key] !== "function" && !["list", "remove", "removeAll", "lock", "unlock"].includes(key)) {
+                  delete target[key];
+                }
+              }
+            } catch (error) {
+              console.error(error);
+            }
+            return;
+          };
+        }
+        if (Object.isFrozen(target[prop])) return target[prop];
+        if (prop === "lock" || prop === "unlock") {
+          const value = Reflect.get(target, prop);
+          if (value) return value;
+        }
+        try {
+          const value = Reflect.get(target, prop);
+          if (value && typeof value === "object" && ["Array", "Object"].includes(value.constructor.name)) {
+            let wrapper = wrapperCache.get(value);
+            if (!wrapper) {
+              wrapper = buildProxy(value, callback, tree.concat(prop));
+              wrapperCache.set(value, wrapper);
+            }
+            return wrapper;
+          }
+          return value;
+        } catch (error) {
+          console.error("Error: ", error);
+          return void 0;
+        }
+      },
+      set(target, key, value) {
+        if (exports.internal.locked) {
+          console.error("Error: state is locked. Use state.unlock() to enable modifications.");
+          return false;
+        }
+        if (protect.includes(key)) {
+          console.error("key " + key + " is protected");
+          return false;
+        }
+        if (target[key] && typeof target[key] === "object" && Object.isFrozen(target[key])) {
+          console.error(`Error: state '${key}' is locked`);
+          return false;
+        }
+        if (target[key] && typeof target[key] === "object" && target[key].__locked) {
+          console.error(`Error: state '${key}' is locked. Use state.${key}.unlock() to enable modifications.`);
+          return false;
+        }
+        try {
+          const path = objPath(key, tree);
+          const rawValue = deepRaw(value);
+          callback(
+            {
+              action: "set",
+              path,
+              target,
+              newValue: rawValue,
+              previousValue: Reflect.get(target, key)
+            }
+          );
+          event("state." + path);
+          Reflect.set(target, key, rawValue);
+          exports.internal.bumpStateVersion();
+          if (target[key] && typeof target[key] === "object") {
+            const lockValue = target[key];
+            if (lockValue && typeof lockValue === "object") {
+              try {
+                Object.defineProperty(lockValue, "__locked", {
+                  writable: true,
+                  enumerable: false,
+                  configurable: false,
+                  value: false
+                });
+                Object.defineProperty(lockValue, "lock", {
+                  writable: false,
+                  enumerable: false,
+                  configurable: false,
+                  value: () => {
+                    Object.defineProperty(lockValue, "__locked", {
+                      writable: true,
+                      enumerable: false,
+                      configurable: false,
+                      value: true
+                    });
+                    message_default(`State '${key}' is now locked.`);
+                  }
+                });
+                Object.defineProperty(lockValue, "unlock", {
+                  writable: false,
+                  enumerable: false,
+                  configurable: false,
+                  value: () => {
+                    Object.defineProperty(lockValue, "__locked", {
+                      writable: true,
+                      enumerable: false,
+                      configurable: false,
+                      value: false
+                    });
+                    message_default(`State '${key}' is now unlocked.`);
+                  }
+                });
+              } catch (_) {
+              }
+            }
+          }
+          return true;
+        } catch (error) {
+          console.error("Error in set trap:", error);
+          return false;
+        }
+      },
+      deleteProperty(target, prop) {
+        try {
+          const path = objPath(prop, tree);
+          callback({ action: "delete", path, target });
+          return Reflect.deleteProperty(target, prop);
+        } catch (error) {
+          console.error("Error in deleteProperty trap:", error);
+          return false;
+        }
+      },
+      ownKeys(target) {
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        return Reflect.getOwnPropertyDescriptor(target, prop);
+      }
+    }
+  );
+};
+var state2 = buildProxy({}, () => {
+});
+state2.lock = () => {
+  exports.internal.locked = true;
+  message_default("State is now locked. All modifications are blocked.");
+};
+state2.unlock = () => {
+  exports.internal.locked = false;
+  message_default("State is now unlocked. Modifications are allowed.");
+};
+
+// functions/store/index.ts
+init_platform();
+init_internal();
+init_message();
+var _localStorage = getLocalStorage();
+var _fallbackStorageByContext = /* @__PURE__ */ new Map();
+function _getFallbackStorage() {
+  const contextName = exports.internal.currentContext || "";
+  const key = contextName || "default";
+  if (!_fallbackStorageByContext.has(key)) {
+    _fallbackStorageByContext.set(key, /* @__PURE__ */ new Map());
+  }
+  return _fallbackStorageByContext.get(key);
+}
+var _hasStorage = _localStorage !== null;
+function _getPrefix() {
+  const contextName = exports.internal.currentContext || "";
+  return contextName ? `${contextName}-` : `memorio_store_`;
+}
+function _prefixKey(name) {
+  if (!name || typeof name !== "string") {
+    console.warn(`[memorio store] key is empty or not a string \u2014 operation aborted`);
+    return "";
+  }
+  if (name.length > 512) {
+    console.warn(`[memorio store] key "${name}" exceeds 512 chars \u2014 operation aborted`);
+    return "";
+  }
+  return _getPrefix() + name;
+}
+function _read(prefixedName) {
+  const raw = _hasStorage ? _localStorage.getItem(prefixedName) : _getFallbackStorage().get(prefixedName);
+  return raw ? JSON.parse(raw) : raw;
+}
+function _write(prefixedName, value) {
+  const json = JSON.stringify(value);
+  if (_hasStorage) _localStorage.setItem(prefixedName, json);
+  else _getFallbackStorage().set(prefixedName, json);
+}
+function _remove(prefixedName) {
+  if (_hasStorage) {
+    if (_localStorage.getItem(prefixedName)) {
+      _localStorage.removeItem(prefixedName);
+      return true;
+    }
+  } else if (_getFallbackStorage().has(prefixedName)) {
+    _getFallbackStorage().delete(prefixedName);
+    return true;
+  }
+  return false;
+}
+var store = new Proxy({}, {});
+Object.defineProperty(
+  globalThis,
+  "store",
+  {
+    value: store,
+    enumerable: false,
+    configurable: true
+  }
+);
+Object.defineProperties(
+  store,
+  {
+    /**
+     * Gets a value from storage.
+     * @param name The key to retrieve.
+     * @returns The parsed value or null if not found.
+     */
+    get: {
+      value: (name) => {
+        if (!name) {
+          console.warn("[memorio store] store.get() called with empty or null key \u2014 returning null");
+          return null;
+        }
+        try {
+          return _read(_prefixKey(name));
+        } catch (err) {
+          exports.message(`Error parsing store item '${name}': ${err}`);
+        }
+        return null;
+      }
+    },
+    getMultiple: {
+      value: (keys) => {
+        const result = {};
+        for (const key of keys) {
+          try {
+            const item = store.get(key);
+            if (item) result[key] = item;
+          } catch (err) {
+            console.debug(`[memorio store] getMultiple error for key "${key}":`, err);
+          }
+        }
+        return result;
+      }
+    },
+    /**
+     * Sets a value in storage.
+     * @param name The key to set.
+     * @param value The value to store (objects, arrays, primitives).
+     * @returns true if written, false if the key was rejected.
+     */
+    set: {
+      value: (name, value) => {
+        if (!name) {
+          console.warn("[memorio store] store.set() called with empty or null key \u2014 write aborted");
+          return false;
+        }
+        const prefixedName = _prefixKey(name);
+        if (!prefixedName) return false;
+        if (typeof value === "function") {
+          console.warn("[memorio store] functions are not storable \u2014 write aborted for key: " + name);
+          exports.message("Storing functions is not secure and is blocked for safety.");
+          return false;
+        }
+        try {
+          _write(prefixedName, value);
+        } catch (err) {
+          exports.message(`Error setting store item '${name}': ${err}`);
+          return false;
+        }
+        return true;
+      }
+    },
+    /**
+     * Removes a value from storage.
+     * @param name The key to remove.
+     * @returns True if removed, false if not found.
+     */
+    remove: {
+      value: (name) => {
+        if (!name) {
+          console.debug("[memorio store] store.remove() called with empty or null key \u2014 returning false");
+          return false;
+        }
+        const prefixedName = _prefixKey(name);
+        if (!prefixedName) return false;
+        try {
+          return _remove(prefixedName);
+        } catch (err) {
+          exports.message(`Error removing store item '${name}': ${err}`);
+        }
+        return false;
+      }
+    },
+    /**
+     * Alias for remove.
+     * @param name The key to delete.
+     */
+    delete: {
+      value: (name) => {
+        return store.remove(name);
+      }
+    },
+    /**
+     * Clears all memorio items from storage.
+     */
+    removeAll: {
+      value: () => {
+        if (_hasStorage) {
+          const keysToRemove = [];
+          for (let i = 0; i < _localStorage.length; i++) {
+            const key = _localStorage.key(i);
+            if (key?.startsWith(_getPrefix())) keysToRemove.push(key);
+          }
+          keysToRemove.forEach((key) => _localStorage.removeItem(key));
+        } else {
+          _getFallbackStorage().clear();
+        }
+        return true;
+      }
+    },
+    /**
+     * Alias for removeAll.
+     */
+    clearAll: {
+      value: () => {
+        store.removeAll();
+        return true;
+      }
+    },
+    /**
+     * Estimates storage quota usage.
+     * @returns Promise with [usage, quota].
+     */
+    quota: {
+      value: async () => {
+        return [0, 0];
+      }
+    },
+    /**
+     * Calculates total size of all memorio items (characters).
+     */
+    size: {
+      value: () => {
+        let totalSize = 0;
+        if (_hasStorage) {
+          Object.keys(_localStorage).forEach((key) => {
+            if (key.startsWith(_getPrefix())) {
+              const item = _localStorage.getItem(key);
+              if (item) totalSize += item.length;
+            }
+          });
+        } else {
+          _getFallbackStorage().forEach((value) => {
+            totalSize += value.length;
+          });
+        }
+        return totalSize;
+      }
+    },
+    /**
+     * Check if using real localStorage or fallback
+     */
+    isPersistent: {
+      get: () => _hasStorage
+    },
+    /**
+     * Get a list of all memorio store items.
+     */
+    list: {
+      value: () => {
+        const result = {};
+        try {
+          if (_hasStorage) {
+            for (let i = 0; i < _localStorage.length; i++) {
+              const key = _localStorage.key(i);
+              if (key?.startsWith(_getPrefix())) {
+                const cleanKey = key.replace(_getPrefix(), "");
+                const item = _localStorage.getItem(key);
+                if (item !== null) {
+                  try {
+                    result[cleanKey] = JSON.parse(item);
+                  } catch {
+                    result[cleanKey] = item;
+                  }
+                }
+              }
+            }
+          } else {
+            _getFallbackStorage().forEach((value, key) => {
+              if (key.startsWith(_getPrefix())) {
+                const cleanKey = key.replace(_getPrefix(), "");
+                try {
+                  result[cleanKey] = JSON.parse(value);
+                } catch {
+                  result[cleanKey] = value;
+                }
+              }
+            });
+          }
+        } catch (err) {
+          exports.message(`Error listing store items: ${err}`);
+        }
+        return result;
+      }
+    }
+  }
+);
+Object.freeze(store);
+
+// functions/session/index.ts
+init_platform();
+init_internal();
+init_message();
+var _sessionStorage = getSessionStorage();
+var _fallbackStorageByContext2 = /* @__PURE__ */ new Map();
+function _getFallbackStorage2() {
+  const contextName = exports.internal.currentContext || "";
+  const key = contextName || "default";
+  if (!_fallbackStorageByContext2.has(key)) {
+    _fallbackStorageByContext2.set(key, /* @__PURE__ */ new Map());
+  }
+  return _fallbackStorageByContext2.get(key);
+}
+var _hasStorage2 = _sessionStorage !== null;
+function _getPrefix2() {
+  const contextName = exports.internal.currentContext || "";
+  return contextName ? `${contextName}-` : `memorio_session_`;
+}
+function _prefixKey2(name) {
+  if (!name || typeof name !== "string") {
+    console.warn("[memorio session] key is empty or not a string \u2014 operation aborted");
+    return "";
+  }
+  if (name.length > 512) {
+    console.warn(`[memorio session] key "${name}" exceeds 512 chars \u2014 operation aborted`);
+    return "";
+  }
+  return _getPrefix2() + name;
+}
+function _read2(prefixedName) {
+  const raw = _hasStorage2 ? _sessionStorage.getItem(prefixedName) : _getFallbackStorage2().get(prefixedName);
+  return raw ? JSON.parse(raw) : raw;
+}
+function _write2(prefixedName, value) {
+  const json = JSON.stringify(value);
+  if (_hasStorage2) _sessionStorage.setItem(prefixedName, json);
+  else _getFallbackStorage2().set(prefixedName, json);
+}
+function _remove2(prefixedName) {
+  if (_hasStorage2) {
+    if (_sessionStorage.getItem(prefixedName)) {
+      _sessionStorage.removeItem(prefixedName);
+      return true;
+    }
+  } else if (_getFallbackStorage2().has(prefixedName)) {
+    _getFallbackStorage2().delete(prefixedName);
+    return true;
+  }
+  return false;
+}
+var session = new Proxy({}, {});
+Object.defineProperty(
+  globalThis,
+  "session",
+  {
+    value: session,
+    enumerable: false,
+    configurable: true
+  }
+);
+Object.defineProperties(
+  session,
+  {
+    /**
+     * Gets a value from storage.
+     * @param name The key to retrieve.
+     * @returns The parsed value or null if not found.
+     */
+    get: {
+      value: (name) => {
+        if (!name) {
+          console.warn("[memorio session] session.get() called with empty or null key \u2014 returning null");
+          return null;
+        }
+        try {
+          return _read2(_prefixKey2(name));
+        } catch (err) {
+          exports.message(`Error parsing session item '${name}':${err}`);
+        }
+        return null;
+      }
+    },
+    /**
+     * Sets a value in storage.
+     * @param name The key to set.
+     * @param value The value to store.
+     * @returns true if written, false if the key was rejected.
+     */
+    set: {
+      value: (name, value) => {
+        if (!name) {
+          console.warn("[memorio session] session.set() called with empty or null key \u2014 write aborted");
+          return false;
+        }
+        const prefixedName = _prefixKey2(name);
+        if (!prefixedName) return false;
+        if (typeof value === "function") {
+          console.warn("[memorio session] functions are not storable \u2014 write aborted for key: " + name);
+          exports.message("It's not secure to session functions.");
+          return false;
+        }
+        try {
+          _write2(prefixedName, value);
+        } catch (err) {
+          exports.message(`Error setting session item '${name}': ${err}`);
+          return false;
+        }
+        return true;
+      }
+    },
+    /**
+     * Removes a value from storage.
+     * @param name The key to remove.
+     * @returns True if removed.
+     */
+    remove: {
+      value: (name) => {
+        if (!name) {
+          console.warn("[memorio session] session.remove() called with empty or null key \u2014 returning false");
+          return false;
+        }
+        const prefixedName = _prefixKey2(name);
+        if (!prefixedName) return false;
+        try {
+          return _remove2(prefixedName);
+        } catch (err) {
+          exports.message(`Error removing session item '${name}': ${err}`);
+        }
+        return false;
+      }
+    },
+    /**
+     * Alias for remove.
+     * @param name The key to delete.
+     * @returns True if removed.
+     */
+    delete: {
+      value: (name) => {
+        return session.remove(name);
+      }
+    },
+    /**
+       * Clears all sessionStorage items.
+       */
+    removeAll: {
+      value: () => {
+        if (_hasStorage2) {
+          const keysToRemove = [];
+          for (let i = 0; i < _sessionStorage.length; i++) {
+            const key = _sessionStorage.key(i);
+            if (key?.startsWith(_getPrefix2())) {
+              keysToRemove.push(key);
+            }
+          }
+          keysToRemove.forEach((key) => _sessionStorage.removeItem(key));
+        } else {
+          _getFallbackStorage2().clear();
+        }
+        return true;
+      }
+    },
+    /**
+     * Alias for removeAll.
+     */
+    clearAll: {
+      value: () => {
+        session.removeAll();
+        return true;
+      }
+    },
+    quota: {
+      value: async () => {
+        return [0, 0];
+      }
+    },
+    /**
+     * Gets total size of all sessionStorage items.
+     * @returns Total size in characters.
+     */
+    size: {
+      value: () => {
+        let totalSize = 0;
+        if (_hasStorage2) {
+          Object.keys(_sessionStorage).forEach(
+            (key) => {
+              if (key.startsWith(_getPrefix2())) {
+                const item = _sessionStorage.getItem(key);
+                if (item) totalSize += item.length;
+              }
+            }
+          );
+        } else {
+          _getFallbackStorage2().forEach((value) => {
+            totalSize += value.length;
+          });
+        }
+        return totalSize;
+      }
+    },
+    /**
+     * Check if using real sessionStorage or fallback
+     */
+    isPersistent: {
+      get: () => _hasStorage2
+    },
+    /**
+     * Get a list of all memorio session items.
+     */
+    list: {
+      value: () => {
+        const result = {};
+        try {
+          if (_hasStorage2) {
+            for (let i = 0; i < _sessionStorage.length; i++) {
+              const key = _sessionStorage.key(i);
+              if (key?.startsWith(_getPrefix2())) {
+                const cleanKey = key.replace(_getPrefix2(), "");
+                const item = _sessionStorage.getItem(key);
+                if (item !== null) {
+                  try {
+                    result[cleanKey] = JSON.parse(item);
+                  } catch {
+                    result[cleanKey] = item;
+                  }
+                }
+              }
+            }
+          } else {
+            _getFallbackStorage2().forEach((value, key) => {
+              if (key.startsWith(_getPrefix2())) {
+                const cleanKey = key.replace(_getPrefix2(), "");
+                try {
+                  result[cleanKey] = JSON.parse(value);
+                } catch {
+                  result[cleanKey] = value;
+                }
+              }
+            });
+          }
+        } catch (err) {
+          exports.message(`Error listing session items: ${err}`);
+        }
+        return result;
+      }
+    }
+  }
+);
+Object.freeze(session);
+
+// functions/cache/index.ts
+var cacheData = {};
+var cache = new Proxy({}, {
+  get(target, prop) {
+    const key = prop;
+    if (key === "get") return (name) => cacheData[name];
+    if (key === "set") return (name, value) => {
+      cacheData[name] = value;
+    };
+    if (key === "remove") return (name) => {
+      delete cacheData[name];
+      return true;
+    };
+    if (key === "removeAll") return () => {
+      Object.keys(cacheData).forEach((k) => delete cacheData[k]);
+      return true;
+    };
+    if (key === "clear") return () => {
+      Object.keys(cacheData).forEach((k) => delete cacheData[k]);
+      return true;
+    };
+    if (key === "list") return () => ({ ...cacheData });
+    return cacheData[key];
+  },
+  set(target, prop, value) {
+    cacheData[prop] = value;
+    return true;
+  },
+  deleteProperty(target, prop) {
+    delete cacheData[prop];
+    return true;
+  }
+});
+Object.freeze(cache);
+
+// index.ts
+init_idb();
+
+// functions/observer/index.ts
+init_message();
+var _deprecationShown = false;
+var observerFunction = (s, cb = null, option = true) => {
+  if (!_deprecationShown) {
+    console.warn('DEPRECATED: "observer" is deprecated and will be removed in future versions. Please use "useObserver" instead.');
+    _deprecationShown = true;
+  }
+  const resolvePath = (path2) => {
+    if (typeof path2 === "string") return path2;
+    if (path2 && typeof path2 === "object" && path2.__path) return path2.__path;
+    return null;
+  };
+  const path = resolvePath(s);
+  if (!s && !cb) {
+    console.error("Observer Error: You need to setup observer correctly, Some parameters are missed!");
+    return;
+  }
+  if (!s && cb) {
+    console.error(`Observer Error: You need to declare what state need to be monitored as string like 'state.test'.`);
+    return;
+  }
+  if (path) {
+    const t = path.split(".");
+    if (t[0] !== "state" && t[0] !== "store") {
+      console.error(`Observer Error: You need to declare 'state.' or 'store.'. The '${path}' string is incorrect!`);
+      return;
+    }
+  }
+  if (s && !cb) {
+    const resolvedPath = resolvePath(s);
+    if (!resolvedPath) return;
+    const obs = globalThis.observer;
+    if (obs?.list?.[resolvedPath]) dispatch.remove(resolvedPath);
+    message_default(`called: ${resolvedPath}`);
+    return;
+  }
+  if (s && cb) {
+    const resolvedPath = resolvePath(s);
+    if (!resolvedPath) return;
+    if (typeof s !== "string" && !(s && typeof s === "object")) {
+      console.error(`Observer Error: name of state need to be a 'string' like 'state.test' or a direct state value`);
+      return;
+    }
+    const callbacks = Array.isArray(cb) ? cb : [cb];
+    const obs = globalThis.observer;
+    if (obs?.list?.[resolvedPath]) dispatch.remove(resolvedPath);
+    callbacks.forEach((callback) => {
+      if (typeof callback === "function") {
+        dispatch.listen(resolvedPath, callback, option);
+      }
+    });
+    return;
+  }
+};
+var observer = observerFunction;
+Object.defineProperties(
+  observer,
+  {
+    /**
+     * See the list of all your observer (eventListener) actually installed.
+     * @returns The list of all installed observers.
+     */
+    list: {
+      get: () => globalThis.events
+    },
+    ///
+    /**
+     * Remove an observer.
+     * @param name The name of the observer to remove.
+     */
+    remove: {
+      value: (name) => {
+        if (!name) return;
+        dispatch.remove(name);
+        delete globalThis.events[name];
+        return;
+      }
+    },
+    ///
+    /**
+     * Remove all observers.
+     * @returns void
+     */
+    removeAll: {
+      get: () => {
+        const obs = globalThis.observer;
+        const list = obs?.list;
+        if (list) {
+          Object.keys(list).forEach((key) => {
+            obs?.remove?.(key);
+          });
+        }
+        return true;
+      }
+    },
+    ///
+    /**
+     * Check if an observer exists for the given path.
+     * @param name The state path to check.
+     * @returns true if an observer exists for the path, false otherwise.
+     */
+    has: {
+      value: (name) => {
+        const obs = globalThis.observer;
+        return !!obs?.list?.[name];
+      }
+    }
+  }
+);
+
+// functions/useObserver/index.ts
+init_message();
+init_internal();
+if (!globalThis.useObserver) globalThis.useObserver = null;
+Object.defineProperty(
+  globalThis,
+  "useObserver",
+  {
+    value: null,
+    writable: true,
+    enumerable: false,
+    configurable: true
+  }
+);
+var useObserver = ((func, deps = []) => {
+  if (!deps || typeof func !== "function") {
+    return () => {
+    };
+  }
+  const handlers = [];
+  const depList = Array.isArray(deps) && !deps.__path ? deps : [deps];
+  try {
+    depList.forEach((dep) => {
+      let t = "";
+      if (typeof dep === "function") {
+        const result = exports.propertyName(dep);
+        if (result) t = result;
+      } else if (typeof dep === "object" && dep !== null) {
+        t = dep.__path || (typeof dep.toString === "function" && dep.toString() !== "[object Object]" ? dep.toString() : "");
+      }
+      if (t) {
+        t = t.replace(/^(\(\)\s*=>\s*)/, "").replace(/^globalThis\./, "").replace(/^state\./, "");
+        const path = t.startsWith("store.") || t.startsWith("state.") ? t : "state." + t;
+        dispatch.listen(path, () => func());
+        handlers.push(path);
+      } else {
+        exports.internal.clearTrackedPaths();
+        exports.internal.tracking = true;
+        try {
+          func();
+        } catch (_) {
+        }
+        exports.internal.tracking = false;
+        exports.internal.trackedPaths.forEach((path) => {
+          if (!handlers.includes(path)) {
+            message_default(`useObserver: [Auto-Discovery] -> "${path}"`);
+            dispatch.listen(path, () => func());
+            handlers.push(path);
+          }
+        });
+      }
+    });
+    if (handlers.length > 0) {
+      message_default(`useObserver: Monitoring ${handlers.length} paths.`);
+    } else {
+      console.warn(`useObserver: No paths resolved for monitoring. Check your dependencies!`);
+    }
+    return () => {
+      handlers.forEach((path) => {
+        if (typeof dispatch.remove === "function") {
+          dispatch.remove(path);
+          message_default(`useObserver: Stopped monitoring "${path}"`);
+        }
+      });
+    };
+  } catch (err) {
+    message_default(`useObserver Error: ${err}`);
+    return () => {
+    };
+  }
+});
+globalThis.useObserver = useObserver;
+Object.freeze(globalThis.useObserver);
+
+// index.ts
+init_message();
+
+// functions/devtools/index.ts
+init_internal();
+function isDebugEnabled() {
+  return exports.internal.debug === true;
+}
+function extractStoreData() {
+  if (!globalThis.store) return {};
+  const result = {};
+  const store2 = globalThis.store;
+  if (typeof store2.list === "function") {
+    try {
+      return store2.list();
+    } catch {
+    }
+  }
+  if (typeof store2.get === "function") {
+    for (const key of Object.keys(store2)) {
+      if (!["get", "set", "remove", "delete", "removeAll", "clearAll", "size", "isPersistent", "list"].includes(key)) {
+        try {
+          const val = store2.get(key);
+          if (val !== null && val !== void 0) {
+            result[key] = val;
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  return result;
+}
+function extractSessionData() {
+  if (!globalThis.session) return {};
+  const result = {};
+  const session2 = globalThis.session;
+  if (typeof session2.list === "function") {
+    try {
+      return session2.list();
+    } catch {
+    }
+  }
+  if (typeof session2.get === "function") {
+    for (const key of Object.keys(session2)) {
+      if (!["get", "set", "remove", "delete", "removeAll", "clearAll", "size", "isPersistent", "list"].includes(key)) {
+        try {
+          const val = session2.get(key);
+          if (val !== null && val !== void 0) {
+            result[key] = val;
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  return result;
+}
+var inspect = () => {
+  if (!isDebugEnabled()) return;
+  if (globalThis.state) {
+    const stateList = globalThis.state.list;
+    let stateData;
+    if (typeof stateList === "function") {
+      stateData = stateList();
+    } else if (typeof stateList === "object" && stateList !== null) {
+      stateData = stateList;
+    } else {
+      stateData = globalThis.state;
+    }
+    console.table(stateData);
+  }
+  if (globalThis.store) {
+    console.table(extractStoreData());
+  }
+  if (globalThis.session) {
+    console.table(extractSessionData());
+  }
+  if (globalThis.cache) {
+    const cacheList = globalThis.cache.list;
+    let cacheData2;
+    if (typeof cacheList === "function") {
+      cacheData2 = cacheList();
+    } else if (typeof cacheList === "object" && cacheList !== null) {
+      cacheData2 = cacheList;
+    } else {
+      cacheData2 = globalThis.cache;
+    }
+    console.table(cacheData2);
+  }
+};
+var stats = () => {
+  const getKeys = (obj) => {
+    if (!obj) return 0;
+    if (typeof obj.list === "function") {
+      try {
+        const list = obj.list();
+        return Object.keys(list).length;
+      } catch {
+      }
+    }
+    return Object.keys(obj).length;
+  };
+  return {
+    stateKeys: getKeys(globalThis.state),
+    storeKeys: getKeys(globalThis.store),
+    sessionKeys: getKeys(globalThis.session),
+    cacheKeys: getKeys(globalThis.cache),
+    idbDatabases: 0,
+    lastUpdate: (/* @__PURE__ */ new Date()).toISOString()
+  };
+};
+var clear = (module) => {
+  if (globalThis[module] && typeof globalThis[module].clear === "function") {
+    globalThis[module].clear();
+  } else {
+    console.error(`Module ${module} not found or does not support clear()`);
+  }
+};
+var clearAll = () => {
+  clear("state");
+  clear("store");
+  clear("session");
+  clear("cache");
+};
+var exportData = () => {
+  const getStateData = () => {
+    if (!globalThis.state) return void 0;
+    try {
+      if (typeof globalThis.state.list === "function") {
+        return globalThis.state.list();
+      }
+      return globalThis.state;
+    } catch {
+      return void 0;
+    }
+  };
+  const getStoreData = () => {
+    return extractStoreData();
+  };
+  const getSessionData = () => {
+    return extractSessionData();
+  };
+  const getCacheData = () => {
+    if (!globalThis.cache) return void 0;
+    try {
+      if (typeof globalThis.cache.list === "function") {
+        return globalThis.cache.list();
+      }
+      return globalThis.cache;
+    } catch {
+      return void 0;
+    }
+  };
+  const data = {
+    state: getStateData(),
+    store: getStoreData(),
+    session: getSessionData(),
+    cache: getCacheData(),
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return JSON.stringify(data, null, 2);
+};
+var importData = (jsonString) => {
+  try {
+    const data = JSON.parse(jsonString);
+    if (data.state) {
+      Object.entries(data.state).forEach(([key, value]) => {
+        if (globalThis.state && key !== "list" && key !== "remove" && key !== "removeAll") {
+          ;
+          globalThis.state[key] = value;
+        }
+      });
+    }
+    if (data.store && globalThis.store && typeof globalThis.store.set === "function") {
+      Object.entries(data.store).forEach(([key, value]) => {
+        ;
+        globalThis.store.set(key, value);
+      });
+    }
+    if (data.session && globalThis.session && typeof globalThis.session.set === "function") {
+      Object.entries(data.session).forEach(([key, value]) => {
+        ;
+        globalThis.session.set(key, value);
+      });
+    }
+    if (data.cache && globalThis.cache) {
+      Object.entries(data.cache).forEach(([key, value]) => {
+        if (globalThis.cache && key !== "get" && key !== "set" && key !== "remove" && key !== "clear") {
+          ;
+          globalThis.cache[key] = value;
+        }
+      });
+    }
+  } catch (error) {
+    console.error("%c\u2717 Import failed:", "color: #F44336", error);
+  }
+};
+var watch = (module, path) => {
+  if (!globalThis[module]) {
+    console.error(`Module ${module} not found`);
+    return;
+  }
+  const target = globalThis[module];
+  const initialValue = target[path];
+  console.debug(`\u{1F441} Watching ${module}.${path} (initial: ${JSON.stringify(initialValue)})`);
+  if (module === "state" && globalThis.memorio?.dispatch) {
+    const handler = (e) => {
+      const detail = e.detail;
+      if (detail?.name?.includes(path)) {
+        console.debug(`\u{1F441} Change: ${module}.${path} =`, e.detail.value);
+      }
+    };
+    target.addEventListener?.("memorio-change", handler);
+  }
+};
+var help = () => {
+  console.debug(`
+\u{1F9E0} Memorio DevTools Help
+
+Available commands:
+  memorio.devtools.inspect()          - Inspect all state modules
+  memorio.devtools.stats()            - Show statistics
+  memorio.devtools.clear('module')    - Clear specific module
+  memorio.devtools.clearAll()         - Clear all modules
+  memorio.devtools.exportData()       - Export all data as JSON
+  memorio.devtools.importData(json)   - Import data from JSON
+  memorio.devtools.watch(module, path) - Watch a path for changes
+  memorio.devtools.help()             - Show this help
+
+Shortcuts:
+  state    - globalThis.state
+  store    - globalThis.store
+  session  - globalThis.session
+  cache    - globalThis.cache
+`);
+};
+var devtools = {
+  inspect,
+  stats,
+  clear,
+  clearAll,
+  exportData,
+  importData,
+  watch,
+  help
+};
+
+// functions/logger/index.ts
+init_internal();
+init_message();
+var defaultConfig = {
+  enabled: true,
+  logToConsole: true,
+  modules: ["state", "store", "session", "cache", "idb"],
+  maxEntries: 1e3
+};
+function isDebugEnabled2() {
+  return exports.internal.debug === true;
+}
+var config = { ...defaultConfig };
+var logHistory = [];
+var configure = (options) => {
+  config = { ...config, ...options };
+};
+var enable = () => {
+  config.enabled = true;
+};
+var disable = () => {
+  config.enabled = false;
+};
+var isEnabled = (module) => {
+  return config.enabled && config.modules.includes(module);
+};
+var log = (module, action, path, value, previousValue) => {
+  if (!isEnabled(module)) return;
+  const entry = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    module,
+    action,
+    path,
+    value,
+    previousValue
+  };
+  logHistory.push(entry);
+  if (logHistory.length > config.maxEntries) {
+    logHistory.shift();
+  }
+  if (config.logToConsole && isDebugEnabled2()) {
+    const prefix = `[Memorio:${module.toUpperCase()}]`;
+    const color = getModuleColor(module);
+    message_default(
+      `%c${prefix}%c ${action} ${path},
+      color: ${color}; font-weight: bold,
+      color: inherit`
+    );
+    if (value !== void 0) {
+      message_default(`  \u2192 value:${value}`);
+    }
+    if (previousValue !== void 0) {
+      message_default(`  \u2190 previous:${previousValue}`);
+    }
+  }
+  if (config.customHandler) {
+    config.customHandler(entry);
+  }
+};
+var getModuleColor = (module) => {
+  const colors = {
+    state: "#4CAF50",
+    store: "#2196F3",
+    session: "#FF9800",
+    cache: "#9C27B0",
+    idb: "#F44336"
+  };
+  return colors[module] || "#888888";
+};
+var getHistory = () => {
+  return [...logHistory];
+};
+var clearHistory = () => {
+  logHistory.length = 0;
+};
+var getStats = () => {
+  const stats2 = {
+    total: logHistory.length,
+    state: 0,
+    store: 0,
+    session: 0,
+    cache: 0,
+    idb: 0,
+    set: 0,
+    get: 0,
+    delete: 0,
+    clear: 0
+  };
+  for (const entry of logHistory) {
+    if (entry) {
+      const module = entry.module;
+      const action = entry.action;
+      if (module && typeof stats2[module] === "number") stats2[module]++;
+      if (action && typeof stats2[action] === "number") stats2[action]++;
+    }
+  }
+  return stats2;
+};
+var exportLogs = () => {
+  return JSON.stringify(logHistory, null, 2);
+};
+var logger = {
+  configure,
+  enable,
+  disable,
+  isEnabled,
+  log,
+  getHistory,
+  clearHistory,
+  getStats,
+  exportLogs
+};
+
+// index.ts
+init_internal();
+init_platform();
+
+// core/global.ts
+init_platform();
+init_internal();
+
+// package.json
+var package_default = {
+  version: "4.6.9"};
+
+// core/global.ts
+init_idb();
+init_message();
+Object.defineProperty(
+  globalThis,
+  "memorio",
+  {
+    value: {
+      setProps: () => {
+      },
+      obj: {},
+      array: [],
+      dispatch,
+      message: exports.message,
+      devtools,
+      logger,
+      setDescription: () => {
+      }
+    },
+    writable: false,
+    configurable: true,
+    enumerable: false
+  }
+);
+Object.defineProperty(
+  globalThis,
+  "events",
+  {
+    value: {},
+    writable: true,
+    enumerable: false
+  }
+);
+Object.defineProperty(
+  memorio,
+  "version",
+  {
+    writable: false,
+    enumerable: false,
+    value: package_default.version
+  }
+);
+Object.defineProperty(
+  memorio,
+  "debug",
+  {
+    get: () => exports.internal.debug,
+    set: (v) => {
+      exports.internal.debug = v;
+    },
+    enumerable: false
+  }
+);
+var caps = getCapabilities();
+Object.defineProperty(memorio, "_platform", { writable: false, enumerable: false, value: caps.platform });
+Object.defineProperty(memorio, "_capabilities", { writable: false, enumerable: false, value: caps });
+Object.defineProperty(memorio, "_sessionId", { writable: false, enumerable: false, value: generateSessionId() });
+initializePlatform();
+memorio.isBrowser = isBrowser;
+memorio.isNode = isNode;
+memorio.isDeno = isDeno;
+memorio.isEdge = isEdge;
+memorio.getCapabilities = getCapabilities;
+memorio.createContext = createContext;
+memorio.listContexts = listContexts;
+memorio.deleteContext = deleteContext;
+memorio.isolate = (name) => createContext(name);
+Object.defineProperty(globalThis, "state", { value: state2, writable: true, enumerable: false, configurable: true });
+Object.defineProperty(globalThis, "store", { value: store, writable: true, enumerable: false, configurable: true });
+Object.defineProperty(globalThis, "session", { value: session, writable: true, enumerable: false, configurable: true });
+Object.defineProperty(globalThis, "cache", { value: cache, writable: true, enumerable: false, configurable: true });
+Object.defineProperty(globalThis, "idb", { value: exports.idb, writable: true, enumerable: false, configurable: true });
+Object.defineProperty(globalThis, "observer", { value: observer, writable: true, enumerable: false, configurable: true });
+Object.defineProperty(globalThis, "useObserver", { value: useObserver, writable: true, enumerable: false, configurable: true });
+Object.defineProperty(memorio, "dispatch", { value: dispatch, writable: true, enumerable: false, configurable: true });
+Object.defineProperty(memorio, "setContext", { writable: false, enumerable: false, value: (id) => setCurrentContext(id) });
+Object.defineProperty(memorio, "getContext", { writable: false, enumerable: false, value: () => exports.internal.currentContext });
+Object.defineProperty(globalThis, "$state", { get: () => globalThis.state, configurable: true });
+Object.defineProperty(globalThis, "$store", { get: () => globalThis.store, configurable: true });
+Object.defineProperty(globalThis, "$session", { get: () => globalThis.session, configurable: true });
+Object.defineProperty(globalThis, "$cache", { get: () => globalThis.cache, configurable: true });
+memorio.help = function() {
+  console.debug(`
+\u{1F9E0} Memorio ${package_default.version} - Help
+
+Core Modules:
+  state     - Reactive state management
+  store     - Persistent storage (localStorage/Map)
+  session   - Session storage (sessionStorage/Map)
+  cache     - In-memory cache
+  idb       - IndexedDB (browser only)
+
+Context Management:
+  memorio.isolate(name)      - Create isolated context
+  memorio.listContexts()     - List all contexts
+  memorio.deleteContext(id)  - Delete a context
+
+Platform Detection:
+  memorio.isBrowser()   - Browser environment
+  memorio.isNode()      - Node.js environment
+  memorio.isDeno()      - Deno environment
+  memorio.isEdge()      - Edge/Worker environment
+  memorio.getCapabilities() - Full capabilities object
+
+DevTools:
+  memorio.devtools.inspect()   - Inspect all modules
+  memorio.devtools.stats()     - Show statistics
+  memorio.devtools.watch()     - Watch a path
+  memorio.devtools.exportData() - Export as JSON
+  memorio.devtools.importData() - Import from JSON
+  memorio.devtools.clear()     - Clear specific module
+  memorio.devtools.clearAll()  - Clear all modules
+
+Shortcuts:
+  state, store, session, cache, idb - direct access to modules
+`);
+};
+
+// index.ts
+var memorio2 = globalThis.memorio;
+var events = globalThis.events;
+var isolate = (name) => createContext(name);
+var help2 = globalThis.memorio?.help;
+var setContext = (id) => exports.internal.currentContext = id;
+var getContext = () => exports.internal.currentContext;
+var index_default = memorio2;
+
+exports.cache = cache;
+exports.createContext = createContext;
+exports.default = index_default;
+exports.deleteContext = deleteContext;
+exports.devtools = devtools;
+exports.dispatch = dispatch;
+exports.events = events;
+exports.getCapabilities = getCapabilities;
+exports.getContext = getContext;
+exports.help = help2;
+exports.isBrowser = isBrowser;
+exports.isDeno = isDeno;
+exports.isEdge = isEdge;
+exports.isNode = isNode;
+exports.isolate = isolate;
+exports.listContexts = listContexts;
+exports.logger = logger;
+exports.memorio = memorio2;
+exports.observer = observer;
+exports.session = session;
+exports.setContext = setContext;
+exports.state = state2;
+exports.store = store;
+exports.useObserver = useObserver;