memorio 4.9.31 → 5.0.0

package/global.js

@@ -0,0 +1,4532 @@
+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/env.ts
+var DEV, PROD;
+var init_env = __esm({
+  "core/env.ts"() {
+    init_esm_shims();
+    DEV = false ;
+    PROD = !DEV;
+    if (typeof globalThis !== "undefined") {
+      globalThis["__DEV__"] = DEV;
+    }
+  }
+});
+
+// core/internal.ts
+var INTERNAL_KEY, state, internal, protect, propertyName, 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"
+    ];
+    propertyName = /* @__PURE__ */ __name((container, object) => {
+      const target = object !== void 0 ? object : container;
+      return String(target).replace("() => ", "");
+    }, "propertyName");
+    internal_default = internal;
+  }
+});
+
+// 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 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 hasSqlJs() {
+  const anyGlobal = globalThis;
+  if (typeof anyGlobal.WebAssembly === "undefined" || typeof anyGlobal.WebAssembly.instantiate !== "function") {
+    return false;
+  }
+  return typeof anyGlobal.window !== "undefined";
+}
+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(),
+    hasSqlJs: hasSqlJs(),
+    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 {
+        static {
+          __name(this, "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: /* @__PURE__ */ __name((key) => {
+        const data = contextStorage.store.get(key);
+        return data ? JSON.parse(data) : null;
+      }, "get"),
+      set: /* @__PURE__ */ __name((key, value) => {
+        contextStorage.store.set(key, JSON.stringify(value));
+      }, "set"),
+      remove: /* @__PURE__ */ __name((key) => contextStorage.store.delete(key), "remove"),
+      removeAll: /* @__PURE__ */ __name(() => contextStorage.store.clear(), "removeAll"),
+      clearAll: /* @__PURE__ */ __name(() => contextStorage.store.clear(), "clearAll"),
+      size: /* @__PURE__ */ __name(() => contextStorage.store.size, "size"),
+      isPersistent: false
+    },
+    session: {
+      get: /* @__PURE__ */ __name((key) => {
+        const data = contextStorage.session.get(key);
+        return data ? JSON.parse(data) : null;
+      }, "get"),
+      set: /* @__PURE__ */ __name((key, value) => {
+        contextStorage.session.set(key, JSON.stringify(value));
+      }, "set"),
+      remove: /* @__PURE__ */ __name((key) => contextStorage.session.delete(key), "remove"),
+      removeAll: /* @__PURE__ */ __name(() => contextStorage.session.clear(), "removeAll"),
+      clearAll: /* @__PURE__ */ __name(() => contextStorage.session.clear(), "clearAll"),
+      size: /* @__PURE__ */ __name(() => contextStorage.session.size, "size"),
+      isPersistent: false
+    },
+    cache: {
+      get: /* @__PURE__ */ __name((key) => contextStorage.cache.get(key), "get"),
+      set: /* @__PURE__ */ __name((key, value) => contextStorage.cache.set(key, value), "set"),
+      remove: /* @__PURE__ */ __name((key) => contextStorage.cache.delete(key), "remove"),
+      removeAll: /* @__PURE__ */ __name(() => contextStorage.cache.clear(), "removeAll"),
+      clear: /* @__PURE__ */ __name(() => contextStorage.cache.clear(), "clear")
+    }
+  };
+}
+function listContexts() {
+  return Array.from(_contexts.keys());
+}
+function deleteContext(id) {
+  return _contexts.delete(id);
+}
+function setCurrentContext(id) {
+  internal_default.currentContext = id;
+}
+var _eventListenerStorage, CONTEXTS_KEY, _contexts;
+var init_platform = __esm({
+  "core/platform.ts"() {
+    init_esm_shims();
+    init_internal();
+    __name(generateSessionId, "generateSessionId");
+    __name(detectPlatform, "detectPlatform");
+    __name(isBrowser, "isBrowser");
+    __name(isNode, "isNode");
+    __name(isDeno, "isDeno");
+    __name(isEdge, "isEdge");
+    __name(getSessionStorage, "getSessionStorage");
+    __name(getLocalStorage, "getLocalStorage");
+    __name(hasIndexedDB, "hasIndexedDB");
+    __name(hasSqlJs, "hasSqlJs");
+    __name(hasDispatchEvent, "hasDispatchEvent");
+    __name(getCapabilities, "getCapabilities");
+    _eventListenerStorage = /* @__PURE__ */ new Map();
+    __name(initializePlatform, "initializePlatform");
+    CONTEXTS_KEY = "__memorio_contexts__";
+    _contexts = globalThis[CONTEXTS_KEY] || /* @__PURE__ */ new Map();
+    if (!globalThis[CONTEXTS_KEY]) {
+      globalThis[CONTEXTS_KEY] = _contexts;
+    }
+    __name(createContext, "createContext");
+    __name(listContexts, "listContexts");
+    __name(deleteContext, "deleteContext");
+    __name(setCurrentContext, "setCurrentContext");
+  }
+});
+
+// functions/store/index.ts
+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);
+}
+function _getPrefix() {
+  const contextName = internal_default.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 - operation aborted`);
+    return "";
+  }
+  if (name.length > 512) {
+    console.warn(`[memorio store] key "${name}" exceeds 512 chars - 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 _localStorage, _fallbackStorageByContext, _hasStorage, STORE_INSTANCE_KEY, store;
+var init_store = __esm({
+  "functions/store/index.ts"() {
+    init_esm_shims();
+    init_platform();
+    init_internal();
+    init_message();
+    _localStorage = getLocalStorage();
+    _fallbackStorageByContext = /* @__PURE__ */ new Map();
+    __name(_getFallbackStorage, "_getFallbackStorage");
+    _hasStorage = _localStorage !== null;
+    __name(_getPrefix, "_getPrefix");
+    __name(_prefixKey, "_prefixKey");
+    __name(_read, "_read");
+    __name(_write, "_write");
+    __name(_remove, "_remove");
+    STORE_INSTANCE_KEY = "__memorio_store_instance__";
+    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/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 transaction2 = db.transaction([table], "readonly");
+        const store2 = transaction2.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 transaction2 = db.transaction(table, "readwrite");
+          const objectStore = transaction2.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 transaction2 = db.transaction(table, "readwrite");
+          const store2 = transaction2.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 transaction2 = db.transaction(table, "readwrite");
+          const objectStore = transaction2.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 transaction2 = db.transaction(table, "readonly");
+          const store2 = transaction2.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.");
+      }
+    }
+  }
+});
+
+// functions/sqlite/tools/db.support.ts
+var db_support_exports2 = {};
+function _inDocument() {
+  const g3 = globalThis;
+  return typeof g3.document !== "undefined" && typeof g3.document.createElement === "function";
+}
+function _loadSqlJsScript(url) {
+  const g3 = globalThis;
+  if (g3.__memorioSqlJsScript === url) return Promise.resolve();
+  if (!_scriptLoaded) {
+    _scriptLoaded = new Promise((resolve, reject) => {
+      if (g3.initSqlJs && typeof g3.initSqlJs === "function") {
+        g3.__memorioSqlJsScript = url;
+        resolve();
+        return;
+      }
+      if (!_inDocument()) {
+        reject(new Error("memorio sqlite: no document available to load sql.js"));
+        return;
+      }
+      const script = g3.document.createElement("script");
+      script.src = url;
+      script.async = true;
+      script.onload = () => {
+        g3.__memorioSqlJsScript = url;
+        resolve();
+      };
+      script.onerror = () => reject(new Error(`memorio sqlite: failed to load sql.js from ${url}`));
+      g3.document.head.appendChild(script);
+    });
+  }
+  return _scriptLoaded;
+}
+var _loading, _SQL, _defaultLocateFile, _scriptLoaded, _loadSqlJsFromCdn;
+var init_db_support2 = __esm({
+  "functions/sqlite/tools/db.support.ts"() {
+    init_esm_shims();
+    init_sqlite();
+    init_platform();
+    init_message();
+    _loading = null;
+    _SQL = null;
+    _defaultLocateFile = /* @__PURE__ */ __name((file) => {
+      const g3 = globalThis;
+      const base = g3.sqliteWasmBase || "";
+      return base + file;
+    }, "_defaultLocateFile");
+    _scriptLoaded = null;
+    __name(_inDocument, "_inDocument");
+    __name(_loadSqlJsScript, "_loadSqlJsScript");
+    _loadSqlJsFromCdn = /* @__PURE__ */ __name(async (url) => {
+      const g3 = globalThis;
+      if (!url) {
+        throw new Error('memorio sqlite: no loader configured. Install sql.js (npm i sql.js) and pass a loader via sqlite.config({ loader: () => import("sql.js") }).');
+      }
+      if (typeof g3.initSqlJs === "function") return g3.initSqlJs;
+      await _loadSqlJsScript(url);
+      return g3.initSqlJs || g3;
+    }, "_loadSqlJsFromCdn");
+    sqlite.db.support = () => {
+      return hasSqlJs();
+    };
+    sqlite.db.getSQL = async () => {
+      if (_SQL) return _SQL;
+      if (_loading) return _loading;
+      const g3 = globalThis;
+      const cfg = g3.sqliteConfig || {};
+      const p = (async () => {
+        if (typeof cfg.loader === "function") {
+          return await cfg.loader();
+        }
+        if (cfg.scriptUrl) {
+          const mod = await _loadSqlJsFromCdn(cfg.scriptUrl);
+          const initSqlJs = typeof mod === "function" ? mod : mod && (mod.default || mod);
+          const SQL = await initSqlJs({ locateFile: cfg.locateFile || _defaultLocateFile });
+          g3.sqliteVersion = SQL?.version || "sql.js";
+          message_default("Memorio SQLite: sql.js engine loaded");
+          return SQL;
+        }
+        throw new Error('memorio sqlite: no loader configured. Install sql.js (npm i sql.js) and pass a loader via sqlite.config({ loader: () => import("sql.js") }).');
+      })();
+      _loading = p;
+      try {
+        _SQL = await p;
+        return _SQL;
+      } catch (err) {
+        try {
+          sqlite._disabled = true;
+        } catch (_) {
+        }
+        try {
+          sqlite._warning = "Memorio SQLite: sql.js could not be loaded. Install sql.js (npm i sql.js) and pass a loader via sqlite.config({ loader: () => <your sql.js import>() }).";
+        } catch (_) {
+        }
+        console.warn("Memorio SQLite: failed to load sql.js", err);
+        throw err;
+      } finally {
+        _loading = null;
+      }
+    };
+    sqlite.db.version = () => {
+      return globalThis.sqliteVersion || null;
+    };
+  }
+});
+
+// functions/sqlite/tools/persist.ts
+function _ns() {
+  const cfg = g.sqliteConfig || {};
+  return cfg.namespace ? `ns:${cfg.namespace}` : "default";
+}
+function _key(name) {
+  return `memorio:sqlite:db:${_ns()}:${name}`;
+}
+function _b64encode(buf) {
+  const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
+  let binary = "";
+  const len = bytes.byteLength;
+  for (let i = 0; i < len; i++) binary += String.fromCharCode(bytes[i]);
+  if (typeof btoa === "function") return btoa(binary);
+  return typeof Buffer !== "undefined" ? Buffer.from(bytes).toString("base64") : "";
+}
+function _b64decode(b64) {
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(b64, "base64"));
+  }
+  if (typeof atob !== "function") {
+    throw new Error("memorio sqlite: no base64 decoder available");
+  }
+  const binary = atob(b64);
+  const len = binary.length;
+  const out = new Uint8Array(len);
+  for (let i = 0; i < len; i++) out[i] = binary.charCodeAt(i);
+  return out;
+}
+function saveSnapshot(name) {
+  return new Promise((resolve) => {
+    const db = g.__sqliteDbs && g.__sqliteDbs[name];
+    if (!db || typeof db.export !== "function") {
+      resolve(false);
+      return;
+    }
+    try {
+      const blob = db.export();
+      store.set(_key(name), _b64encode(blob));
+      message_default(`Memorio SQLite: persisted '${name}' to store`);
+      resolve(true);
+    } catch (err) {
+      console.warn("Memorio SQLite: persist snapshot failed", err);
+      resolve(false);
+    }
+  });
+}
+function loadSnapshot(name) {
+  const b64 = store.get(_key(name));
+  if (!b64) return null;
+  try {
+    return _b64decode(b64);
+  } catch {
+    return null;
+  }
+}
+function removeSnapshot(name) {
+  store.remove(_key(name));
+}
+function attachAutoExport(name, db) {
+  if (!db || typeof db.updateHook !== "function") return;
+  _persistDbs[name] = true;
+  try {
+    db.updateHook(() => {
+      if (_exportTimers[name]) clearTimeout(_exportTimers[name]);
+      _exportTimers[name] = setTimeout(() => {
+        _exportTimers[name] = null;
+        void saveSnapshot(name);
+      }, 250);
+    });
+  } catch (err) {
+    console.warn("Memorio SQLite: could not attach updateHook", err);
+  }
+}
+var g, _persistDbs, _exportTimers;
+var init_persist = __esm({
+  "functions/sqlite/tools/persist.ts"() {
+    init_esm_shims();
+    init_sqlite();
+    init_store();
+    init_message();
+    g = globalThis;
+    _persistDbs = {};
+    _exportTimers = {};
+    __name(_ns, "_ns");
+    __name(_key, "_key");
+    __name(_b64encode, "_b64encode");
+    __name(_b64decode, "_b64decode");
+    __name(saveSnapshot, "saveSnapshot");
+    __name(loadSnapshot, "loadSnapshot");
+    __name(removeSnapshot, "removeSnapshot");
+    __name(attachAutoExport, "attachAutoExport");
+    sqlite.db.persist = async (name = "memorio") => {
+      return saveSnapshot(name);
+    };
+    sqlite.db.download = async (name = "memorio", filename = `${name}.sqlite`) => {
+      const g3 = globalThis;
+      const db = g3.__sqliteDbs && g3.__sqliteDbs[name];
+      if (!db) {
+        console.warn(`Memorio SQLite: cannot download '${name}' - database not found. Create it with sqlite.db.create('${name}').`);
+        return false;
+      }
+      let blob;
+      try {
+        blob = await sqlite.db.export(name);
+      } catch (err) {
+        console.warn("Memorio SQLite: export failed during download", err);
+        return false;
+      }
+      if (!blob) return false;
+      if (typeof g3.document === "undefined" || typeof g3.Blob === "undefined") {
+        console.warn("Memorio SQLite: sqlite.db.download() requires a browser environment.");
+        return false;
+      }
+      const URL = g3.URL || g3.webkitURL;
+      if (!URL || typeof URL.createObjectURL !== "function") return false;
+      const objectUrl = URL.createObjectURL(new Blob([blob], { type: "application/x-sqlite3" }));
+      const a = g3.document.createElement("a");
+      a.style.display = "none";
+      a.href = objectUrl;
+      a.download = filename;
+      g3.document.body.appendChild(a);
+      a.click();
+      setTimeout(() => {
+        try {
+          URL.revokeObjectURL(objectUrl);
+        } catch (_) {
+        }
+        a.remove();
+      }, 1e3);
+      return true;
+    };
+    sqlite.db.close = async (name = "memorio") => {
+      const db = g.__sqliteDbs && g.__sqliteDbs[name];
+      if (db && typeof db.close === "function") {
+        try {
+          await saveSnapshot(name);
+        } catch (_) {
+        }
+        try {
+          db.close();
+        } catch (err) {
+          console.warn("Memorio SQLite: close failed", err);
+        }
+      }
+      if (g.__sqliteDbs) delete g.__sqliteDbs[name];
+      if (g.sqlbases) {
+        const idx = g.sqlbases.findIndex((x) => x && x.name === name);
+        if (idx > -1) g.sqlbases.splice(idx, 1);
+      }
+      delete _persistDbs[name];
+      if (_exportTimers[name]) {
+        clearTimeout(_exportTimers[name]);
+        _exportTimers[name] = null;
+      }
+      removeSnapshot(name);
+    };
+    sqlite.db.loadSnapshot = loadSnapshot;
+    sqlite.db.saveSnapshot = saveSnapshot;
+  }
+});
+
+// functions/sqlite/tools/db.create.ts
+var db_create_exports2 = {};
+var init_db_create2 = __esm({
+  "functions/sqlite/tools/db.create.ts"() {
+    init_esm_shims();
+    init_sqlite();
+    init_message();
+    init_persist();
+    sqlite.db.create = async (name = "memorio", opts = {}) => {
+      const SQL = await sqlite.db.getSQL();
+      const g3 = globalThis;
+      const persistence = !!(opts && opts.persistence) || !!(g3.sqliteConfig && g3.sqliteConfig.persistence);
+      let data;
+      if (persistence && !opts.data) {
+        const restored = loadSnapshot(name);
+        if (restored) data = restored;
+      }
+      const useData = opts && opts.data || data;
+      let db;
+      if (useData && typeof useData.byteLength === "number") {
+        db = new SQL.Database(useData);
+        message_default(`Memorio SQLite: database '${name}' opened (persistence=${persistence})`);
+      } else {
+        db = new SQL.Database();
+        message_default(`Memorio SQLite: database '${name}' created (persistence=${persistence})`);
+      }
+      const createOpts = { ...opts, persistence };
+      if (!g3.__sqliteDbs) g3.__sqliteDbs = {};
+      g3.__sqliteDbs[name] = db;
+      if (!g3.sqlbases) g3.sqlbases = [];
+      const idx = g3.sqlbases.findIndex((x) => x && x.name === name);
+      if (idx > -1) {
+        g3.sqlbases[idx] = { name, db, persistence: createOpts.persistence };
+      } else {
+        g3.sqlbases.push({ name, db, persistence: createOpts.persistence });
+      }
+      if (persistence) attachAutoExport(name, db);
+      return db;
+    };
+  }
+});
+
+// functions/sqlite/tools/db.get.ts
+var db_get_exports = {};
+var init_db_get = __esm({
+  "functions/sqlite/tools/db.get.ts"() {
+    init_esm_shims();
+    init_sqlite();
+    sqlite.db.get = (name = "memorio") => {
+      const dbs = globalThis.__sqliteDbs;
+      if (!dbs || !dbs[name]) {
+        throw new Error(
+          `SQLite database '${name}' does not exist. Create it with sqlite.db.create('${name}').`
+        );
+      }
+      return dbs[name];
+    };
+  }
+});
+
+// functions/sqlite/tools/db.delete.ts
+var db_delete_exports2 = {};
+var init_db_delete2 = __esm({
+  "functions/sqlite/tools/db.delete.ts"() {
+    init_esm_shims();
+    init_sqlite();
+    init_message();
+    sqlite.db.delete = (name) => {
+      const dbs = globalThis.__sqliteDbs;
+      if (!dbs || !dbs[name]) return false;
+      try {
+        dbs[name].close();
+      } catch (_) {
+      }
+      delete dbs[name];
+      const g3 = globalThis;
+      if (g3.sqlbases) g3.sqlbases = g3.sqlbases.filter((x) => x && x.name !== name);
+      message_default(`Memorio SQLite: database '${name}' deleted`);
+      return true;
+    };
+  }
+});
+
+// functions/sqlite/tools/db.list.ts
+var db_list_exports2 = {};
+var init_db_list2 = __esm({
+  "functions/sqlite/tools/db.list.ts"() {
+    init_esm_shims();
+    init_sqlite();
+    sqlite.db.list = () => {
+      const dbs = globalThis.__sqliteDbs;
+      return dbs ? Object.keys(dbs) : [];
+    };
+  }
+});
+
+// functions/sqlite/tools/db.size.ts
+var db_size_exports2 = {};
+var init_db_size2 = __esm({
+  "functions/sqlite/tools/db.size.ts"() {
+    init_esm_shims();
+    init_sqlite();
+    sqlite.db.size = async (name) => {
+      const dbs = globalThis.__sqliteDbs;
+      if (!dbs) return 0;
+      const _bytes = /* @__PURE__ */ __name((b) => b ? b.byteLength || b.length || 0 : 0, "_bytes");
+      if (name) {
+        const db = sqlite.db.get(name);
+        return _bytes(db.export());
+      }
+      let total = 0;
+      for (const n of Object.keys(dbs)) {
+        try {
+          total += _bytes(dbs[n].export());
+        } catch (_) {
+        }
+      }
+      return total;
+    };
+  }
+});
+
+// functions/sqlite/tools/db.export.ts
+var db_export_exports = {};
+var init_db_export = __esm({
+  "functions/sqlite/tools/db.export.ts"() {
+    init_esm_shims();
+    init_sqlite();
+    sqlite.db.export = async (name = "memorio") => {
+      const db = sqlite.db.get(name);
+      return db.export();
+    };
+  }
+});
+
+// functions/sqlite/tools/db.import.ts
+var db_import_exports = {};
+var init_db_import = __esm({
+  "functions/sqlite/tools/db.import.ts"() {
+    init_esm_shims();
+    init_sqlite();
+    sqlite.db.import = async (name, data) => {
+      return sqlite.db.create(name, { data });
+    };
+  }
+});
+
+// functions/sqlite/crud/query.run.ts
+var query_run_exports = {};
+var init_query_run = __esm({
+  "functions/sqlite/crud/query.run.ts"() {
+    init_esm_shims();
+    init_sqlite();
+    init_message();
+    sqlite.query.run = async (name = "memorio", sql, params = []) => {
+      const db = sqlite.db.get(name);
+      message_default(`Memorio SQLite: run -> ${sql}`);
+      db.run(sql, params);
+      return db.getRowsModified();
+    };
+  }
+});
+
+// functions/sqlite/crud/query.select.ts
+var query_select_exports = {};
+var init_query_select = __esm({
+  "functions/sqlite/crud/query.select.ts"() {
+    init_esm_shims();
+    init_sqlite();
+    sqlite.query.select = async (name = "memorio", sql, params = []) => {
+      const db = sqlite.db.get(name);
+      const stmt = db.prepare(sql, params);
+      const result = [];
+      try {
+        while (stmt.step()) {
+          result.push(stmt.getAsObject());
+        }
+      } finally {
+        try {
+          stmt.free();
+        } catch (_) {
+        }
+      }
+      return result;
+    };
+  }
+});
+
+// functions/sqlite/crud/data.set.ts
+var data_set_exports2 = {};
+var init_data_set2 = __esm({
+  "functions/sqlite/crud/data.set.ts"() {
+    init_esm_shims();
+    init_sqlite();
+    sqlite.data.set = async (name = "memorio", sql, params = []) => {
+      return sqlite.query.run(name, sql, params);
+    };
+  }
+});
+
+// functions/sqlite/crud/data.get.ts
+var data_get_exports2 = {};
+var init_data_get2 = __esm({
+  "functions/sqlite/crud/data.get.ts"() {
+    init_esm_shims();
+    init_sqlite();
+    sqlite.data.get = async (name = "memorio", sql, params = []) => {
+      const rows = await sqlite.query.select(name, sql, params);
+      return rows.length ? rows[0] : null;
+    };
+  }
+});
+
+// functions/sqlite/index.ts
+var _hasSqlJs, sqlite;
+var init_sqlite = __esm({
+  "functions/sqlite/index.ts"() {
+    init_esm_shims();
+    init_platform();
+    init_env();
+    _hasSqlJs = hasSqlJs();
+    sqlite = {
+      db: {},
+      query: {},
+      data: {}
+    };
+    sqlite.config = (opts) => {
+      const g3 = globalThis;
+      g3.sqliteConfig = { ...g3.sqliteConfig, ...opts };
+      if (opts && opts.wasmUrl) {
+        g3.sqliteWasmBase = opts.wasmUrl.endsWith("/") ? opts.wasmUrl : opts.wasmUrl + "/";
+      }
+      return sqlite;
+    };
+    Object.defineProperty(sqlite, "ready", {
+      enumerable: false,
+      configurable: false,
+      get: /* @__PURE__ */ __name(() => {
+        const g3 = globalThis;
+        if (!g3.sqliteReady) {
+          g3.sqliteReady = typeof sqlite.db.getSQL === "function" ? sqlite.db.getSQL().then(() => {
+          }).catch(() => {
+          }) : Promise.resolve();
+        }
+        return g3.sqliteReady;
+      }, "get")
+    });
+    if (_hasSqlJs) {
+      (async () => {
+        Object.defineProperty(sqlite, "db", { value: {}, writable: false, configurable: true, enumerable: true });
+        Object.defineProperty(sqlite, "query", { value: {}, writable: false, configurable: true, enumerable: true });
+        Object.defineProperty(sqlite, "data", { value: {}, writable: false, configurable: true, enumerable: true });
+        Object.defineProperty(globalThis, "sqlbases", {
+          value: [],
+          writable: true,
+          configurable: true,
+          enumerable: false
+        });
+        await Promise.all([
+          Promise.resolve().then(() => (init_db_support2(), db_support_exports2)),
+          Promise.resolve().then(() => (init_db_create2(), db_create_exports2)),
+          Promise.resolve().then(() => (init_db_get(), db_get_exports)),
+          Promise.resolve().then(() => (init_db_delete2(), db_delete_exports2)),
+          Promise.resolve().then(() => (init_db_list2(), db_list_exports2)),
+          Promise.resolve().then(() => (init_db_size2(), db_size_exports2)),
+          Promise.resolve().then(() => (init_db_export(), db_export_exports)),
+          Promise.resolve().then(() => (init_db_import(), db_import_exports)),
+          Promise.resolve().then(() => (init_query_run(), query_run_exports)),
+          Promise.resolve().then(() => (init_query_select(), query_select_exports)),
+          Promise.resolve().then(() => (init_data_set2(), data_set_exports2)),
+          Promise.resolve().then(() => (init_data_get2(), data_get_exports2))
+        ]);
+      })();
+    } else {
+      sqlite._disabled = true;
+      sqlite._warning = 'SQLite (sql.js) is not available in this environment. It requires a browser with WebAssembly support. Install the optional "sql.js" package to enable it.';
+      if (DEV) {
+        globalThis.sqliteDisabled = true;
+        globalThis.sqliteWarning = sqlite._warning;
+        console.warn("Memorio SQLite: sql.js is not available in this environment (requires browser + WebAssembly). Use store or session for persistence.");
+      }
+    }
+  }
+});
+
+// global.ts
+init_esm_shims();
+
+// index.ts
+init_esm_shims();
+init_env();
+
+// 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(() => {
+          try {
+            cb(target);
+          } catch (err) {
+            if (typeof console !== "undefined") {
+              console.error("[memorio dispatch] observer error:", err);
+            }
+          }
+        });
+      } else {
+        Promise.resolve().then(() => {
+          try {
+            cb(target);
+          } catch (err) {
+            if (typeof console !== "undefined") {
+              console.error("[memorio dispatch] observer error:", err);
+            }
+          }
+        });
+      }
+    }, "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_store();
+init_env();
+
+// core/mutation/engine.ts
+init_esm_shims();
+init_internal();
+
+// 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
+};
+
+// core/mutation/id.ts
+init_esm_shims();
+function generateMutationId() {
+  const now2 = hlc.tick();
+  return "m_" + encodeHLC(now2);
+}
+__name(generateMutationId, "generateMutationId");
+function generateTransactionId() {
+  const now2 = hlc.tick();
+  return "tx_" + encodeHLC(now2);
+}
+__name(generateTransactionId, "generateTransactionId");
+function generateCommitId() {
+  const now2 = hlc.tick();
+  return "c_" + encodeHLC(now2);
+}
+__name(generateCommitId, "generateCommitId");
+function encodeHLC(hlcValue) {
+  const timePart = hlcValue.physical.toString(36);
+  const logicalPart = hlcValue.logical.toString(36).padStart(2, "0");
+  const nodePart = hlcValue.node.slice(0, 4);
+  return `${timePart}${logicalPart}${nodePart}`;
+}
+__name(encodeHLC, "encodeHLC");
+
+// core/mutation/patch.ts
+init_esm_shims();
+function mutationToPatch(mutation) {
+  if (mutation.before === mutation.after) return null;
+  const op = mutationToPatchOp(mutation.operation, mutation.before, mutation.after);
+  if (!op) return null;
+  const patch = { op, path: mutation.path };
+  if (op === "add" || op === "replace") {
+    patch.value = mutation.after;
+  }
+  if (op === "replace") {
+    patch.oldValue = mutation.before;
+  }
+  if (op === "remove") {
+    patch.oldValue = mutation.before;
+  }
+  return patch;
+}
+__name(mutationToPatch, "mutationToPatch");
+function mutationToPatchOp(operation, _before, _after) {
+  switch (operation) {
+    case "set":
+      if (_before === void 0) return "add";
+      return "replace";
+    case "delete":
+      return "remove";
+    case "insert":
+      return "add";
+    case "remove":
+      return "remove";
+    case "replace":
+      return "replace";
+    case "length":
+      return "replace";
+    default:
+      return null;
+  }
+}
+__name(mutationToPatchOp, "mutationToPatchOp");
+function diffToPatch(path2, before2, after2) {
+  if (before2 === after2) return null;
+  if (after2 === void 0) {
+    return { op: "remove", path: path2, oldValue: before2 };
+  }
+  if (before2 === void 0) {
+    return { op: "add", path: path2, value: after2 };
+  }
+  return { op: "replace", path: path2, value: after2, oldValue: before2 };
+}
+__name(diffToPatch, "diffToPatch");
+function canMerge(patch1, patch2) {
+  return patch1.path === patch2.path && patch1.op === patch2.op;
+}
+__name(canMerge, "canMerge");
+function mergePatches(patch1, patch2) {
+  const op = patch1.op === "remove" && patch2.op === "remove" ? "remove" : "replace";
+  return {
+    op,
+    path: patch1.path,
+    value: patch2.value ?? patch1.value,
+    oldValue: patch1.oldValue
+  };
+}
+__name(mergePatches, "mergePatches");
+
+// core/mutation/transaction.ts
+init_esm_shims();
+init_internal();
+var TX_REGISTRY_KEY = "__memorio_transaction_registry__";
+var registry = globalThis[TX_REGISTRY_KEY] || /* @__PURE__ */ new Map();
+if (!globalThis[TX_REGISTRY_KEY]) {
+  globalThis[TX_REGISTRY_KEY] = registry;
+}
+var TX_STACK_KEY = "__memorio_transaction_stack__";
+var txStack = globalThis[TX_STACK_KEY] || [];
+if (!globalThis[TX_STACK_KEY]) {
+  globalThis[TX_STACK_KEY] = txStack;
+}
+function getActiveTxId() {
+  return txStack.length > 0 ? txStack[txStack.length - 1] : null;
+}
+__name(getActiveTxId, "getActiveTxId");
+function setActiveTx(id) {
+  if (id === null) {
+    txStack.pop();
+  } else {
+    txStack.push(id);
+  }
+}
+__name(setActiveTx, "setActiveTx");
+function beginTransaction(source, message2, metadata) {
+  const id = generateTransactionId();
+  const ctx = {
+    id,
+    startedAt: hlc.serialize(hlc.tick()),
+    source,
+    message: message2,
+    metadata,
+    mutations: [],
+    active: true
+  };
+  registry.set(id, ctx);
+  setActiveTx(id);
+  return ctx;
+}
+__name(beginTransaction, "beginTransaction");
+function tagForTransaction() {
+  const txId = getActiveTxId();
+  if (!txId) return void 0;
+  const ctx = registry.get(txId);
+  if (ctx && ctx.active) {
+    return txId;
+  }
+  return void 0;
+}
+__name(tagForTransaction, "tagForTransaction");
+function commitTransaction() {
+  const txId = getActiveTxId();
+  if (!txId) return null;
+  const ctx = registry.get(txId);
+  if (!ctx || !ctx.active) return null;
+  ctx.active = false;
+  ctx.committedAt = hlc.serialize(hlc.tick());
+  const tx = {
+    id: ctx.id,
+    mutations: ctx.mutations,
+    startedAt: ctx.startedAt,
+    committedAt: ctx.committedAt,
+    source: ctx.source,
+    message: ctx.message,
+    metadata: ctx.metadata
+  };
+  setActiveTx(null);
+  return tx;
+}
+__name(commitTransaction, "commitTransaction");
+function _setPath(path2, value) {
+  const parts = path2.replace(/^state\./, "").split(".");
+  let current = globalThis.state;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === void 0) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+__name(_setPath, "_setPath");
+function _deletePath(path2) {
+  const parts = path2.replace(/^state\./, "").split(".");
+  let current = globalThis.state;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === void 0) return;
+    current = current[part];
+  }
+  if (current.remove) {
+    current.remove(parts[parts.length - 1]);
+  } else {
+    delete current[parts[parts.length - 1]];
+  }
+}
+__name(_deletePath, "_deletePath");
+function _applyInverse(record) {
+  const wasEnabled = internal_default.historyEnabled;
+  const wasRecording = internal_default._recording;
+  internal_default.historyEnabled = false;
+  internal_default._recording = false;
+  try {
+    if (record.action === "set" || record.operation === "set") {
+      if (record.previousValue === void 0) {
+        _deletePath(record.path);
+      } else {
+        _setPath(record.path, record.previousValue);
+      }
+    } else if (record.action === "delete" || record.operation === "delete") {
+      if (record.previousValue !== void 0) {
+        _setPath(record.path, record.previousValue);
+      }
+    }
+  } finally {
+    internal_default.historyEnabled = wasEnabled;
+    internal_default._recording = wasRecording;
+  }
+}
+__name(_applyInverse, "_applyInverse");
+function abortTransaction() {
+  const txId = getActiveTxId();
+  if (!txId) return null;
+  const ctx = registry.get(txId);
+  if (!ctx || !ctx.active) return null;
+  for (let i = ctx.mutations.length - 1; i >= 0; i--) {
+    const undoStack = internal_default.undoStack;
+    const idx = undoStack.findIndex((r) => r.id === ctx.mutations[i]);
+    if (idx >= 0) {
+      const record = undoStack[idx];
+      internal_default.undoStack.splice(idx, 1);
+      _applyInverse(record);
+    }
+  }
+  ctx.active = false;
+  ctx.committedAt = hlc.serialize(hlc.tick());
+  const tx = {
+    id: ctx.id,
+    mutations: ctx.mutations,
+    startedAt: ctx.startedAt,
+    committedAt: ctx.committedAt,
+    source: ctx.source,
+    message: ctx.message,
+    metadata: ctx.metadata
+  };
+  registry.delete(txId);
+  setActiveTx(null);
+  return tx;
+}
+__name(abortTransaction, "abortTransaction");
+function listTransactions() {
+  const result = [];
+  for (const ctx of registry.values()) {
+    result.push({
+      id: ctx.id,
+      mutations: ctx.mutations,
+      startedAt: ctx.startedAt,
+      committedAt: ctx.committedAt,
+      source: ctx.source,
+      message: ctx.message,
+      metadata: ctx.metadata
+    });
+  }
+  return result;
+}
+__name(listTransactions, "listTransactions");
+function currentTransaction() {
+  const txId = getActiveTxId();
+  if (!txId) return null;
+  const ctx = registry.get(txId);
+  if (!ctx || !ctx.active) return null;
+  return {
+    id: ctx.id,
+    mutations: ctx.mutations,
+    startedAt: ctx.startedAt,
+    source: ctx.source,
+    message: ctx.message,
+    metadata: ctx.metadata
+  };
+}
+__name(currentTransaction, "currentTransaction");
+function registerMutationInTransaction(mutationId) {
+  const txId = getActiveTxId();
+  if (!txId) return;
+  const ctx = registry.get(txId);
+  if (ctx && ctx.active) {
+    ctx.mutations.push(mutationId);
+  }
+}
+__name(registerMutationInTransaction, "registerMutationInTransaction");
+
+// core/mutation/engine.ts
+function currentTimestamp() {
+  return hlc.serialize(hlc.tick());
+}
+__name(currentTimestamp, "currentTimestamp");
+function createMutation(path2, operation, before2, after2, options) {
+  const now2 = hlc.tick();
+  const mutation = {
+    id: generateMutationId(),
+    path: path2,
+    operation,
+    after: after2,
+    before: before2,
+    timestamp: now2.physical,
+    hlc: hlc.serialize(now2),
+    context: options?.context || internal_default.currentContext || void 0,
+    source: options?.source,
+    transactionId: options?.transactionId || (operation !== "length" ? tagForTransaction() : void 0),
+    // Legacy fields for backward compatibility
+    action: operation === "set" ? "set" : "delete",
+    newValue: after2,
+    previousValue: before2
+  };
+  if (mutation.transactionId) {
+    registerMutationInTransaction(mutation.id);
+  }
+  return mutation;
+}
+__name(createMutation, "createMutation");
+function recordMutation(mutation) {
+  if (!internal_default.historyEnabled) return;
+  internal_default.recordMutation(mutation);
+}
+__name(recordMutation, "recordMutation");
+function toPatch(mutation) {
+  return mutationToPatch(mutation);
+}
+__name(toPatch, "toPatch");
+function mutate(path2, value, options) {
+  const normalizedPath = path2.startsWith("state.") ? path2 : "state." + path2;
+  const keyPath = normalizedPath.replace(/^state\./, "");
+  let current;
+  try {
+    const parts2 = keyPath.split(".");
+    let obj = globalThis.state;
+    for (const part of parts2) {
+      obj = obj?.[part];
+    }
+    current = obj;
+  } catch {
+    current = void 0;
+  }
+  const operation = value === void 0 ? "delete" : "set";
+  const mutation = createMutation(
+    normalizedPath,
+    operation,
+    current,
+    value === void 0 ? void 0 : value,
+    options
+  );
+  const wasRecording = internal_default._recording;
+  internal_default._recording = false;
+  const parts = keyPath.split(".");
+  let target = globalThis.state;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (target[parts[i]] === void 0) {
+      target[parts[i]] = {};
+    }
+    target = target[parts[i]];
+  }
+  if (operation === "delete") {
+    delete target[parts[parts.length - 1]];
+  } else {
+    target[parts[parts.length - 1]] = value;
+  }
+  internal_default._recording = wasRecording;
+  recordMutation(mutation);
+  return mutation;
+}
+__name(mutate, "mutate");
+function activeTransactionId() {
+  return internal_default.currentTransactionId || null;
+}
+__name(activeTransactionId, "activeTransactionId");
+
+// functions/state/index.ts
+var TARGET = /* @__PURE__ */ Symbol("memorio.target");
+var wrapperCache = /* @__PURE__ */ new WeakMap();
+var arrayRootDedup = /* @__PURE__ */ new Set();
+var deepRaw = /* @__PURE__ */ __name((val, seen = null) => {
+  if (val === null || typeof val !== "object") return val;
+  if (!seen) seen = /* @__PURE__ */ new WeakSet();
+  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)) {
+    if (!Object.prototype.propertyIsEnumerable.call(val, k)) continue;
+    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 of Reflect.ownKeys(target)) {
+                if (typeof target[key] !== "function" && !["list", "remove", "removeAll", "lock", "unlock", "persist"].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);
+          if (Array.isArray(target) && tree.length > 0) {
+            const rootName = "state." + tree.join(".");
+            if (!arrayRootDedup.has(rootName)) {
+              arrayRootDedup.add(rootName);
+              event(rootName);
+              if (typeof globalThis.queueMicrotask === "function") {
+                globalThis.queueMicrotask(() => arrayRootDedup.clear());
+              }
+            }
+          }
+          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 });
+          event("state." + path2);
+          if (Array.isArray(target) && tree.length > 0) {
+            const rootName = "state." + tree.join(".");
+            if (!arrayRootDedup.has(rootName)) {
+              arrayRootDedup.add(rootName);
+              event(rootName);
+              if (typeof globalThis.queueMicrotask === "function") {
+                globalThis.queueMicrotask(() => arrayRootDedup.clear());
+              }
+            }
+          }
+          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._recording !== false) {
+      const operation = mutation.action === "delete" ? "delete" : "set";
+      const record = createMutation(
+        mutation.path,
+        operation,
+        mutation.previousValue,
+        mutation.newValue,
+        {
+          context: mutation.context,
+          source: mutation.source
+        }
+      );
+      internal_default.recordMutation(record);
+    }
+  });
+  const _rawTarget = state2[TARGET];
+  try {
+    Object.defineProperty(_rawTarget, "lock", {
+      value: /* @__PURE__ */ __name(() => {
+        internal_default.locked = true;
+        message_default("State is now locked. All modifications are blocked.");
+      }, "value"),
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+    Object.defineProperty(_rawTarget, "unlock", {
+      value: /* @__PURE__ */ __name(() => {
+        internal_default.locked = false;
+        message_default("State is now unlocked. Modifications are allowed.");
+      }, "value"),
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  } catch (e) {
+    if (DEV) console.warn("[memorio state] lock/unlock defineProperty failed:", e);
+  }
+  try {
+    Object.defineProperty(_rawTarget, "persist", {
+      value: /* @__PURE__ */ __name((path2) => {
+        if (typeof path2 !== "string" || !path2.length) {
+          if (DEV) console.warn('[memorio state] state.persist() requires a non-empty path string (e.g. "state.user")');
+          return () => {
+          };
+        }
+        const normalized = path2.startsWith("state.") ? path2 : "state." + path2;
+        const key = normalized.replace(/^state\./, "");
+        const segments = key.split(".");
+        const initial = store.get(key);
+        if (initial !== void 0 && initial !== null) {
+          let acc = state2;
+          for (let i = 0; i < segments.length - 1; i++) {
+            const seg = segments[i];
+            if (acc[seg] === void 0 || acc[seg] === null) acc[seg] = {};
+            acc = acc[seg];
+          }
+          if (acc) acc[segments[segments.length - 1]] = deepRaw(initial);
+        }
+        const handler = /* @__PURE__ */ __name(() => {
+          let current = state2;
+          for (const seg of segments) {
+            current = current === void 0 || current === null ? void 0 : current[seg];
+          }
+          store.set(key, deepRaw(current));
+        }, "handler");
+        const off = dispatch.listen(normalized, handler);
+        return typeof off === "function" ? off : () => {
+        };
+      }, "value"),
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  } catch (e) {
+    if (DEV) console.warn("[memorio state] persist defineProperty failed:", e);
+  }
+  globalThis[STATE_INSTANCE_KEY] = state2;
+}
+
+// index.ts
+init_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/cache/index.ts
+init_esm_shims();
+var CACHE_INSTANCE_KEY = "__memorio_cache_instance__";
+var cacheData = {};
+var cache = globalThis[CACHE_INSTANCE_KEY] ? globalThis[CACHE_INSTANCE_KEY] : 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;
+  }
+});
+if (!globalThis[CACHE_INSTANCE_KEY]) {
+  globalThis[CACHE_INSTANCE_KEY] = cache;
+  if (!Object.isFrozen(cache)) {
+    Object.freeze(cache);
+  }
+}
+
+// index.ts
+init_idb();
+init_sqlite();
+
+// functions/observer/index.ts
+init_esm_shims();
+init_message();
+var observerFunction = /* @__PURE__ */ __name((s, cb = null, option = true) => {
+  const resolvePath = /* @__PURE__ */ __name((path3) => {
+    if (typeof path3 === "string") return path3;
+    if (path3 && typeof path3 === "object" && path3.__path) return path3.__path;
+    return null;
+  }, "resolvePath");
+  const path2 = 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 (path2) {
+    const t = path2.split(".");
+    if (t[0] !== "state" && t[0] !== "store") {
+      console.error(`Observer Error: You need to declare 'state.' or 'store.'. The '${path2}' 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);
+    const unsubs = [];
+    callbacks.forEach((callback) => {
+      if (typeof callback === "function") {
+        const off = dispatch.listen(resolvedPath, callback, option);
+        if (typeof off === "function") unsubs.push(off);
+      }
+    });
+    if (unsubs.length === 1) return unsubs[0];
+    if (unsubs.length > 1) return () => unsubs.forEach((u) => u());
+    return () => {
+    };
+  }
+}, "observerFunction");
+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: /* @__PURE__ */ __name(() => globalThis.events, "get")
+    },
+    ///
+    /**
+     * Remove an observer.
+     * @param name The name of the observer to remove.
+     */
+    remove: {
+      value: /* @__PURE__ */ __name((name) => {
+        if (!name) return;
+        dispatch.remove(name);
+        delete globalThis.events[name];
+        return;
+      }, "value")
+    },
+    ///
+    /**
+     * Remove all observers.
+     * @returns void
+     */
+    removeAll: {
+      get: /* @__PURE__ */ __name(() => {
+        const obs = globalThis.observer;
+        const list = obs?.list;
+        if (list) {
+          Object.keys(list).forEach((key) => {
+            obs?.remove?.(key);
+          });
+        }
+        return true;
+      }, "get")
+    },
+    ///
+    /**
+     * 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: /* @__PURE__ */ __name((name) => {
+        const obs = globalThis.observer;
+        return !!obs?.list?.[name];
+      }, "value")
+    }
+  }
+);
+
+// functions/useObserver/index.ts
+init_esm_shims();
+init_message();
+init_internal();
+var useObserver = /* @__PURE__ */ __name(((func, deps = []) => {
+  if (!deps || typeof func !== "function") {
+    return () => {
+    };
+  }
+  const handlers = [];
+  const unsubs = [];
+  const depList = Array.isArray(deps) && !deps.__path ? deps : [deps];
+  try {
+    depList.forEach((dep) => {
+      let t = "";
+      if (typeof dep === "function") {
+        const result = 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 path2 = t.startsWith("store.") || t.startsWith("state.") ? t : "state." + t;
+        if (!handlers.includes(path2)) {
+          handlers.push(path2);
+          const off = dispatch.listen(path2, () => func());
+          if (typeof off === "function") unsubs.push({ path: path2, off });
+        }
+      } else {
+        internal_default.clearTrackedPaths();
+        internal_default.tracking = true;
+        try {
+          func();
+        } catch (_) {
+        }
+        internal_default.tracking = false;
+        internal_default.trackedPaths.forEach((path2) => {
+          if (!handlers.includes(path2)) {
+            message_default(`useObserver: [Auto-Discovery] -> "${path2}"`);
+            handlers.push(path2);
+            const off = dispatch.listen(path2, () => func());
+            if (typeof off === "function") unsubs.push({ path: path2, off });
+          }
+        });
+      }
+    });
+    if (handlers.length > 0) {
+      message_default(`useObserver: Monitoring ${handlers.length} paths.`);
+    } else {
+      console.warn(`useObserver: No paths resolved for monitoring. Check your dependencies!`);
+    }
+    return () => {
+      unsubs.forEach(({ path: path2, off }) => {
+        off();
+        message_default(`useObserver: Stopped monitoring "${path2}"`);
+      });
+    };
+  } catch (err) {
+    message_default(`useObserver Error: ${err}`);
+    return () => {
+    };
+  }
+}), "useObserver");
+
+// index.ts
+init_message();
+
+// functions/logger/index.ts
+init_esm_shims();
+init_internal();
+init_message();
+init_env();
+var defaultConfig = {
+  enabled: true,
+  logToConsole: true,
+  modules: ["state", "store", "session", "cache", "idb"],
+  maxEntries: 1e3
+};
+function isDebugEnabled() {
+  return DEV && internal_default.debug === true;
+}
+__name(isDebugEnabled, "isDebugEnabled");
+var config = { ...defaultConfig };
+var logHistory = [];
+var configure = /* @__PURE__ */ __name((options) => {
+  config = { ...config, ...options };
+}, "configure");
+var enable = /* @__PURE__ */ __name(() => {
+  config.enabled = true;
+}, "enable");
+var disable = /* @__PURE__ */ __name(() => {
+  config.enabled = false;
+}, "disable");
+var isEnabled = /* @__PURE__ */ __name((module) => {
+  return config.enabled && config.modules.includes(module);
+}, "isEnabled");
+var log = /* @__PURE__ */ __name((module, action, path2, value, previousValue) => {
+  if (!isEnabled(module)) return;
+  const entry = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    module,
+    action,
+    path: path2,
+    value,
+    previousValue
+  };
+  logHistory.push(entry);
+  if (logHistory.length > config.maxEntries) {
+    logHistory.shift();
+  }
+  if (config.logToConsole && isDebugEnabled()) {
+    const prefix = `[Memorio:${module.toUpperCase()}]`;
+    const color = getModuleColor(module);
+    message_default(
+      `%c${prefix}%c ${action} ${path2},
+      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);
+  }
+}, "log");
+var getModuleColor = /* @__PURE__ */ __name((module) => {
+  const colors = {
+    state: "#4CAF50",
+    store: "#2196F3",
+    session: "#FF9800",
+    cache: "#9C27B0",
+    idb: "#F44336"
+  };
+  return colors[module] || "#888888";
+}, "getModuleColor");
+var getHistory = /* @__PURE__ */ __name(() => {
+  return [...logHistory];
+}, "getHistory");
+var clearHistory = /* @__PURE__ */ __name(() => {
+  logHistory.length = 0;
+}, "clearHistory");
+var getStats = /* @__PURE__ */ __name(() => {
+  const stats = {
+    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 stats[module] === "number") stats[module]++;
+      if (action && typeof stats[action] === "number") stats[action]++;
+    }
+  }
+  return stats;
+}, "getStats");
+var exportLogs = /* @__PURE__ */ __name(() => {
+  return JSON.stringify(logHistory, null, 2);
+}, "exportLogs");
+var logger = {
+  configure,
+  enable,
+  disable,
+  isEnabled,
+  log,
+  getHistory,
+  clearHistory,
+  getStats,
+  exportLogs
+};
+
+// core/fractional.ts
+init_esm_shims();
+function generateBetween(left, right, minChars = 2) {
+  if (left !== null && right !== null && left >= right) {
+    throw new Error(`left (${left}) must be < right (${right})`);
+  }
+  if (left === null && right === null) {
+    return "a";
+  }
+  if (left === null) {
+    return generateLower(right, minChars);
+  }
+  if (right === null) {
+    return generateUpper(left, minChars);
+  }
+  return generateMiddle(left, right, minChars);
+}
+__name(generateBetween, "generateBetween");
+function generateLower(right, minChars) {
+  const rightDigits = right.split(".");
+  const first = rightDigits[0];
+  const firstChar = first.charCodeAt(0);
+  if (firstChar > "a".charCodeAt(0)) {
+    const prev = String.fromCharCode(firstChar - 1);
+    const rest = first.slice(1);
+    if (rest === "") {
+      return leftPad(prev, minChars);
+    }
+    return prev + rest;
+  }
+  if (first[0] === "a") {
+    let i = 0;
+    while (i < first.length && first[i] === "a") i++;
+    if (i === first.length) {
+      return ".z." + ".z".repeat(Math.floor(minChars / 2) + 1);
+    }
+    const char = first.charCodeAt(i);
+    const next = String.fromCharCode(char - 1);
+    if (next >= "a") {
+      return next + first.slice(i + 1);
+    }
+    return "a" + next + first.slice(i + 1);
+  }
+  return ".z." + ".z".repeat(Math.floor(minChars / 2) + 1);
+}
+__name(generateLower, "generateLower");
+function generateUpper(left, minChars) {
+  const leftDigits = left.split(".");
+  const first = leftDigits[0];
+  const firstChar = first.charCodeAt(0);
+  const nextChar = String.fromCharCode(firstChar + 1);
+  if (nextChar <= "z") {
+    const rest = first.slice(1);
+    if (rest === "") {
+      return rightPad(nextChar, minChars);
+    }
+    return nextChar + rest;
+  }
+  if (first.length > 1) {
+    const lastChar = first[first.length - 1];
+    if (lastChar < "z") {
+      return first.slice(0, -1) + String.fromCharCode(lastChar.charCodeAt(0) + 1);
+    }
+  }
+  const carry = handleCarry(first, 0);
+  if (carry !== null) {
+    return carry + leftPad("a", minChars);
+  }
+  return "b" + leftPad("a", minChars);
+}
+__name(generateUpper, "generateUpper");
+function handleCarry(digits, carryPos) {
+  if (carryPos >= digits.length) return null;
+  const char = digits.charCodeAt(carryPos);
+  if (char < "z".charCodeAt(0)) {
+    return digits.slice(0, carryPos) + String.fromCharCode(char + 1);
+  }
+  return handleCarry(digits, carryPos + 1);
+}
+__name(handleCarry, "handleCarry");
+function generateMiddle(left, right, minChars) {
+  const leftDigits = left.split(".");
+  const rightDigits = right.split(".");
+  const maxLen = Math.max(leftDigits.length, rightDigits.length);
+  const leftParts = padParts(leftDigits, maxLen);
+  const rightParts = padParts(rightDigits, maxLen);
+  let prefix = [];
+  for (let i = 0; i < maxLen; i++) {
+    const l = leftParts[i] || "a";
+    const r = rightParts[i] || "z";
+    if (l === r) {
+      prefix.push(l);
+    } else {
+      const lCode = l.charCodeAt(0);
+      const rCode = r.charCodeAt(0);
+      if (rCode - lCode > 1) {
+        prefix.push(String.fromCharCode(lCode + 1));
+        while (prefix.length < minChars) {
+          prefix.push("a");
+        }
+        return prefix.join(".");
+      }
+      prefix.push(l);
+      prefix.push(generateUpper(l, minChars));
+      return prefix.join(".");
+    }
+  }
+  return generateUpper(left, minChars);
+}
+__name(generateMiddle, "generateMiddle");
+function padParts(parts, maxLen) {
+  while (parts.length < maxLen) parts.push("a");
+  return parts;
+}
+__name(padParts, "padParts");
+function leftPad(key, minChars) {
+  let result = key;
+  while (result.length < minChars) result = "a" + result;
+  return result;
+}
+__name(leftPad, "leftPad");
+function rightPad(key, minChars) {
+  let result = key;
+  while (result.length < minChars) result = result + "a";
+  return result;
+}
+__name(rightPad, "rightPad");
+function firstKey() {
+  return generateBetween(null, null);
+}
+__name(firstKey, "firstKey");
+function after(left) {
+  return generateBetween(left, null);
+}
+__name(after, "after");
+function before(right) {
+  return generateBetween(null, right);
+}
+__name(before, "before");
+function between(left, right) {
+  return generateBetween(left, right);
+}
+__name(between, "between");
+function reorder(items, fromIndex, toIndex) {
+  if (fromIndex === toIndex) return items.map((i) => i.key);
+  const reordered = [...items];
+  const [removed] = reordered.splice(fromIndex, 1);
+  reordered.splice(toIndex, 0, removed);
+  return reordered.map((i) => i.key);
+}
+__name(reorder, "reorder");
+function reindex(items) {
+  if (items.length === 0) return items;
+  const result = [];
+  let prev = null;
+  for (let i = 0; i < items.length; i++) {
+    const next = i < items.length - 1 ? items[i + 1].key : null;
+    const newItem = { ...items[i] };
+    if (prev === null) {
+      newItem.key = before(items[0].key);
+    } else if (next === null) {
+      newItem.key = after(prev);
+    } else {
+      newItem.key = between(prev, next);
+    }
+    result.push(newItem);
+    prev = newItem.key;
+  }
+  return result;
+}
+__name(reindex, "reindex");
+var fractional = {
+  generateBetween,
+  firstKey,
+  after,
+  before,
+  between,
+  reorder,
+  reindex
+};
+
+// index.ts
+init_internal();
+init_platform();
+
+// core/global.ts
+init_esm_shims();
+init_platform();
+init_internal();
+
+// package.json
+var package_default = {
+  version: "5.0.0"};
+
+// core/global.ts
+init_env();
+init_store();
+init_idb();
+init_sqlite();
+init_message();
+
+// functions/typed/index.ts
+init_esm_shims();
+function typed() {
+  return state2;
+}
+__name(typed, "typed");
+
+// functions/history/index.ts
+init_esm_shims();
+init_internal();
+init_env();
+init_message();
+function _clone(value) {
+  if (value === null || typeof value !== "object") return value;
+  try {
+    return deepRaw(value, /* @__PURE__ */ new WeakSet());
+  } catch (err) {
+    if (DEV) console.warn("[memorio history] deep clone failed:", err);
+    return value;
+  }
+}
+__name(_clone, "_clone");
+var snapshot = /* @__PURE__ */ __name(() => {
+  return deepRaw(state2, /* @__PURE__ */ new WeakSet());
+}, "snapshot");
+var diff = /* @__PURE__ */ __name((snap) => {
+  const changes = [];
+  const _walk = /* @__PURE__ */ __name((oldObj, newObj, prefix) => {
+    const oldKeys = oldObj ? Object.keys(oldObj) : [];
+    const newKeys = newObj ? Object.keys(newObj) : [];
+    for (const key of newKeys) {
+      const newPath = prefix ? `${prefix}.${key}` : key;
+      const oldVal = oldObj ? oldObj[key] : void 0;
+      const newVal = newObj[key];
+      if (oldVal !== newVal) {
+        const oldType = typeof oldVal;
+        const newType = typeof newVal;
+        if (oldType !== newType || oldVal === void 0) {
+          changes.push({ path: newPath, oldValue: oldVal, newValue: newVal });
+        } else if (oldVal && typeof oldVal === "object") {
+          _walk(oldVal, newVal, newPath);
+        } else if (oldVal !== newVal) {
+          changes.push({ path: newPath, oldValue: oldVal, newValue: newVal });
+        }
+      }
+    }
+    for (const key of oldKeys) {
+      if (!(key in (newObj || {}))) {
+        const newPath = prefix ? `${prefix}.${key}` : key;
+        changes.push({ path: newPath, oldValue: oldObj[key], newValue: void 0 });
+      }
+    }
+  }, "_walk");
+  _walk(snap, deepRaw(state2), "");
+  return changes;
+}, "diff");
+var enableHistory = /* @__PURE__ */ __name((enabled = true) => {
+  internal_default.historyEnabled = enabled;
+  message_default(`[memorio history] Tracking ${enabled ? "enabled" : "disabled"}`);
+}, "enableHistory");
+var trace = /* @__PURE__ */ __name(() => {
+  return [...internal_default.mutations];
+}, "trace");
+var canUndo = /* @__PURE__ */ __name(() => {
+  return internal_default.canUndo();
+}, "canUndo");
+var canRedo = /* @__PURE__ */ __name(() => {
+  return internal_default.canRedo();
+}, "canRedo");
+var undo = /* @__PURE__ */ __name(() => {
+  if (!internal_default.historyEnabled) {
+    message_default("[memorio history] History is not enabled");
+    return void 0;
+  }
+  const record = internal_default.popUndo();
+  if (!record) return void 0;
+  _applyInverse2(record);
+  message_default(`[memorio history] Undid: ${record.action} ${record.path}`);
+  return record;
+}, "undo");
+var redo = /* @__PURE__ */ __name(() => {
+  if (!internal_default.historyEnabled) {
+    message_default("[memorio history] History is not enabled");
+    return void 0;
+  }
+  const record = internal_default.popRedo();
+  if (!record) return void 0;
+  _applyForward(record);
+  message_default(`[memorio history] Redid: ${record.action} ${record.path}`);
+  return record;
+}, "redo");
+function _applyInverse2(record) {
+  const wasEnabled = internal_default.historyEnabled;
+  internal_default.historyEnabled = false;
+  try {
+    if (record.action === "set") {
+      if (record.previousValue === void 0) {
+        _deletePath2(record.path);
+      } else {
+        _setPath2(record.path, record.previousValue);
+      }
+    } else if (record.action === "delete") {
+      if (record.previousValue !== void 0) {
+        _setPath2(record.path, record.previousValue);
+      }
+    }
+  } finally {
+    internal_default.historyEnabled = wasEnabled;
+  }
+}
+__name(_applyInverse2, "_applyInverse");
+function _applyForward(record) {
+  const wasEnabled = internal_default.historyEnabled;
+  internal_default.historyEnabled = false;
+  try {
+    if (record.action === "set") {
+      _setPath2(record.path, record.newValue);
+    } else if (record.action === "delete") {
+      _deletePath2(record.path);
+    }
+  } finally {
+    internal_default.historyEnabled = wasEnabled;
+  }
+}
+__name(_applyForward, "_applyForward");
+function _setPath2(path2, value) {
+  const parts = path2.split(".");
+  let current = state2;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === void 0) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+__name(_setPath2, "_setPath");
+function _deletePath2(path2) {
+  const parts = path2.split(".");
+  if (parts.length === 1) {
+    state2.remove(parts[0]);
+    return;
+  }
+  let current = state2;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === void 0) return;
+    current = current[part];
+  }
+  delete current[parts[parts.length - 1]];
+}
+__name(_deletePath2, "_deletePath");
+var rollback = /* @__PURE__ */ __name((snap) => {
+  state2.removeAll();
+  for (const key of Object.keys(snap)) {
+    state2[key] = _clone(snap[key]);
+  }
+  internal_default.clearHistory();
+  message_default("[memorio history] State rolled back to snapshot");
+}, "rollback");
+var clearHistory2 = /* @__PURE__ */ __name(() => {
+  internal_default.clearHistory();
+  message_default("[memorio history] History cleared");
+}, "clearHistory");
+var clearRedo = /* @__PURE__ */ __name(() => {
+  internal_default.clearRedo();
+}, "clearRedo");
+
+// functions/memory/index.ts
+init_esm_shims();
+init_store();
+init_idb();
+init_env();
+
+// functions/memory/journal.ts
+init_esm_shims();
+init_env();
+init_store();
+var g2 = globalThis;
+function namespace() {
+  const cfg = g2.memorioSyncConfig;
+  if (cfg && typeof cfg.namespace === "string" && cfg.namespace) return `ns:${cfg.namespace}`;
+  const ctx = g2.memorio ? g2.memorio._currentContext : void 0;
+  const ctxName = typeof ctx === "string" && ctx ? ctx : "";
+  return ctxName ? `ctx:${ctxName}` : "default";
+}
+__name(namespace, "namespace");
+function isSyncEnabled() {
+  return !!g2.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 = g2.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 configure2(opts) {
+  const prev = g2.memorioSyncConfig || {};
+  g2.memorioSyncConfig = { ...prev, ...opts };
+  return journal;
+}
+__name(configure2, "configure");
+if (typeof g2.addEventListener === "function") {
+  let armed = false;
+  g2.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) {
+    configure2(opts);
+    return this;
+  }
+};
+
+// core/global.ts
+if (!("memorio" in globalThis)) {
+  Object.defineProperty(
+    globalThis,
+    "memorio",
+    {
+      value: {
+        setProps: /* @__PURE__ */ __name(() => {
+        }, "setProps"),
+        obj: {},
+        array: [],
+        dispatch,
+        message,
+        setDescription: /* @__PURE__ */ __name(() => {
+        }, "setDescription")
+      },
+      writable: false,
+      configurable: true,
+      enumerable: false
+    }
+  );
+  if (!("events" in globalThis)) {
+    Object.defineProperty(
+      globalThis,
+      "events",
+      {
+        value: {},
+        writable: true,
+        enumerable: false,
+        configurable: true
+      }
+    );
+  }
+  if (typeof globalThis.addEventListener !== "function") {
+    const listeners = {};
+    globalThis.addEventListener = (name, cb) => {
+      (listeners[name] = listeners[name] ?? []).push(cb);
+    };
+    globalThis.removeEventListener = (name, cb) => {
+      const arr = listeners[name];
+      if (arr) {
+        const idx = arr.indexOf(cb);
+        if (idx > -1) arr.splice(idx, 1);
+      }
+    };
+    globalThis.dispatchEvent = (e) => {
+      const type = (e && typeof e === "object" ? e.type : null) || String(e);
+      const arr = listeners[type];
+      if (arr) {
+        arr.slice().forEach((cb) => cb(e));
+      }
+    };
+  }
+  if (typeof globalThis.addEventListener === "function") {
+    dispatch.listen("memorio:memory:cleanup", async () => memory.forgetExpired?.());
+  }
+  Object.defineProperty(
+    memorio,
+    "version",
+    {
+      writable: false,
+      enumerable: false,
+      value: package_default.version
+    }
+  );
+  memorio.memory = memory;
+  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(memorio, "setContext", { writable: false, enumerable: false, value: /* @__PURE__ */ __name((id) => setCurrentContext(id), "value") });
+  Object.defineProperty(memorio, "getContext", { writable: false, enumerable: false, value: /* @__PURE__ */ __name(() => internal_default.currentContext, "value") });
+  memorio.registerSchema = schema.register;
+  memorio.validate = schema.validate;
+  memorio.unregisterSchema = schema.unregister;
+  memorio.listSchemas = schema.list;
+  memorio.typed = typed;
+  memorio.snapshot = snapshot;
+  memorio.diff = diff;
+  memorio.undo = undo;
+  memorio.redo = redo;
+  memorio.canUndo = canUndo;
+  memorio.canRedo = canRedo;
+  memorio.rollback = rollback;
+  memorio.trace = trace;
+  memorio.enableHistory = enableHistory;
+  memorio.clearHistory = clearHistory2;
+  memorio.clearRedo = clearRedo;
+  memorio.mutate = mutate;
+  memorio.createMutation = createMutation;
+  memorio.recordMutation = recordMutation;
+  memorio.toPatch = toPatch;
+  memorio.transaction = beginTransaction;
+  memorio.commitTransaction = commitTransaction;
+  memorio.abortTransaction = abortTransaction;
+  memorio.currentTransaction = currentTransaction;
+  Object.defineProperty(memorio, "dispatch", { value: dispatch, writable: true, enumerable: false, configurable: true });
+  memorio.env = {
+    isDev: DEV,
+    isProd: PROD
+  };
+  memorio.global = function() {
+    const globalDefinitions = {
+      state: state2,
+      store,
+      session,
+      cache,
+      idb,
+      sqlite,
+      observer,
+      useObserver
+    };
+    for (const key of Object.keys(globalDefinitions)) {
+      if (!(key in globalThis)) {
+        Object.defineProperty(globalThis, key, {
+          value: globalDefinitions[key],
+          writable: true,
+          configurable: true,
+          enumerable: false
+        });
+      }
+    }
+    if (typeof globalThis.useObserver === "function") {
+      Object.freeze(globalThis.useObserver);
+    }
+  };
+}
+
+// index.ts
+var transaction = beginTransaction;
+var devtools = void 0;
+var memorio2 = globalThis.memorio;
+var events = globalThis.events;
+var isolate = /* @__PURE__ */ __name((name) => createContext(name), "isolate");
+var help = globalThis.memorio?.help;
+var setContext = /* @__PURE__ */ __name((id) => internal_default.currentContext = id, "setContext");
+var getContext = /* @__PURE__ */ __name(() => internal_default.currentContext, "getContext");
+var index_default = memorio2;
+
+// global.ts
+memorio2.global();
+
+export { DEV, PROD, abortTransaction, activeTransactionId, beginTransaction, cache, canMerge, canRedo, canUndo, clearHistory2 as clearHistory, clearRedo, commitTransaction, createContext, createMutation, currentTimestamp, currentTransaction, index_default as default, deleteContext, devtools, diff, diffToPatch, dispatch, enableHistory, events, fractional, generateCommitId, generateMutationId, generateTransactionId, getCapabilities, getContext, help, hlc, idb, internal_default as internal, isBrowser, isDeno, isEdge, isNode, isolate, listContexts, listSchemas, listTransactions, logger, memorio2 as memorio, memory, mergePatches, message, mutate, mutationToPatch, observer, propertyName, recordMutation, redo, registerSchema, rollback, schema, session, setContext, snapshot, sqlite, state2 as state, store, toPatch, trace, transaction, typed, undo, unregisterSchema, useObserver, validate };
+//# sourceMappingURL=global.js.map
+//# sourceMappingURL=global.js.map