memorio 4.9.8 → 4.9.30

package/modules/redux.js

@@ -0,0 +1,2669 @@
+import 'path';
+import 'url';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+  }
+});
+
+// core/internal.ts
+var INTERNAL_KEY, state, internal, protect, internal_default;
+var init_internal = __esm({
+  "core/internal.ts"() {
+    init_esm_shims();
+    INTERNAL_KEY = "__memorio_internal_state";
+    state = globalThis[INTERNAL_KEY] || {
+      debug: false,
+      tracking: false,
+      trackedPaths: /* @__PURE__ */ new Set(),
+      locked: false,
+      lastAccessedPath: "",
+      stateVersion: 0,
+      currentContext: null,
+      mutations: [],
+      undoStack: [],
+      redoStack: [],
+      maxHistory: 100,
+      historyEnabled: false
+    };
+    if (!globalThis[INTERNAL_KEY]) {
+      globalThis[INTERNAL_KEY] = state;
+    }
+    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;
+      },
+      get mutations() {
+        return state.mutations;
+      },
+      get undoStack() {
+        return state.undoStack;
+      },
+      get redoStack() {
+        return state.redoStack;
+      },
+      get maxHistory() {
+        return state.maxHistory;
+      },
+      set maxHistory(value) {
+        state.maxHistory = value;
+      },
+      get historyEnabled() {
+        return state.historyEnabled;
+      },
+      set historyEnabled(value) {
+        state.historyEnabled = value;
+      },
+      /**
+       * Records a mutation in the trace log and undo/redo stacks.
+       * Called by the state proxy's callback.
+       */
+      recordMutation(record) {
+        if (!state.historyEnabled) return;
+        state.mutations.push(record);
+        if (state.mutations.length > state.maxHistory) {
+          state.mutations.shift();
+        }
+        state.undoStack.push(record);
+        if (state.undoStack.length > state.maxHistory) {
+          state.undoStack.shift();
+        }
+        state.redoStack = [];
+      },
+      /**
+       * Pops a record from the undo stack and pushes to redo stack.
+       * Returns the record or undefined if empty.
+       */
+      popUndo() {
+        const record = state.undoStack.pop();
+        if (record) {
+          state.redoStack.push(record);
+        }
+        return record;
+      },
+      /**
+       * Pops a record from the redo stack and pushes to undo stack.
+       * Returns the record or undefined if empty.
+       */
+      popRedo() {
+        const record = state.redoStack.pop();
+        if (record) {
+          state.undoStack.push(record);
+        }
+        return record;
+      },
+      canUndo() {
+        return state.undoStack.length > 0;
+      },
+      canRedo() {
+        return state.redoStack.length > 0;
+      },
+      clearHistory() {
+        state.mutations = [];
+        state.undoStack = [];
+        state.redoStack = [];
+      },
+      clearRedo() {
+        state.redoStack = [];
+      }
+    };
+    protect = [
+      "list",
+      "state",
+      "store",
+      "idb",
+      "sqlite",
+      "observer",
+      "useObserver",
+      "remove",
+      "removeAll",
+      // Platform-related protected keys
+      "_platform",
+      "_capabilities",
+      "_sessionId"
+    ];
+    internal_default = internal;
+  }
+});
+
+// core/env.ts
+var DEV;
+var init_env = __esm({
+  "core/env.ts"() {
+    init_esm_shims();
+    DEV = typeof process !== "undefined" ? false : true;
+  }
+});
+
+// functions/message/index.ts
+var message, message_default;
+var init_message = __esm({
+  "functions/message/index.ts"() {
+    init_esm_shims();
+    init_internal();
+    init_env();
+    message = /* @__PURE__ */ __name((...args) => {
+      if (DEV && internal_default.debug === true) {
+        console.debug(...args);
+      }
+    }, "message");
+    message_default = message;
+  }
+});
+
+// core/platform.ts
+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;
+}
+var CONTEXTS_KEY, _contexts;
+var init_platform = __esm({
+  "core/platform.ts"() {
+    init_esm_shims();
+    init_internal();
+    __name(getSessionStorage, "getSessionStorage");
+    __name(getLocalStorage, "getLocalStorage");
+    __name(hasIndexedDB, "hasIndexedDB");
+    CONTEXTS_KEY = "__memorio_contexts__";
+    _contexts = globalThis[CONTEXTS_KEY] || /* @__PURE__ */ new Map();
+    if (!globalThis[CONTEXTS_KEY]) {
+      globalThis[CONTEXTS_KEY] = _contexts;
+    }
+  }
+});
+
+// functions/idb/tools/db.create.ts
+var db_create_exports = {};
+var init_db_create = __esm({
+  "functions/idb/tools/db.create.ts"() {
+    init_esm_shims();
+    init_idb();
+    init_message();
+    idb.db.create = (dbName, ver = 1) => {
+      return new Promise((resolve, reject) => {
+        if (!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_esm_shims();
+    init_idb();
+    idb.db.list = async () => {
+      if (!("indexedDB" in globalThis) || !indexedDB.databases) return [];
+      try {
+        const result = await indexedDB.databases();
+        globalThis.idbases = result || [];
+        await 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_esm_shims();
+    init_idb();
+    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_esm_shims();
+    init_idb();
+    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_esm_shims();
+    init_idb();
+    init_message();
+    idb.db.delete = (storeName) => {
+      return new Promise((resolve, reject) => {
+        message_default(`Removing database ${storeName}...`);
+        const performDelete = /* @__PURE__ */ __name(() => {
+          const request = indexedDB.deleteDatabase(storeName);
+          request.onsuccess = () => {
+            message_default(`${storeName} database removed successfully`);
+            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");
+        performDelete();
+      });
+    };
+  }
+});
+
+// functions/idb/tools/db.size.ts
+var db_size_exports = {};
+var init_db_size = __esm({
+  "functions/idb/tools/db.size.ts"() {
+    init_esm_shims();
+    init_idb();
+    init_message();
+    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 idb.db.create(dbInfo.name, dbInfo.version);
+          const tableNames = Array.from(db.objectStoreNames);
+          let totalDbSize = 0;
+          for (const tableName of tableNames) {
+            const tableSize = await 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_esm_shims();
+    init_idb();
+    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_esm_shims();
+    init_idb();
+    init_message();
+    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_esm_shims();
+    init_idb();
+    init_message();
+    idb.table.create = (dbName, dbTable) => {
+      return new Promise((resolve, reject) => {
+        try {
+          const currentVersion = Number(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();
+            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_esm_shims();
+    init_idb();
+    init_message();
+    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_esm_shims();
+    init_idb();
+    init_message();
+    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);
+      });
+    };
+    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_esm_shims();
+    init_idb();
+    init_message();
+    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_esm_shims();
+    init_idb();
+    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, idb;
+var init_idb = __esm({
+  "functions/idb/index.ts"() {
+    init_esm_shims();
+    init_platform();
+    init_env();
+    _hasIDB = hasIndexedDB();
+    idb = {
+      db: {},
+      table: {},
+      data: {}
+    };
+    if (_hasIDB) {
+      (async () => {
+        Object.defineProperty(idb, "db", { value: {}, writable: true, configurable: true });
+        Object.defineProperty(idb, "table", { value: {}, writable: true, configurable: true });
+        Object.defineProperty(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(idb);
+        Object.seal(idb);
+        Object.freeze(idb);
+      })();
+    } else {
+      idb._disabled = true;
+      idb._warning = "IndexedDB is not available in this environment (Node.js/Deno). Use store or session for persistence.";
+      if (DEV) {
+        console.warn("Memorio IDB: IndexedDB is not available in this environment. Use store or session for data persistence.");
+      }
+    }
+  }
+});
+
+// modules/redux.ts
+init_esm_shims();
+
+// adapters/redux/index.ts
+init_esm_shims();
+
+// adapters/redux/middleware.ts
+init_esm_shims();
+
+// adapters/redux/selectors.ts
+init_esm_shims();
+function normalizeMappings(mappings) {
+  const out = {};
+  if (!mappings) return out;
+  for (const key of Object.keys(mappings)) {
+    const v = mappings[key];
+    if (typeof v === "function") {
+      out[key] = { selector: v };
+    } else if (v && typeof v === "object") {
+      out[key] = v;
+    }
+  }
+  return out;
+}
+__name(normalizeMappings, "normalizeMappings");
+function selectValues(state3, mappings) {
+  const values = {};
+  for (const key of Object.keys(mappings)) {
+    try {
+      values[key] = mappings[key].selector(state3);
+    } catch {
+      values[key] = void 0;
+    }
+  }
+  return values;
+}
+__name(selectValues, "selectValues");
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return a === b;
+  if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+  if (a instanceof RegExp && b instanceof RegExp) return a.source === b.source && a.flags === b.flags;
+  const ak = Object.keys(a);
+  const bk = Object.keys(b);
+  if (ak.length !== bk.length) return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b)) return false;
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  for (const k of ak) {
+    if (!(k in b)) return false;
+    if (!deepEqual(a[k], b[k])) return false;
+  }
+  return true;
+}
+__name(deepEqual, "deepEqual");
+function actionType(action) {
+  return action && typeof action === "object" ? action.type : void 0;
+}
+__name(actionType, "actionType");
+function shouldIgnoreAction(action, opts, mapping) {
+  const t = actionType(action);
+  if (opts.blacklist && opts.blacklist.length && opts.blacklist.includes(t)) return true;
+  if (opts.whitelist && opts.whitelist.length && !opts.whitelist.includes(t)) return true;
+  if (mapping && mapping.ignoreActions && mapping.ignoreActions.length && mapping.ignoreActions.includes(t)) {
+    return true;
+  }
+  return false;
+}
+__name(shouldIgnoreAction, "shouldIgnoreAction");
+function collectDirtyMappings(action, opts, mappings) {
+  const dirty = [];
+  for (const key of Object.keys(mappings)) {
+    if (!shouldIgnoreAction(action, opts, mappings[key])) dirty.push(key);
+  }
+  return dirty;
+}
+__name(collectDirtyMappings, "collectDirtyMappings");
+
+// adapters/redux/persist.ts
+init_esm_shims();
+
+// functions/memory/index.ts
+init_esm_shims();
+
+// functions/state/index.ts
+init_esm_shims();
+init_internal();
+init_message();
+
+// core/dispatch.ts
+init_esm_shims();
+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: /* @__PURE__ */ __name((name, value = {}) => {
+    globalThis.dispatchEvent(new CustomEvent(String(name), value));
+  }, "set"),
+  ///
+  /**
+   * Subscribes a callback to an event name. Maintains a *list* of handlers per
+   * name, so multiple subscribers on the same path (e.g. several
+   * `useObserver` calls observing `state.report`) each keep firing and each
+   * get an independent unsubscribe. The previous single-slot-per-name
+   * behaviour silently dropped the second subscriber and let any unsubscribe
+   * cancel every other subscriber on that path.
+   * @param name The name of the event to listen for.
+   * @param cb The callback function to execute when the event is triggered.
+   * @returns An unsubscribe function for this subscriber, or void if no callback.
+   */
+  listen: /* @__PURE__ */ __name((name, cb = null, _flag) => {
+    if (!cb) return;
+    const wrapped = /* @__PURE__ */ __name((e) => {
+      const target = e;
+      if (globalThis.queueMicrotask) {
+        globalThis.queueMicrotask(() => cb(target));
+      } else {
+        Promise.resolve().then(() => cb(target));
+      }
+    }, "wrapped");
+    globalThis.addEventListener(name, wrapped);
+    const list = globalThis.events[name] = globalThis.events[name] ?? [];
+    list.push(wrapped);
+    return () => {
+      globalThis.removeEventListener(name, wrapped);
+      const idx = list.indexOf(wrapped);
+      if (idx > -1) list.splice(idx, 1);
+      if (!list.length) delete globalThis.events[name];
+    };
+  }, "listen"),
+  ///
+  /**
+   * Removes ALL handlers for the specified event name (imperative bulk
+   * removal). For per-subscriber teardown, use the unsubscribe function
+   * returned by `listen`.
+   * @param name The name of the event to remove the listeners for.
+   */
+  remove: /* @__PURE__ */ __name((name) => {
+    const entry = globalThis.events?.[name];
+    if (Array.isArray(entry)) {
+      entry.forEach((h) => globalThis.removeEventListener(name, h));
+    } else if (typeof entry === "function") {
+      globalThis.removeEventListener(name, entry);
+    }
+    delete globalThis.events[name];
+  }, "remove")
+};
+
+// functions/schema/index.ts
+init_esm_shims();
+init_message();
+var _schemas = /* @__PURE__ */ new Map();
+var _validateValue = /* @__PURE__ */ __name((value, schema2, path2) => {
+  const errors = [];
+  if (schema2.type && schema2.type !== "any") {
+    const actualType = Array.isArray(value) ? "array" : typeof value;
+    if (actualType !== schema2.type) {
+      errors.push(`${path2}: expected ${schema2.type}, got ${actualType}`);
+      return { valid: false, errors };
+    }
+  }
+  if (schema2.enum && !schema2.enum.includes(value)) {
+    errors.push(`${path2}: value must be one of [${schema2.enum.map(String).join(", ")}]`);
+  }
+  if (schema2.validator) {
+    const result = schema2.validator(value);
+    if (result !== true) {
+      errors.push(`${path2}: ${typeof result === "string" ? result : "validation failed"}`);
+    }
+  }
+  if (typeof value === "number") {
+    if (schema2.min !== void 0 && value < schema2.min) {
+      errors.push(`${path2}: value ${value} is less than minimum ${schema2.min}`);
+    }
+    if (schema2.max !== void 0 && value > schema2.max) {
+      errors.push(`${path2}: value ${value} exceeds maximum ${schema2.max}`);
+    }
+  }
+  if (typeof value === "string") {
+    if (schema2.min !== void 0 && value.length < schema2.min) {
+      errors.push(`${path2}: string length ${value.length} is less than minimum ${schema2.min}`);
+    }
+    if (schema2.max !== void 0 && value.length > schema2.max) {
+      errors.push(`${path2}: string length ${value.length} exceeds maximum ${schema2.max}`);
+    }
+    if (schema2.pattern && !schema2.pattern.test(value)) {
+      errors.push(`${path2}: string does not match required pattern`);
+    }
+  }
+  if (schema2.type === "object" && value && typeof value === "object" && !Array.isArray(value)) {
+    if (schema2.required) {
+      for (const req of schema2.required) {
+        if (!(req in value)) {
+          errors.push(`${path2}: missing required property '${req}'`);
+        }
+      }
+    }
+    if (schema2.properties) {
+      for (const [prop, propSchema] of Object.entries(schema2.properties)) {
+        if (prop in value && value[prop] !== void 0) {
+          const propResult = _validateValue(value[prop], propSchema, `${path2}.${prop}`);
+          if (!propResult.valid) {
+            errors.push(...propResult.errors || []);
+          }
+        }
+      }
+    }
+  }
+  if (schema2.type === "array" && Array.isArray(value) && schema2.items) {
+    for (let i = 0; i < value.length; i++) {
+      const itemResult = _validateValue(value[i], schema2.items, `${path2}[${i}]`);
+      if (!itemResult.valid) {
+        errors.push(...itemResult.errors || []);
+      }
+    }
+  }
+  return errors.length === 0 ? { valid: true } : { valid: false, errors };
+}, "_validateValue");
+var validate = /* @__PURE__ */ __name((path2, value) => {
+  const schema2 = _schemas.get(path2);
+  if (!schema2) {
+    return { valid: true };
+  }
+  return _validateValue(value, schema2, path2);
+}, "validate");
+var registerSchema = /* @__PURE__ */ __name((path2, schema2) => {
+  if (typeof schema2 === "function") {
+    _schemas.set(path2, { validator: schema2 });
+  } else {
+    _schemas.set(path2, schema2);
+  }
+  message_default(`[memorio schema] Registered schema for '${path2}'`);
+}, "registerSchema");
+var unregisterSchema = /* @__PURE__ */ __name((path2) => {
+  return _schemas.delete(path2);
+}, "unregisterSchema");
+var listSchemas = /* @__PURE__ */ __name(() => {
+  return Array.from(_schemas.keys());
+}, "listSchemas");
+var getSchema = /* @__PURE__ */ __name((path2) => {
+  return _schemas.get(path2);
+}, "getSchema");
+var schema = {
+  register: registerSchema,
+  validate,
+  unregister: unregisterSchema,
+  list: listSchemas,
+  get: getSchema
+};
+
+// functions/state/index.ts
+init_env();
+var TARGET = /* @__PURE__ */ Symbol("memorio.target");
+var wrapperCache = /* @__PURE__ */ new WeakMap();
+var deepRaw = /* @__PURE__ */ __name((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;
+}, "deepRaw");
+var objPath = /* @__PURE__ */ __name((prop, object, separator = ".") => {
+  return object.concat(prop).join(separator);
+}, "objPath");
+var buildProxy = /* @__PURE__ */ __name((obj, callback, tree = []) => {
+  const event = /* @__PURE__ */ __name((name) => {
+    try {
+      dispatch.set(name, { detail: { name } });
+    } catch (err) {
+      if (DEV) console.warn("[memorio state] event dispatch failed:", err);
+    }
+    return;
+  }, "event");
+  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 deepRaw(target, /* @__PURE__ */ new WeakSet());
+        }
+        if (typeof prop === "string") {
+          const path2 = tree.length > 0 ? "state." + tree.concat(prop).join(".") : "state." + prop;
+          internal_default.lastAccessedPath = path2;
+          if (internal_default.tracking) {
+            internal_default.trackedPaths.add(path2);
+          }
+        }
+        if (prop === "_lastPath") {
+          return internal_default.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 (internal_default.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 path2 = objPath(key, tree);
+          const rawValue = deepRaw(value);
+          const _schemaResult = schema.validate(path2, rawValue);
+          if (!_schemaResult.valid) {
+            if (DEV && internal_default.debug) {
+              console.error(
+                `[memorio schema] Validation failed for '${path2}':`,
+                _schemaResult.errors
+              );
+            }
+            message_default(
+              `[memorio schema] Validation failed for '${path2}': ` + (_schemaResult.errors?.join(", ") || "unknown error")
+            );
+            return false;
+          }
+          callback(
+            {
+              action: "set",
+              path: path2,
+              target,
+              newValue: rawValue,
+              previousValue: Reflect.get(target, key)
+            }
+          );
+          event("state." + path2);
+          Reflect.set(target, key, rawValue);
+          internal_default.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: /* @__PURE__ */ __name(() => {
+                    Object.defineProperty(lockValue, "__locked", {
+                      writable: true,
+                      enumerable: false,
+                      configurable: false,
+                      value: true
+                    });
+                    message_default(`State '${key}' is now locked.`);
+                  }, "value")
+                });
+                Object.defineProperty(lockValue, "unlock", {
+                  writable: false,
+                  enumerable: false,
+                  configurable: false,
+                  value: /* @__PURE__ */ __name(() => {
+                    Object.defineProperty(lockValue, "__locked", {
+                      writable: true,
+                      enumerable: false,
+                      configurable: false,
+                      value: false
+                    });
+                    message_default(`State '${key}' is now unlocked.`);
+                  }, "value")
+                });
+              } catch (err) {
+                if (DEV) console.warn("[memorio state] lock/unlock defineProperty failed:", err);
+              }
+            }
+          }
+          return true;
+        } catch (error) {
+          console.error("Error in set trap:", error);
+          return false;
+        }
+      },
+      deleteProperty(target, prop) {
+        try {
+          const path2 = objPath(prop, tree);
+          const previousValue = Reflect.get(target, prop);
+          callback({ action: "delete", path: path2, target, previousValue });
+          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);
+      }
+    }
+  );
+}, "buildProxy");
+var STATE_INSTANCE_KEY = "__memorio_state_instance__";
+var state2;
+if (globalThis[STATE_INSTANCE_KEY]) {
+  state2 = globalThis[STATE_INSTANCE_KEY];
+} else {
+  state2 = buildProxy({}, (mutation) => {
+    if (internal_default.historyEnabled) {
+      internal_default.recordMutation({
+        path: mutation.path,
+        action: mutation.action,
+        newValue: mutation.newValue,
+        previousValue: mutation.previousValue,
+        timestamp: Date.now()
+      });
+    }
+  });
+  state2.lock = () => {
+    internal_default.locked = true;
+    message_default("State is now locked. All modifications are blocked.");
+  };
+  state2.unlock = () => {
+    internal_default.locked = false;
+    message_default("State is now unlocked. Modifications are allowed.");
+  };
+  globalThis[STATE_INSTANCE_KEY] = state2;
+}
+
+// functions/store/index.ts
+init_esm_shims();
+init_platform();
+init_internal();
+init_message();
+var _localStorage = getLocalStorage();
+var _fallbackStorageByContext = /* @__PURE__ */ new Map();
+function _getFallbackStorage() {
+  const contextName = internal_default.currentContext || "";
+  const key = contextName || "default";
+  if (!_fallbackStorageByContext.has(key)) {
+    _fallbackStorageByContext.set(key, /* @__PURE__ */ new Map());
+  }
+  return _fallbackStorageByContext.get(key);
+}
+__name(_getFallbackStorage, "_getFallbackStorage");
+var _hasStorage = _localStorage !== null;
+function _getPrefix() {
+  const contextName = internal_default.currentContext || "";
+  return contextName ? `${contextName}-` : `memorio_store_`;
+}
+__name(_getPrefix, "_getPrefix");
+function _prefixKey(name) {
+  if (!name || typeof name !== "string") {
+    console.warn(`[memorio store] key is empty or not a string - operation aborted`);
+    return "";
+  }
+  if (name.length > 512) {
+    console.warn(`[memorio store] key "${name}" exceeds 512 chars - operation aborted`);
+    return "";
+  }
+  return _getPrefix() + name;
+}
+__name(_prefixKey, "_prefixKey");
+function _read(prefixedName) {
+  const raw = _hasStorage ? _localStorage.getItem(prefixedName) : _getFallbackStorage().get(prefixedName);
+  return raw ? JSON.parse(raw) : raw;
+}
+__name(_read, "_read");
+function _write(prefixedName, value) {
+  const json = JSON.stringify(value);
+  if (_hasStorage) _localStorage.setItem(prefixedName, json);
+  else _getFallbackStorage().set(prefixedName, json);
+}
+__name(_write, "_write");
+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;
+}
+__name(_remove, "_remove");
+var STORE_INSTANCE_KEY = "__memorio_store_instance__";
+var store;
+if (globalThis[STORE_INSTANCE_KEY]) {
+  store = globalThis[STORE_INSTANCE_KEY];
+} else {
+  store = new Proxy({}, {});
+  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: /* @__PURE__ */ __name((name) => {
+          if (!name) {
+            console.warn("[memorio store] store.get() called with empty or null key - returning null");
+            return null;
+          }
+          try {
+            return _read(_prefixKey(name));
+          } catch (err) {
+            message(`Error parsing store item '${name}': ${err}`);
+          }
+          return null;
+        }, "value")
+      },
+      getMultiple: {
+        value: /* @__PURE__ */ __name((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;
+        }, "value")
+      },
+      /**
+       * 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: /* @__PURE__ */ __name((name, value) => {
+          if (!name) {
+            console.warn("[memorio store] store.set() called with empty or null key - write aborted");
+            return false;
+          }
+          const prefixedName = _prefixKey(name);
+          if (!prefixedName) return false;
+          if (typeof value === "function") {
+            console.warn("[memorio store] functions are not storable - write aborted for key: " + name);
+            message("Storing functions is not secure and is blocked for safety.");
+            return false;
+          }
+          try {
+            _write(prefixedName, value);
+          } catch (err) {
+            message(`Error setting store item '${name}': ${err}`);
+            return false;
+          }
+          return true;
+        }, "value")
+      },
+      /**
+       * Removes a value from storage.
+       * @param name The key to remove.
+       * @returns True if removed, false if not found.
+       */
+      remove: {
+        value: /* @__PURE__ */ __name((name) => {
+          if (!name) {
+            console.debug("[memorio store] store.remove() called with empty or null key - returning false");
+            return false;
+          }
+          const prefixedName = _prefixKey(name);
+          if (!prefixedName) return false;
+          try {
+            return _remove(prefixedName);
+          } catch (err) {
+            message(`Error removing store item '${name}': ${err}`);
+          }
+          return false;
+        }, "value")
+      },
+      /**
+       * Alias for remove.
+       * @param name The key to delete.
+       */
+      delete: {
+        value: /* @__PURE__ */ __name((name) => {
+          return store.remove(name);
+        }, "value")
+      },
+      /**
+       * Clears all memorio items from storage.
+       */
+      removeAll: {
+        value: /* @__PURE__ */ __name(() => {
+          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;
+        }, "value")
+      },
+      /**
+       * Alias for removeAll.
+       */
+      clearAll: {
+        value: /* @__PURE__ */ __name(() => {
+          store.removeAll();
+          return true;
+        }, "value")
+      },
+      /**
+       * Estimates storage quota usage.
+       * @returns Promise with [usage, quota].
+       */
+      quota: {
+        value: /* @__PURE__ */ __name(async () => {
+          return [0, 0];
+        }, "value")
+      },
+      /**
+       * Calculates total size of all memorio items in kilobytes.
+       * Counts each prefixed key and its JSON-serialized value, summing their
+       * byte lengths and converting to whole kilobytes (Math.ceil). Replaces
+       * the previous character-only total which did not express real usage.
+       * @returns Total size in kilobytes (0 when empty / no memorio items).
+       */
+      size: {
+        value: /* @__PURE__ */ __name(() => {
+          let totalBytes = 0;
+          if (_hasStorage) {
+            for (let i = 0; i < _localStorage.length; i++) {
+              const key = _localStorage.key(i);
+              if (key && key.startsWith(_getPrefix())) {
+                const item = _localStorage.getItem(key);
+                if (item) totalBytes += key.length + item.length;
+              }
+            }
+          } else {
+            _getFallbackStorage().forEach((value, key) => {
+              totalBytes += key.length + value.length;
+            });
+          }
+          return totalBytes === 0 ? 0 : Math.ceil(totalBytes / 1024);
+        }, "value")
+      },
+      /**
+       * Check if using real localStorage or fallback
+       */
+      isPersistent: {
+        get: /* @__PURE__ */ __name(() => _hasStorage, "get")
+      },
+      /**
+       * Get a list of all memorio store items.
+       */
+      list: {
+        value: /* @__PURE__ */ __name(() => {
+          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) {
+            message(`Error listing store items: ${err}`);
+          }
+          return result;
+        }, "value")
+      }
+    }
+  );
+  Object.freeze(store);
+  globalThis[STORE_INSTANCE_KEY] = store;
+}
+
+// functions/session/index.ts
+init_esm_shims();
+init_platform();
+init_internal();
+init_message();
+var _sessionStorage = getSessionStorage();
+var _fallbackStorageByContext2 = /* @__PURE__ */ new Map();
+function _getFallbackStorage2() {
+  const contextName = internal_default.currentContext || "";
+  const key = contextName || "default";
+  if (!_fallbackStorageByContext2.has(key)) {
+    _fallbackStorageByContext2.set(key, /* @__PURE__ */ new Map());
+  }
+  return _fallbackStorageByContext2.get(key);
+}
+__name(_getFallbackStorage2, "_getFallbackStorage");
+var _hasStorage2 = _sessionStorage !== null;
+function _getPrefix2() {
+  const contextName = internal_default.currentContext || "";
+  return contextName ? `${contextName}-` : `memorio_session_`;
+}
+__name(_getPrefix2, "_getPrefix");
+function _prefixKey2(name) {
+  if (!name || typeof name !== "string") {
+    console.warn("[memorio session] key is empty or not a string - operation aborted");
+    return "";
+  }
+  if (name.length > 512) {
+    console.warn(`[memorio session] key "${name}" exceeds 512 chars - operation aborted`);
+    return "";
+  }
+  return _getPrefix2() + name;
+}
+__name(_prefixKey2, "_prefixKey");
+function _read2(prefixedName) {
+  const raw = _hasStorage2 ? _sessionStorage.getItem(prefixedName) : _getFallbackStorage2().get(prefixedName);
+  return raw ? JSON.parse(raw) : raw;
+}
+__name(_read2, "_read");
+function _write2(prefixedName, value) {
+  const json = JSON.stringify(value);
+  if (_hasStorage2) _sessionStorage.setItem(prefixedName, json);
+  else _getFallbackStorage2().set(prefixedName, json);
+}
+__name(_write2, "_write");
+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;
+}
+__name(_remove2, "_remove");
+var SESSION_INSTANCE_KEY = "__memorio_session_instance__";
+var session;
+if (globalThis[SESSION_INSTANCE_KEY]) {
+  session = globalThis[SESSION_INSTANCE_KEY];
+} else {
+  session = new Proxy({}, {});
+  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: /* @__PURE__ */ __name((name) => {
+          if (!name) {
+            console.warn("[memorio session] session.get() called with empty or null key - returning null");
+            return null;
+          }
+          try {
+            return _read2(_prefixKey2(name));
+          } catch (err) {
+            message(`Error parsing session item '${name}':${err}`);
+          }
+          return null;
+        }, "value")
+      },
+      /**
+       * 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: /* @__PURE__ */ __name((name, value) => {
+          if (!name) {
+            console.warn("[memorio session] session.set() called with empty or null key - write aborted");
+            return false;
+          }
+          const prefixedName = _prefixKey2(name);
+          if (!prefixedName) return false;
+          if (typeof value === "function") {
+            console.warn("[memorio session] functions are not storable - write aborted for key: " + name);
+            message("It's not secure to session functions.");
+            return false;
+          }
+          try {
+            _write2(prefixedName, value);
+          } catch (err) {
+            message(`Error setting session item '${name}': ${err}`);
+            return false;
+          }
+          return true;
+        }, "value")
+      },
+      /**
+       * Removes a value from storage.
+       * @param name The key to remove.
+       * @returns True if removed.
+       */
+      remove: {
+        value: /* @__PURE__ */ __name((name) => {
+          if (!name) {
+            console.warn("[memorio session] session.remove() called with empty or null key - returning false");
+            return false;
+          }
+          const prefixedName = _prefixKey2(name);
+          if (!prefixedName) return false;
+          try {
+            return _remove2(prefixedName);
+          } catch (err) {
+            message(`Error removing session item '${name}': ${err}`);
+          }
+          return false;
+        }, "value")
+      },
+      /**
+       * Alias for remove.
+       * @param name The key to delete.
+       * @returns True if removed.
+       */
+      delete: {
+        value: /* @__PURE__ */ __name((name) => {
+          return session.remove(name);
+        }, "value")
+      },
+      /**
+         * Clears all sessionStorage items.
+         */
+      removeAll: {
+        value: /* @__PURE__ */ __name(() => {
+          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;
+        }, "value")
+      },
+      /**
+       * Alias for removeAll.
+       */
+      clearAll: {
+        value: /* @__PURE__ */ __name(() => {
+          session.removeAll();
+          return true;
+        }, "value")
+      },
+      quota: {
+        value: /* @__PURE__ */ __name(async () => {
+          return [0, 0];
+        }, "value")
+      },
+      /**
+       * Calculates total size of all memorio session items in kilobytes.
+       * Counts each prefixed key and its JSON-serialized value, summing their
+       * byte lengths and converting to whole kilobytes (Math.ceil).
+       * @returns Total size in kilobytes (0 when empty / no memorio items).
+       */
+      size: {
+        value: /* @__PURE__ */ __name(() => {
+          let totalBytes = 0;
+          if (_hasStorage2) {
+            for (let i = 0; i < _sessionStorage.length; i++) {
+              const key = _sessionStorage.key(i);
+              if (key && key.startsWith(_getPrefix2())) {
+                const item = _sessionStorage.getItem(key);
+                if (item) totalBytes += key.length + item.length;
+              }
+            }
+          } else {
+            _getFallbackStorage2().forEach((value, key) => {
+              totalBytes += key.length + value.length;
+            });
+          }
+          return totalBytes === 0 ? 0 : Math.ceil(totalBytes / 1024);
+        }, "value")
+      },
+      /**
+       * Check if using real sessionStorage or fallback
+       */
+      isPersistent: {
+        get: /* @__PURE__ */ __name(() => _hasStorage2, "get")
+      },
+      /**
+       * Get a list of all memorio session items.
+       */
+      list: {
+        value: /* @__PURE__ */ __name(() => {
+          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) {
+            message(`Error listing session items: ${err}`);
+          }
+          return result;
+        }, "value")
+      }
+    }
+  );
+  Object.freeze(session);
+  globalThis[SESSION_INSTANCE_KEY] = session;
+}
+
+// functions/memory/index.ts
+init_idb();
+
+// core/hlc.ts
+init_esm_shims();
+var NODE_ID_KEY = "__memorio_hlc_node";
+function getNodeId() {
+  if (typeof globalThis === "undefined") return "node";
+  try {
+    if (typeof sessionStorage !== "undefined" && sessionStorage) {
+      let id = sessionStorage.getItem(NODE_ID_KEY);
+      if (!id) {
+        id = generateNodeId();
+        sessionStorage.setItem(NODE_ID_KEY, id);
+      }
+      return id;
+    }
+  } catch {
+  }
+  if (!globalThis.__memorioHlcNodeId) {
+    globalThis.__memorioHlcNodeId = generateNodeId();
+  }
+  return globalThis.__memorioHlcNodeId;
+}
+__name(getNodeId, "getNodeId");
+function generateNodeId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID().slice(0, 8);
+  }
+  return Math.random().toString(36).slice(2, 10);
+}
+__name(generateNodeId, "generateNodeId");
+var HLC_KEY = "__memorio_hlc_local";
+var local = globalThis[HLC_KEY] || {
+  physical: 0,
+  logical: 0,
+  node: getNodeId()
+};
+if (!globalThis[HLC_KEY]) {
+  globalThis[HLC_KEY] = local;
+}
+function tick(_incoming) {
+  const now2 = Date.now();
+  const base = local.physical;
+  let physical;
+  let logical;
+  if (now2 > base) {
+    physical = now2;
+    logical = 0;
+  } else if (now2 < base) {
+    physical = base;
+    logical = local.logical + 1;
+  } else {
+    physical = base;
+    logical = local.logical + 1;
+  }
+  local.physical = physical;
+  local.logical = logical;
+  return { physical, logical, node: local.node };
+}
+__name(tick, "tick");
+function receive(remote) {
+  const now2 = Date.now();
+  if (remote.physical > local.physical) {
+    local.physical = remote.physical > now2 ? remote.physical : now2;
+    local.logical = 1;
+  } else if (remote.physical === local.physical) {
+    local.logical = Math.max(local.logical, remote.logical) + 1;
+  }
+  local.node = getNodeId();
+  return { ...local };
+}
+__name(receive, "receive");
+function compare(a, b) {
+  if (a.physical !== b.physical) {
+    return a.physical < b.physical ? -1 : 1;
+  }
+  if (a.logical !== b.logical) {
+    return a.logical < b.logical ? -1 : 1;
+  }
+  if (a.node !== b.node) {
+    return a.node < b.node ? -1 : 1;
+  }
+  return 0;
+}
+__name(compare, "compare");
+function happenedBefore(a, b) {
+  return compare(a, b) < 0;
+}
+__name(happenedBefore, "happenedBefore");
+function serialize(hlc2) {
+  return `hlc:${hlc2.physical}:${hlc2.logical}:${hlc2.node}`;
+}
+__name(serialize, "serialize");
+function parse(serialized) {
+  if (!serialized.startsWith("hlc:")) return null;
+  const parts = serialized.split(":");
+  if (parts.length !== 4) return null;
+  const physical = parseInt(parts[1], 10);
+  const logical = parseInt(parts[2], 10);
+  const node = parts[3];
+  if (isNaN(physical) || isNaN(logical)) return null;
+  return { physical, logical, node };
+}
+__name(parse, "parse");
+var hlc = {
+  tick,
+  receive,
+  compare,
+  happenedBefore,
+  serialize,
+  parse,
+  getNodeId
+};
+
+// functions/memory/index.ts
+init_env();
+
+// functions/memory/journal.ts
+init_esm_shims();
+init_env();
+var g = globalThis;
+function namespace() {
+  const cfg = g.memorioSyncConfig;
+  if (cfg && typeof cfg.namespace === "string" && cfg.namespace) return `ns:${cfg.namespace}`;
+  const ctx = g.memorio ? g.memorio._currentContext : void 0;
+  const ctxName = typeof ctx === "string" && ctx ? ctx : "";
+  return ctxName ? `ctx:${ctxName}` : "default";
+}
+__name(namespace, "namespace");
+function isSyncEnabled() {
+  return !!g.memorioSyncConfig;
+}
+__name(isSyncEnabled, "isSyncEnabled");
+var STORE_PREFIX = /* @__PURE__ */ __name((ns) => `memorio:sync:${ns}:`, "STORE_PREFIX");
+var INDEX_KEY = /* @__PURE__ */ __name((ns) => `${STORE_PREFIX(ns)}index`, "INDEX_KEY");
+function parseEntry(raw) {
+  try {
+    if (typeof raw === "string") return JSON.parse(raw);
+    return raw;
+  } catch (err) {
+    if (DEV) console.warn("[memorio memory] failed to parse journal entry:", err);
+    return null;
+  }
+}
+__name(parseEntry, "parseEntry");
+var journal = {
+  /** Append (or replace) a journal row for the current namespace. */
+  async append(entry, operation) {
+    const ns = namespace();
+    const row = {
+      ...entry,
+      operation,
+      updatedAt: entry.updatedAt || Date.now(),
+      version: entry.version || 1,
+      sync: "pending",
+      hlc: entry.hlc || hlc.serialize(hlc.tick())
+    };
+    const key = `${STORE_PREFIX(ns)}${row.id}`;
+    store.set(key, row);
+    const idx = store.get(INDEX_KEY(ns)) || [];
+    if (!idx.includes(row.id)) idx.push(row.id);
+    store.set(INDEX_KEY(ns), idx);
+    return row;
+  },
+  /** All pending (not-yet-synced) entries for the current namespace. */
+  async pending() {
+    const ns = namespace();
+    const out = [];
+    const idx = store.get(INDEX_KEY(ns)) || [];
+    for (const id of idx) {
+      const raw = store.get(`${STORE_PREFIX(ns)}${id}`);
+      if (!raw) continue;
+      const e = parseEntry(raw);
+      if (e && e.sync !== "synced") out.push(e);
+    }
+    out.sort((a, b) => {
+      if (a.hlc && b.hlc) {
+        const ha = hlc.parse(a.hlc);
+        const hb = hlc.parse(b.hlc);
+        if (ha && hb) return hlc.compare(ha, hb);
+      }
+      return (a.updatedAt || 0) - (b.updatedAt || 0);
+    });
+    return out;
+  },
+  /**
+   * Mark entries as synced. Returns the number of rows actually advanced to
+   * `synced` (namespace-scoped).
+   */
+  async markSynced(ids) {
+    if (!ids.length) return 0;
+    const ns = namespace();
+    let count = 0;
+    const idx = store.get(INDEX_KEY(ns)) || [];
+    for (const id of idx) {
+      if (!ids.includes(id)) continue;
+      const key = `${STORE_PREFIX(ns)}${id}`;
+      const raw = store.get(key);
+      if (!raw) continue;
+      const e = parseEntry(raw);
+      if (!e || e.sync === "synced") continue;
+      e.sync = "synced";
+      store.set(key, e);
+      count++;
+    }
+    return count;
+  },
+  async get(id) {
+    const ns = namespace();
+    const raw = store.get(`${STORE_PREFIX(ns)}${id}`);
+    return parseEntry(raw ?? "");
+  },
+  /** Remove all journal rows for the current namespace. */
+  async clear() {
+    const ns = namespace();
+    const idx = store.get(INDEX_KEY(ns)) || [];
+    for (const id of idx) store.remove(`${STORE_PREFIX(ns)}${id}`);
+    store.remove(INDEX_KEY(ns));
+  },
+  /**
+   * Reconcile the local journal against the configured provider. Pushes pending
+   * local operations, then optionally pulls newer remote operations and applies
+   * them. No-op (empty ack) when no provider is configured.
+   *
+    * When pulling remote entries, HLC timestamps are used to order operations
+    * causally. Concurrent writes to the same key (HLC tie) are resolved via the
+    * provider's `resolveConflict` method (if provided), otherwise the REMOTE
+    * entry wins by default (logged at warn level in dev). Provide a resolver on
+    * the sync provider to override this behaviour and prevent silent local data
+    * loss.
+   */
+  async replay() {
+    const ack = { synced: [], resolved: [] };
+    if (!isSyncEnabled()) return ack;
+    const transport = g.memorioSyncConfig || {};
+    const provider = transport.provider;
+    if (!provider || typeof provider.push !== "function") return ack;
+    const pending = await this.pending();
+    if (pending.length) {
+      try {
+        const res = await provider.push(pending);
+        ack.synced = res?.synced || [];
+        ack.conflicts = res?.conflicts;
+        ack.error = res?.error;
+        if (ack.synced.length) await this.markSynced(ack.synced);
+      } catch (err) {
+        ack.error = String(err);
+      }
+    }
+    if (typeof provider.pull === "function") {
+      try {
+        const since = pending.length ? Math.min(...pending.map((p) => p.updatedAt || 0)) : 0;
+        const remote = await provider.pull(since);
+        for (const e of remote || []) {
+          if (e.hlc) {
+            const parsed = hlc.parse(e.hlc);
+            if (parsed) hlc.receive(parsed);
+          }
+          const localEntry = await this.get(e.id);
+          if (localEntry && e.hlc && localEntry.hlc) {
+            const ha = hlc.parse(localEntry.hlc);
+            const hb = hlc.parse(e.hlc);
+            if (ha && hb) {
+              const cmp = hlc.compare(ha, hb);
+              if (cmp === 0) {
+                const hasResolver = typeof provider.resolveConflict === "function";
+                const resolution = hasResolver ? await provider.resolveConflict(localEntry, e) : "remote";
+                if (!hasResolver && DEV) {
+                  console.warn(`[memorio memory] replay() conflict for "${e.id}": no resolveConflict handler provided, defaulting to remote-wins`);
+                }
+                ack.resolved?.push({ id: e.id, resolution });
+                if (resolution === "local") continue;
+              } else if (cmp > 0) {
+                continue;
+              }
+            }
+          }
+          await this.append(e, e.operation || "confirm");
+          await this.markSynced([e.id]);
+        }
+      } catch (err) {
+        if (DEV) console.warn("[memorio memory] sync pull failed:", err);
+      }
+    }
+    return ack;
+  },
+  status() {
+    return Promise.resolve("store");
+  }
+};
+function configure(opts) {
+  const prev = g.memorioSyncConfig || {};
+  g.memorioSyncConfig = { ...prev, ...opts };
+  return journal;
+}
+__name(configure, "configure");
+if (typeof g.addEventListener === "function") {
+  let armed = false;
+  g.addEventListener("focus", () => {
+    if (armed || !isSyncEnabled()) return;
+    armed = true;
+    void journal.replay().finally(() => {
+      armed = false;
+    });
+  });
+}
+var journal_default = journal;
+
+// functions/memory/index.ts
+var MEMORY_INDEX_KEY = "__memorio_memory_index__";
+var SUPERSEDED_PREFIX = "__memorio_superseded__";
+function isSyncEnabled2() {
+  return !!globalThis.memorioSyncConfig;
+}
+__name(isSyncEnabled2, "isSyncEnabled");
+async function recordJournal(entry, operation) {
+  if (!isSyncEnabled2()) return;
+  if (entry.scope === "hot") return;
+  try {
+    await journal_default.append(entry, operation);
+  } catch (err) {
+    if (DEV) console.warn("[memorio memory] journal append failed:", err);
+  }
+}
+__name(recordJournal, "recordJournal");
+function memoryEntryKey(id) {
+  return id.startsWith(SUPERSEDED_PREFIX) ? id : `${SUPERSEDED_PREFIX}${id}`;
+}
+__name(memoryEntryKey, "memoryEntryKey");
+function normalizeTags(tags) {
+  if (!tags) return [];
+  return Array.isArray(tags) ? tags : [tags];
+}
+__name(normalizeTags, "normalizeTags");
+function resolveScope(value, opts) {
+  if (opts.scope) return opts.scope;
+  const size = JSON.stringify(value).length;
+  if (size > 1e6) return "durable";
+  if (size > 1e5) return "local";
+  return "local";
+}
+__name(resolveScope, "resolveScope");
+function now() {
+  return Date.now();
+}
+__name(now, "now");
+function isExpired(entry) {
+  if (entry.ttl === null || entry.ttl === void 0) return false;
+  return now() - entry.createdAt > entry.ttl;
+}
+__name(isExpired, "isExpired");
+function matchesFilters(entry, opts) {
+  if (entry.status === "obsolete") return opts.includeObsolete ?? false;
+  if (entry.status === "superseded") return opts.includeObsolete ?? false;
+  if (isExpired(entry)) {
+    return opts.includeObsolete ?? false;
+  }
+  if (opts.type) {
+    const types = Array.isArray(opts.type) ? opts.type : [opts.type];
+    if (!types.includes(entry.type)) return false;
+  }
+  if (opts.minConfidence !== void 0 && entry.confidence < opts.minConfidence) return false;
+  return true;
+}
+__name(matchesFilters, "matchesFilters");
+function matchesContextFilters(entry, opts) {
+  if (entry.status !== "active") return false;
+  if (isExpired(entry)) return false;
+  if (opts.tags) {
+    const tags = Array.isArray(opts.tags) ? opts.tags : [opts.tags];
+    const hasMatch = tags.some((t) => entry.tags.includes(t));
+    if (!hasMatch) return false;
+  }
+  if (opts.types) {
+    const types = Array.isArray(opts.types) ? opts.types : [opts.types];
+    if (!types.includes(entry.type)) return false;
+  }
+  if (opts.minConfidence !== void 0 && entry.confidence < opts.minConfidence) return false;
+  if (opts.scopes && !opts.scopes.includes(entry.scope)) return false;
+  return true;
+}
+__name(matchesContextFilters, "matchesContextFilters");
+function computeRelevance(entry) {
+  const ageHours = (now() - entry.createdAt) / (1e3 * 3600);
+  const recencyScore = Math.max(0.1, 1 / (1 + ageHours * 0.5));
+  const confidenceScore = entry.confidence;
+  const accessScore = 1 + entry.tags.length * 0.1;
+  const typeBoost = {
+    decision: 1.5,
+    context: 1.3,
+    preference: 1.2,
+    task: 1,
+    fact: 0.8
+  };
+  const scopeBoost = {
+    hot: 1.5,
+    session: 1.2,
+    local: 1,
+    durable: 0.8
+  };
+  return recencyScore * confidenceScore * accessScore * typeBoost[entry.type] * scopeBoost[entry.scope];
+}
+__name(computeRelevance, "computeRelevance");
+function getNestedPath(obj, path2) {
+  if (!path2 || typeof path2 !== "string") return void 0;
+  const parts = path2.replace(/^state\./, "").split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+__name(getNestedPath, "getNestedPath");
+function setNestedPath(obj, path2, value) {
+  if (!path2 || typeof path2 !== "string") return;
+  const parts = path2.replace(/^state\./, "").split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === void 0 || current[part] === null) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+__name(setNestedPath, "setNestedPath");
+function deleteNestedPath(obj, path2) {
+  if (!path2 || typeof path2 !== "string") return;
+  const parts = path2.replace(/^state\./, "").split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === void 0 || current[part] === null) return;
+    current = current[part];
+  }
+  delete current[parts[parts.length - 1]];
+}
+__name(deleteNestedPath, "deleteNestedPath");
+async function saveToScope(entry) {
+  const storageKey = entry.status === "superseded" ? memoryEntryKey(entry.id || entry.key) : entry.key;
+  const serialized = JSON.stringify(entry);
+  switch (entry.scope) {
+    case "hot":
+      setNestedPath(state2, storageKey, entry.value);
+      break;
+    case "session":
+      session.set(storageKey, serialized);
+      break;
+    case "local":
+      store.set(storageKey, serialized);
+      break;
+    case "durable":
+      await idb.set("memories", storageKey, serialized);
+      break;
+  }
+  await updateIndex(entry.id || entry.key, entry.scope, entry.status === "superseded");
+}
+__name(saveToScope, "saveToScope");
+async function loadFromScope(id, scope, isSuperseded = false) {
+  const storageKey = isSuperseded ? memoryEntryKey(id) : id;
+  let raw;
+  switch (scope) {
+    case "hot": {
+      const val = getNestedPath(state2, storageKey);
+      if (val === void 0) return null;
+      return reconstructEntry(id, val, scope);
+    }
+    case "session":
+      raw = session.get(storageKey);
+      break;
+    case "local":
+      raw = store.get(storageKey);
+      break;
+    case "durable":
+      raw = await idb.get("memories", storageKey);
+      break;
+  }
+  if (!raw) return null;
+  try {
+    const entry = JSON.parse(raw);
+    entry.id = entry.id || id;
+    return entry;
+  } catch (err) {
+    if (DEV) console.warn("[memorio memory] failed to parse memory entry:", err);
+    return null;
+  }
+}
+__name(loadFromScope, "loadFromScope");
+function reconstructEntry(key, value, scope) {
+  return {
+    id: key,
+    key,
+    value,
+    type: "fact",
+    confidence: 1,
+    scope,
+    ttl: null,
+    tags: [],
+    status: "active",
+    createdAt: now(),
+    lastConfirmedAt: now(),
+    supersededId: null
+  };
+}
+__name(reconstructEntry, "reconstructEntry");
+async function removeFromScope(id, scope, isSuperseded = false) {
+  const storageKey = isSuperseded ? memoryEntryKey(id) : id;
+  switch (scope) {
+    case "hot":
+      setNestedPath(state2, storageKey, void 0);
+      break;
+    case "session":
+      session.remove(storageKey);
+      break;
+    case "local":
+      store.remove(storageKey);
+      break;
+    case "durable":
+      await idb.deleteKey("memories", storageKey);
+      break;
+  }
+  await removeFromIndex(id, isSuperseded);
+}
+__name(removeFromScope, "removeFromScope");
+async function getAllIndexes() {
+  try {
+    const raw = store.get(MEMORY_INDEX_KEY);
+    if (!raw) return {};
+    return JSON.parse(raw);
+  } catch (err) {
+    if (DEV) console.warn("[memorio memory] failed to parse memory index:", err);
+    return {};
+  }
+}
+__name(getAllIndexes, "getAllIndexes");
+async function updateIndex(id, scope, isSuperseded = false) {
+  const index = await getAllIndexes();
+  index[id] = { scope, superseded: isSuperseded };
+  store.set(MEMORY_INDEX_KEY, JSON.stringify(index));
+}
+__name(updateIndex, "updateIndex");
+async function removeFromIndex(id, isSuperseded = false) {
+  const index = await getAllIndexes();
+  const entry = index[id];
+  if (entry) {
+    if (isSuperseded && entry.superseded) {
+      delete index[id];
+    } else if (!isSuperseded && !entry.superseded) {
+      delete index[id];
+    }
+  }
+  store.set(MEMORY_INDEX_KEY, JSON.stringify(index));
+}
+__name(removeFromIndex, "removeFromIndex");
+async function loadAll() {
+  const index = await getAllIndexes();
+  const entries = [];
+  for (const [id, info] of Object.entries(index)) {
+    const entry = await loadFromScope(id, info.scope, info.superseded);
+    if (entry) {
+      entry.id = entry.id || id;
+      entry.supersededId = entry.supersededId ?? null;
+      entries.push(entry);
+    }
+  }
+  return entries;
+}
+__name(loadAll, "loadAll");
+var memory = {
+  async remember(key, value, opts = {}) {
+    const existing = await this._getEntry(key);
+    if (existing && existing.status === "active") {
+      const supersededId = `${existing.id}__v${Date.now()}`;
+      const superseded = {
+        ...existing,
+        id: supersededId,
+        key: existing.key,
+        status: "superseded",
+        supersededId: null,
+        lastConfirmedAt: now()
+      };
+      await saveToScope(superseded);
+      await recordJournal(superseded, "supersede");
+    }
+    const scope = resolveScope(value, opts);
+    const tags = normalizeTags(opts.tags);
+    const entry = {
+      id: opts.id || key,
+      key,
+      value,
+      type: opts.type || "fact",
+      confidence: opts.confidence ?? 1,
+      scope,
+      ttl: opts.ttl ?? null,
+      tags,
+      source: opts.source,
+      status: "active",
+      createdAt: now(),
+      lastConfirmedAt: now(),
+      updatedAt: now(),
+      version: existing ? existing.version ? existing.version + 1 : 1 : 1,
+      sync: isSyncEnabled2() ? "pending" : void 0,
+      supersededId: existing ? existing.id : null,
+      hlc: hlc.serialize(hlc.tick())
+    };
+    await saveToScope(entry);
+    await recordJournal(entry, "remember");
+    dispatch.set("memorio:memory:remembered", { key, scope, entryId: entry.id });
+  },
+  async recall(query, opts = {}) {
+    const entry = await this._getEntry(query);
+    if (!entry) return null;
+    if (!matchesFilters(entry, opts)) return null;
+    entry.lastConfirmedAt = now();
+    await saveToScope(entry);
+    dispatch.set("memorio:memory:recalled", { key: query });
+    return entry.value;
+  },
+  async context(opts = {}) {
+    const entries = await loadAll();
+    const filtered = entries.filter((e) => matchesContextFilters(e, opts));
+    const ranked = filtered.map((entry) => ({
+      entry,
+      score: computeRelevance(entry)
+    })).sort((a, b) => b.score - a.score).slice(0, opts.maxEntries ?? 25);
+    return ranked.map(({ entry }) => ({
+      key: entry.key,
+      value: entry.value,
+      type: entry.type,
+      confidence: entry.confidence,
+      scope: entry.scope,
+      tags: entry.tags,
+      age: now() - entry.createdAt,
+      accessCount: entry.tags.length + 1,
+      lastAccessedAt: entry.lastConfirmedAt
+    }));
+  },
+  async forget(key) {
+    const entry = await this._getEntry(key);
+    if (!entry) {
+      const tombstone2 = {
+        id: key,
+        key,
+        value: null,
+        type: "fact",
+        confidence: 1,
+        scope: "local",
+        ttl: null,
+        tags: [],
+        status: "obsolete",
+        operation: "delete",
+        createdAt: now(),
+        lastConfirmedAt: now(),
+        updatedAt: now(),
+        version: 1,
+        sync: isSyncEnabled2() ? "pending" : void 0,
+        hlc: hlc.serialize(hlc.tick())
+      };
+      await recordJournal(tombstone2, "delete");
+      return;
+    }
+    await removeFromScope(entry.id || key, entry.scope, entry.status === "superseded");
+    const tombstone = {
+      ...entry,
+      value: null,
+      status: "obsolete",
+      operation: "delete",
+      updatedAt: now(),
+      version: (entry.version ? entry.version : 0) + 1,
+      sync: isSyncEnabled2() ? "pending" : void 0,
+      hlc: hlc.serialize(hlc.tick())
+    };
+    await recordJournal(tombstone, "delete");
+    dispatch.set("memorio:memory:forgotten", { key });
+  },
+  async update(key, value, opts = {}) {
+    const existing = await this._getEntry(key);
+    if (!existing) {
+      await this.remember(key, value, opts);
+      return;
+    }
+    const supersededId = `${existing.id}__v${now()}`;
+    const superseded = {
+      ...existing,
+      id: supersededId,
+      key: existing.key,
+      status: "superseded",
+      supersededId: null,
+      lastConfirmedAt: now()
+    };
+    await saveToScope(superseded);
+    await recordJournal(superseded, "supersede");
+    const updated = {
+      ...existing,
+      value,
+      lastConfirmedAt: now(),
+      updatedAt: now(),
+      version: (existing.version ? existing.version : 0) + 1,
+      sync: isSyncEnabled2() ? "pending" : void 0,
+      hlc: hlc.serialize(hlc.tick()),
+      ...opts.scope ? { scope: opts.scope } : {},
+      ...opts.ttl !== void 0 ? { ttl: opts.ttl } : {},
+      ...opts.type ? { type: opts.type } : {},
+      ...opts.confidence !== void 0 ? { confidence: opts.confidence } : {},
+      ...opts.tags !== void 0 ? { tags: normalizeTags(opts.tags) } : {},
+      ...opts.source ? { source: opts.source } : {}
+    };
+    await saveToScope(updated);
+    await recordJournal(updated, "update");
+    dispatch.set("memorio:memory:updated", { key, entryId: updated.id });
+  },
+  async stats() {
+    const entries = await loadAll();
+    const byScope = { hot: 0, session: 0, local: 0, durable: 0 };
+    const byType = {};
+    let expired = 0;
+    for (const entry of entries) {
+      byScope[entry.scope] = (byScope[entry.scope] || 0) + 1;
+      if (isExpired(entry)) expired++;
+      byType[entry.type] = (byType[entry.type] || 0) + 1;
+    }
+    return { total: entries.length, byScope, byType, expired };
+  },
+  async forgetExpired() {
+    const entries = await loadAll();
+    let count = 0;
+    for (const entry of entries) {
+      if (isExpired(entry) && entry.status === "active") {
+        entry.status = "obsolete";
+        entry.updatedAt = now();
+        entry.operation = "expire";
+        await saveToScope(entry);
+        await recordJournal(entry, "expire");
+        count++;
+      }
+    }
+    return count;
+  },
+  async clear() {
+    const index = await getAllIndexes();
+    for (const [id, info] of Object.entries(index)) {
+      await removeFromScope(id, info.scope, info.superseded);
+    }
+    store.remove(MEMORY_INDEX_KEY);
+  },
+  async _getEntry(key) {
+    const index = await getAllIndexes();
+    const info = index[key];
+    if (!info) {
+      const val = getNestedPath(state2, key);
+      if (val !== void 0) return reconstructEntry(key, val, "hot");
+      return null;
+    }
+    return loadFromScope(key, info.scope, info.superseded);
+  },
+  async _loadAll() {
+    return loadAll();
+  },
+  async _save(entry) {
+    await saveToScope(entry);
+  },
+  /** Apply a field-level path patch to an existing memory entry. */
+  async patch(key, patches) {
+    const entry = await this._getEntry(key);
+    if (!entry) return;
+    let patched = false;
+    for (const p of patches) {
+      if (p.op === "set") {
+        setNestedPath({ [entry.key]: entry.value }, p.path.replace(/^[^.]+\./, ""), p.value);
+        patched = true;
+      } else if (p.op === "delete") {
+        deleteNestedPath({ [entry.key]: entry.value }, p.path.replace(/^[^.]+\./, ""));
+        patched = true;
+      }
+    }
+    if (!patched) return;
+    const updated = {
+      ...entry,
+      updatedAt: now(),
+      lastConfirmedAt: now(),
+      version: (entry.version ? entry.version : 0) + 1,
+      sync: isSyncEnabled2() ? "pending" : void 0,
+      hlc: hlc.serialize(hlc.tick()),
+      patches,
+      path: patches[0]?.path
+    };
+    await saveToScope(updated);
+    await recordJournal(updated, "patch");
+    dispatch.set("memorio:memory:patched", { key, patches });
+  },
+  /** Local operation journal (namespaced). No-op substrate when sqlite/idb unavailable. */
+  journal: journal_default,
+  /** Configure the optional cloud-sync layer (namespace + provider). Chainable. */
+  configure(opts) {
+    configure(opts);
+    return this;
+  }
+};
+
+// adapters/redux/persist.ts
+function createPersistContext() {
+  return { cache: {}, hydrating: false, pending: false, dirty: /* @__PURE__ */ new Set() };
+}
+__name(createPersistContext, "createPersistContext");
+function schedulePersist(getState, mappings, ctx, opts) {
+  if (ctx.hydrating) return;
+  if (ctx.pending) return;
+  ctx.pending = true;
+  queueMicrotask(() => {
+    ctx.pending = false;
+    void flushPersist(getState, mappings, ctx, opts);
+  });
+}
+__name(schedulePersist, "schedulePersist");
+async function flushPersist(getState, mappings, ctx, opts) {
+  const keys = Array.from(ctx.dirty);
+  ctx.dirty.clear();
+  if (keys.length === 0) return;
+  const state3 = getState();
+  const values = selectValues(state3, mappings);
+  for (const key of keys) {
+    const mapping = mappings[key];
+    const next = values[key];
+    const prev = ctx.cache[key];
+    if (!deepEqual(next, prev)) {
+      ctx.cache[key] = next;
+      try {
+        await memory.remember(key, next, {
+          type: mapping.type,
+          confidence: mapping.confidence ?? 0.9,
+          scope: mapping.scope ?? "local",
+          ttl: mapping.ttl ?? null,
+          tags: mapping.tags,
+          source: mapping.source ?? "redux"
+        });
+        if (opts.debug) {
+          console.debug(`[memorio/redux] persisted "${key}"`);
+        }
+      } catch (err) {
+        if (opts.failSoft === false) throw err;
+        opts.onError?.(err, "persist");
+        if (opts.debug) {
+          console.debug(`[memorio/redux] persist failed for "${key}"`, err);
+        }
+      }
+    }
+  }
+}
+__name(flushPersist, "flushPersist");
+
+// adapters/redux/middleware.ts
+function createMemorioMiddleware(opts = {}) {
+  const mappings = normalizeMappings(opts.mappings);
+  const ctx = createPersistContext();
+  let getState = null;
+  const middleware = /* @__PURE__ */ __name((api) => {
+    getState = api.getState;
+    return (next) => (action) => {
+      const result = next(action);
+      if (shouldIgnoreAction(action, opts)) return result;
+      const dirty = collectDirtyMappings(action, opts, mappings);
+      if (dirty.length === 0) return result;
+      for (const key of dirty) ctx.dirty.add(key);
+      void schedulePersist(getState, mappings, ctx, opts);
+      return result;
+    };
+  }, "middleware");
+  return {
+    middleware,
+    cache: ctx.cache,
+    setHydrating: /* @__PURE__ */ __name((v) => {
+      ctx.hydrating = v;
+    }, "setHydrating"),
+    flush: /* @__PURE__ */ __name(() => getState ? flushPersist(getState, mappings, ctx, opts) : Promise.resolve(), "flush")
+  };
+}
+__name(createMemorioMiddleware, "createMemorioMiddleware");
+
+// adapters/redux/hydration.ts
+init_esm_shims();
+async function hydrateMemorio(mappings, opts = {}, bridge) {
+  const canonical = normalizeMappings(mappings);
+  const values = {};
+  let ok = true;
+  bridge?.setHydrating(true);
+  try {
+    for (const key of Object.keys(canonical)) {
+      try {
+        const recalled = await memory.recall(key);
+        if (recalled !== null && recalled !== void 0) values[key] = recalled;
+      } catch (err) {
+        ok = false;
+        if (opts.failSoft === false) throw err;
+        opts.onError?.(err, "hydrate");
+        if (opts.debug) {
+          console.debug(`[memorio/redux] hydrate recall failed for "${key}"`, err);
+        }
+      }
+    }
+    if (opts.onHydration) {
+      opts.onHydration(values);
+      if (bridge) {
+        const selected = selectValues(bridge.getState(), canonical);
+        for (const key of Object.keys(selected)) {
+          bridge.cache[key] = selected[key];
+        }
+      }
+    }
+  } finally {
+    bridge?.setHydrating(false);
+  }
+  return { values, ok };
+}
+__name(hydrateMemorio, "hydrateMemorio");
+
+// adapters/redux/bridge.ts
+init_esm_shims();
+function createMemorioReduxBridge(opts = {}) {
+  const handle = createMemorioMiddleware(opts);
+  let disconnected = false;
+  return {
+    middleware: handle.middleware,
+    cache: handle.cache,
+    flush: handle.flush,
+    disconnect: /* @__PURE__ */ __name(() => {
+      if (disconnected) return;
+      disconnected = true;
+      handle.cache && Object.keys(handle.cache).forEach((k) => delete handle.cache[k]);
+      handle.setHydrating(false);
+    }, "disconnect"),
+    hydrate: /* @__PURE__ */ __name(async (store2, hopts = {}) => {
+      const res = await hydrateMemorio(
+        opts.mappings,
+        {
+          failSoft: opts.failSoft,
+          onError: opts.onError,
+          debug: opts.debug,
+          onHydration: hopts.onHydration
+        },
+        {
+          cache: handle.cache,
+          setHydrating: handle.setHydrating,
+          getState: /* @__PURE__ */ __name(() => store2.getState(), "getState")
+        }
+      );
+      return { values: res.values, ok: res.ok };
+    }, "hydrate")
+  };
+}
+__name(createMemorioReduxBridge, "createMemorioReduxBridge");
+
+export { actionType, createMemorioMiddleware, createMemorioReduxBridge, deepEqual, hydrateMemorio, normalizeMappings, selectValues, shouldIgnoreAction };
+//# sourceMappingURL=redux.js.map
+//# sourceMappingURL=redux.js.map