memorio 5.1.2 → 5.1.4

package/global.js

@@ -1092,6 +1092,123 @@ var init_store = __esm({
   }
 });
 
+// core/hlc.ts
+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;
+}
+function generateNodeId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID().slice(0, 8);
+  }
+  return Math.random().toString(36).slice(2, 10);
+}
+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 };
+}
+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 };
+}
+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;
+}
+function happenedBefore(a, b) {
+  return compare(a, b) < 0;
+}
+function serialize(hlc2) {
+  return `hlc:${hlc2.physical}:${hlc2.logical}:${hlc2.node}`;
+}
+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 };
+}
+var NODE_ID_KEY, HLC_KEY, local, hlc;
+var init_hlc = __esm({
+  "core/hlc.ts"() {
+    init_esm_shims();
+    NODE_ID_KEY = "__memorio_hlc_node";
+    __name(getNodeId, "getNodeId");
+    __name(generateNodeId, "generateNodeId");
+    HLC_KEY = "__memorio_hlc_local";
+    local = globalThis[HLC_KEY] || {
+      physical: 0,
+      logical: 0,
+      node: getNodeId()
+    };
+    if (!globalThis[HLC_KEY]) {
+      globalThis[HLC_KEY] = local;
+    }
+    __name(tick, "tick");
+    __name(receive, "receive");
+    __name(compare, "compare");
+    __name(happenedBefore, "happenedBefore");
+    __name(serialize, "serialize");
+    __name(parse, "parse");
+    hlc = {
+      tick,
+      receive,
+      compare,
+      happenedBefore,
+      serialize,
+      parse,
+      getNodeId
+    };
+  }
+});
+
 // functions/idb/tools/db.create.ts
 var db_create_exports = {};
 var init_db_create = __esm({
@@ -1730,13 +1847,41 @@ var init_db_support2 = __esm({
 });
 
 // functions/sqlite/tools/persist.ts
+var persist_exports = {};
+__export(persist_exports, {
+  CHECKPOINT_INTERVAL: () => CHECKPOINT_INTERVAL,
+  DEBOUNCE_MS: () => DEBOUNCE_MS,
+  _attachJournal: () => _attachJournal,
+  _checkpoint: () => _checkpoint,
+  _clearJournal: () => _clearJournal,
+  _journalAppend: () => _journalAppend,
+  _journalCount: () => _journalCount,
+  _journalEntries: () => _journalEntries,
+  _journalReplay: () => _journalReplay,
+  _loadCheckpoint: () => _loadCheckpoint,
+  _removeCheckpoint: () => _removeCheckpoint,
+  _saveCheckpoint: () => _saveCheckpoint,
+  _scheduleCheckpoint: () => _scheduleCheckpoint
+});
 function _ns() {
   const cfg = g.sqliteConfig || {};
   return cfg.namespace ? `ns:${cfg.namespace}` : "default";
 }
-function _key(name) {
+function _dbKey(name) {
   return `memorio:sqlite:db:${_ns()}:${name}`;
 }
+function _journalKey(name, seq) {
+  return `memorio:sqlite:journal:${_ns()}:${name}:${seq}`;
+}
+function _journalIndexKey(name) {
+  return `memorio:sqlite:journal:${_ns()}:${name}:index`;
+}
+function _journalSeqKey(name) {
+  return `memorio:sqlite:journal:${_ns()}:${name}:seq`;
+}
+function _opCounterKey(name) {
+  return `memorio:sqlite:journal:${_ns()}:${name}:ops`;
+}
 function _b64encode2(buf) {
   const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
   let binary = "";
@@ -1749,35 +1894,81 @@ function _b64decode2(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");
+  if (typeof atob === "function") {
+    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;
   }
-  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;
+  throw new Error("memorio sqlite: no base64 decoder available");
 }
-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), _b64encode2(blob));
-      message_default(`Memorio SQLite: persisted '${name}' to store`);
-      resolve(true);
-    } catch (err) {
-      console.warn("Memorio SQLite: persist snapshot failed", err);
-      resolve(false);
-    }
+function _nextSeq(name) {
+  const seq = (store.get(_journalSeqKey(name)) || 0) + 1;
+  store.set(_journalSeqKey(name), seq);
+  return seq;
+}
+function _journalAppend(name, sql, params) {
+  const seq = _nextSeq(name);
+  const entry = {
+    hlc: hlc.serialize(hlc.tick()),
+    sql,
+    params: params || [],
+    seq,
+    ts: Date.now()
+  };
+  store.set(_journalKey(name, seq), entry);
+  const idx = store.get(_journalIndexKey(name)) || [];
+  idx.push(seq);
+  store.set(_journalIndexKey(name), idx);
+  return seq;
+}
+function _journalEntries(name) {
+  const idx = store.get(_journalIndexKey(name)) || [];
+  const entries = [];
+  for (const seq of idx) {
+    const raw = store.get(_journalKey(name, seq));
+    if (raw && typeof raw === "object" && raw.hlc) entries.push(raw);
+  }
+  entries.sort((a, b) => {
+    const ha = hlc.parse(a.hlc);
+    const hb = hlc.parse(b.hlc);
+    if (ha && hb) return hlc.compare(ha, hb);
+    return a.seq - b.seq;
   });
+  return entries;
+}
+function _journalCount(name) {
+  const idx = store.get(_journalIndexKey(name)) || [];
+  return idx.length;
 }
-function loadSnapshot(name) {
-  const b64 = store.get(_key(name));
+function _clearJournal(name) {
+  const idx = store.get(_journalIndexKey(name)) || [];
+  for (const seq of idx) {
+    store.remove(_journalKey(name, seq));
+  }
+  store.remove(_journalIndexKey(name));
+  store.remove(_journalSeqKey(name));
+  store.remove(_opCounterKey(name));
+}
+async function _saveCheckpoint(name) {
+  const db = g.__sqliteDbs && g.__sqliteDbs[name];
+  if (!db || typeof db.export !== "function") return false;
+  try {
+    const blob = db.export();
+    store.set(_dbKey(name), _b64encode2(blob));
+    message_default(`Memorio SQLite: checkpoint saved for '${name}'`);
+    return true;
+  } catch (err) {
+    if (db && db.version === "bun:sqlite") {
+      return false;
+    }
+    console.warn("Memorio SQLite: checkpoint failed", err);
+    return false;
+  }
+}
+function _loadCheckpoint(name) {
+  const b64 = store.get(_dbKey(name));
   if (!b64) return null;
   try {
     return _b64decode2(b64);
@@ -1785,48 +1976,108 @@ function loadSnapshot(name) {
     return null;
   }
 }
-function removeSnapshot(name) {
-  store.remove(_key(name));
+function _removeCheckpoint(name) {
+  store.remove(_dbKey(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);
+async function _journalReplay(name, db) {
+  const entries = _journalEntries(name);
+  if (!entries.length) return 0;
+  let replayed = 0;
+  for (const entry of entries) {
+    try {
+      db.run(entry.sql, entry.params || []);
+      replayed++;
+    } catch (err) {
+      console.warn(`Memorio SQLite: failed to replay journal entry ${entry.seq} for '${name}'`, err);
+    }
+  }
+  message_default(`Memorio SQLite: replayed ${replayed} journal entries for '${name}'`);
+  return replayed;
+}
+function _scheduleCheckpoint(name) {
+  if (_checkpointTimers[name]) clearTimeout(_checkpointTimers[name]);
+  _checkpointTimers[name] = setTimeout(() => {
+    _checkpointTimers[name] = null;
+    void _checkpoint(name);
+  }, DEBOUNCE_MS);
+}
+async function _checkpoint(name) {
+  if (_checkpointTimers[name]) {
+    clearTimeout(_checkpointTimers[name]);
+    _checkpointTimers[name] = null;
+  }
+  const saved = await _saveCheckpoint(name);
+  if (saved) _clearJournal(name);
+  return saved;
+}
+function _attachJournal(name, db) {
+  if (!db || typeof db.run !== "function") return;
+  if (db.__memorioJournalAttached) return;
+  db.__memorioJournalAttached = true;
+  const originalRun = db.run.bind(db);
+  db.run = function(sql, params) {
+    const paramArr = Array.isArray(params) ? params : params !== void 0 ? [params] : [];
+    _journalAppend(name, sql, paramArr);
+    const ops = (store.get(_opCounterKey(name)) || 0) + 1;
+    store.set(_opCounterKey(name), ops);
+    if (ops >= CHECKPOINT_INTERVAL) {
+      store.set(_opCounterKey(name), 0);
+      void _checkpoint(name);
+    } else {
+      _scheduleCheckpoint(name);
+    }
+    return originalRun(sql, params);
+  };
+  if (typeof db.updateHook === "function") {
+    try {
+      db.updateHook(() => {
+        _scheduleCheckpoint(name);
+      });
+    } catch (err) {
+      console.warn("Memorio SQLite: could not attach updateHook", err);
+    }
   }
 }
-var g, _persistDbs, _exportTimers;
+var g, CHECKPOINT_INTERVAL, DEBOUNCE_MS, _checkpointTimers;
 var init_persist = __esm({
   "functions/sqlite/tools/persist.ts"() {
     init_esm_shims();
     init_sqlite();
     init_store();
+    init_hlc();
     init_message();
     g = globalThis;
-    _persistDbs = {};
-    _exportTimers = {};
+    CHECKPOINT_INTERVAL = 50;
+    DEBOUNCE_MS = 250;
+    _checkpointTimers = {};
     __name(_ns, "_ns");
-    __name(_key, "_key");
+    __name(_dbKey, "_dbKey");
+    __name(_journalKey, "_journalKey");
+    __name(_journalIndexKey, "_journalIndexKey");
+    __name(_journalSeqKey, "_journalSeqKey");
+    __name(_opCounterKey, "_opCounterKey");
     __name(_b64encode2, "_b64encode");
     __name(_b64decode2, "_b64decode");
-    __name(saveSnapshot, "saveSnapshot");
-    __name(loadSnapshot, "loadSnapshot");
-    __name(removeSnapshot, "removeSnapshot");
-    __name(attachAutoExport, "attachAutoExport");
+    __name(_nextSeq, "_nextSeq");
+    __name(_journalAppend, "_journalAppend");
+    __name(_journalEntries, "_journalEntries");
+    __name(_journalCount, "_journalCount");
+    __name(_clearJournal, "_clearJournal");
+    __name(_saveCheckpoint, "_saveCheckpoint");
+    __name(_loadCheckpoint, "_loadCheckpoint");
+    __name(_removeCheckpoint, "_removeCheckpoint");
+    __name(_journalReplay, "_journalReplay");
+    __name(_scheduleCheckpoint, "_scheduleCheckpoint");
+    __name(_checkpoint, "_checkpoint");
+    __name(_attachJournal, "_attachJournal");
     sqlite.db.persist = async (name = "memorio") => {
-      return saveSnapshot(name);
+      return _checkpoint(name);
+    };
+    sqlite.db.flush = async (name = "memorio") => {
+      return _checkpoint(name);
     };
     sqlite.db.download = async (name = "memorio", filename = `${name}.sqlite`) => {
-      const g3 = globalThis;
-      const db = g3.__sqliteDbs && g3.__sqliteDbs[name];
+      const db = g.__sqliteDbs && g.__sqliteDbs[name];
       if (!db) {
         console.warn(`Memorio SQLite: cannot download '${name}' - database not found. Create it with sqlite.db.create('${name}').`);
         return false;
@@ -1839,18 +2090,18 @@ var init_persist = __esm({
         return false;
       }
       if (!blob) return false;
-      if (typeof g3.document === "undefined" || typeof g3.Blob === "undefined") {
+      if (typeof g.document === "undefined" || typeof g.Blob === "undefined") {
         console.warn("Memorio SQLite: sqlite.db.download() requires a browser environment.");
         return false;
       }
-      const URL = g3.URL || g3.webkitURL;
+      const URL = g.URL || g.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");
+      const a = g.document.createElement("a");
       a.style.display = "none";
       a.href = objectUrl;
       a.download = filename;
-      g3.document.body.appendChild(a);
+      g.document.body.appendChild(a);
       a.click();
       setTimeout(() => {
         try {
@@ -1865,7 +2116,7 @@ var init_persist = __esm({
       const db = g.__sqliteDbs && g.__sqliteDbs[name];
       if (db && typeof db.close === "function") {
         try {
-          await saveSnapshot(name);
+          await _checkpoint(name);
         } catch (_) {
         }
         try {
@@ -1879,15 +2130,22 @@ var init_persist = __esm({
         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;
+      if (_checkpointTimers[name]) {
+        clearTimeout(_checkpointTimers[name]);
+        _checkpointTimers[name] = null;
       }
-      removeSnapshot(name);
     };
-    sqlite.db.loadSnapshot = loadSnapshot;
-    sqlite.db.saveSnapshot = saveSnapshot;
+    sqlite.db.loadSnapshot = _loadCheckpoint;
+    sqlite.db.saveSnapshot = _saveCheckpoint;
+    sqlite.db.removeSnapshot = _removeCheckpoint;
+    sqlite.db.journal = {
+      append: _journalAppend,
+      entries: _journalEntries,
+      count: _journalCount,
+      clear: _clearJournal,
+      replay: _journalReplay,
+      checkpoint: _checkpoint
+    };
   }
 });
 
@@ -1905,7 +2163,7 @@ var init_db_create2 = __esm({
       const persistence = !!(opts && opts.persistence) || !!(g3.sqliteConfig && g3.sqliteConfig.persistence);
       let data;
       if (persistence && !opts.data) {
-        const restored = loadSnapshot(name);
+        const restored = _loadCheckpoint(name);
         if (restored) data = restored;
       }
       const useData = opts && opts.data || data;
@@ -1927,7 +2185,13 @@ var init_db_create2 = __esm({
       } else {
         g3.sqlbases.push({ name, db, persistence: createOpts.persistence });
       }
-      if (persistence) attachAutoExport(name, db);
+      if (persistence && !opts.data) {
+        _attachJournal(name, db);
+        const replayed = await _journalReplay(name, db);
+        if (replayed > 0) {
+          message_default(`Memorio SQLite: replayed ${replayed} journal entries for '${name}'`);
+        }
+      }
       return db;
     };
   }
@@ -1958,9 +2222,14 @@ var init_db_delete2 = __esm({
     init_esm_shims();
     init_sqlite();
     init_message();
-    sqlite.db.delete = (name) => {
+    init_persist();
+    sqlite.db.delete = async (name) => {
       const dbs = globalThis.__sqliteDbs;
       if (!dbs || !dbs[name]) return false;
+      try {
+        await _checkpoint(name);
+      } catch (_) {
+      }
       try {
         dbs[name].close();
       } catch (_) {
@@ -1968,6 +2237,7 @@ var init_db_delete2 = __esm({
       delete dbs[name];
       const g3 = globalThis;
       if (g3.sqlbases) g3.sqlbases = g3.sqlbases.filter((x) => x && x.name !== name);
+      _removeCheckpoint(name);
       message_default(`Memorio SQLite: database '${name}' deleted`);
       return true;
     };
@@ -2112,7 +2382,7 @@ var init_data_get2 = __esm({
 });
 
 // functions/sqlite/index.ts
-var _hasSqlJs, _hasBunSqlite, sqlite;
+var _hasSqlJs, _hasBunSqlite, sqlite, _toolsLoaded;
 var init_sqlite = __esm({
   "functions/sqlite/index.ts"() {
     init_esm_shims();
@@ -2125,6 +2395,7 @@ var init_sqlite = __esm({
       query: {},
       data: {}
     };
+    _toolsLoaded = Promise.resolve();
     sqlite.config = (opts) => {
       const g3 = globalThis;
       g3.sqliteConfig = { ...g3.sqliteConfig, ...opts };
@@ -2139,15 +2410,19 @@ var init_sqlite = __esm({
       get: /* @__PURE__ */ __name(() => {
         const g3 = globalThis;
         if (!g3.sqliteReady) {
-          g3.sqliteReady = typeof sqlite.db.getSQL === "function" ? sqlite.db.getSQL().then(() => {
+          g3.sqliteReady = _toolsLoaded.then(() => {
+            if (typeof sqlite.db.getSQL !== "function") return;
+            return sqlite.db.getSQL().then(() => {
+            }).catch(() => {
+            });
           }).catch(() => {
-          }) : Promise.resolve();
+          });
         }
         return g3.sqliteReady;
       }, "get")
     });
     if (_hasSqlJs || _hasBunSqlite) {
-      (async () => {
+      _toolsLoaded = (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 });
@@ -2159,6 +2434,7 @@ var init_sqlite = __esm({
         });
         await Promise.all([
           Promise.resolve().then(() => (init_db_support2(), db_support_exports2)),
+          Promise.resolve().then(() => (init_persist(), persist_exports)),
           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)),
@@ -2382,121 +2658,11 @@ 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
-};
+init_hlc();
 
 // core/mutation/id.ts
 init_esm_shims();
+init_hlc();
 function generateMutationId() {
   const now2 = hlc.tick();
   return "m_" + encodeHLC(now2);
@@ -2588,6 +2754,7 @@ __name(mergePatches, "mergePatches");
 // core/mutation/transaction.ts
 init_esm_shims();
 init_internal();
+init_hlc();
 var TX_REGISTRY_KEY = "__memorio_transaction_registry__";
 var registry = globalThis[TX_REGISTRY_KEY] || /* @__PURE__ */ new Map();
 if (!globalThis[TX_REGISTRY_KEY]) {
@@ -3157,19 +3324,39 @@ if (globalThis[STATE_INSTANCE_KEY]) {
         const initial = store.get(key);
         if (initial !== void 0 && initial !== null) {
           let acc = state2;
+          let seedOk = true;
           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];
+            const existing = acc[seg];
+            if (existing === void 0 || existing === null) {
+              acc[seg] = {};
+              acc = acc[seg];
+            } else if (typeof existing === "object") {
+              acc = existing;
+            } else {
+              if (DEV) {
+                console.warn(
+                  `[memorio state] state.persist('${normalized}') aborted seeding: '${seg}' already holds a primitive value (${typeof existing}), cannot nest '${segments.slice(i + 1).join(".")}' under it.`
+                );
+              }
+              seedOk = false;
+              break;
+            }
+          }
+          if (seedOk && acc) {
+            acc[segments[segments.length - 1]] = deepRaw(initial);
           }
-          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));
+          if (current === void 0) {
+            store.remove(key);
+          } else {
+            store.set(key, deepRaw(current));
+          }
         }, "handler");
         const off = dispatch.listen(normalized, handler);
         return typeof off === "function" ? off : () => {
@@ -3589,8 +3776,7 @@ var observerFunction = /* @__PURE__ */ __name((s, cb = null, option = true) => {
   }
   if (s && cb) {
     const resolvedPath = resolvePath(s);
-    if (!resolvedPath) return;
-    if (typeof s !== "string" && !(s && typeof s === "object")) {
+    if (!resolvedPath) {
       console.error(`Observer Error: name of state need to be a 'string' like 'state.test' or a direct state value`);
       return;
     }
@@ -3640,7 +3826,7 @@ Object.defineProperties(
      * @returns void
      */
     removeAll: {
-      get: /* @__PURE__ */ __name(() => {
+      value: /* @__PURE__ */ __name(() => {
         const obs = globalThis.observer;
         const list = obs?.list;
         if (list) {
@@ -3649,7 +3835,7 @@ Object.defineProperties(
           });
         }
         return true;
-      }, "get")
+      }, "value")
     },
     ///
     /**
@@ -3679,40 +3865,58 @@ var useObserver = /* @__PURE__ */ __name(((func, deps = []) => {
   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 (depList.length === 0) {
+      internal_default.clearTrackedPaths();
+      internal_default.tracking = true;
+      try {
+        func();
+      } catch (_) {
       }
-      if (t) {
-        t = t.replace(/^(\(\)\s*=>\s*)/, "").replace(/^globalThis\./, "").replace(/^state\./, "");
-        const path2 = t.startsWith("store.") || t.startsWith("state.") ? t : "state." + t;
+      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 });
         }
-      } else {
-        internal_default.clearTrackedPaths();
-        internal_default.tracking = true;
-        try {
-          func();
-        } catch (_) {
+      });
+    } else {
+      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() : "");
         }
-        internal_default.tracking = false;
-        internal_default.trackedPaths.forEach((path2) => {
+        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)) {
-            message_default(`useObserver: [Auto-Discovery] -> "${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 {
@@ -4199,8 +4403,8 @@ function isAuditActive() {
   return _auditLogger !== null;
 }
 __name(isAuditActive, "isAuditActive");
-function setAuditLogger(logger3) {
-  _auditLogger = logger3;
+function setAuditLogger(logger2) {
+  _auditLogger = logger2;
 }
 __name(setAuditLogger, "setAuditLogger");
 function logAudit(entry) {
@@ -4443,6 +4647,9 @@ var logger = {
   exportLogs
 };
 
+// index.ts
+init_hlc();
+
 // core/fractional.ts
 init_esm_shims();
 function generateBetween(left, right, minChars = 2) {
@@ -4635,7 +4842,7 @@ init_internal();
 
 // package.json
 var package_default = {
-  version: "5.1.2"};
+  version: "5.1.4"};
 
 // core/global.ts
 init_env();
@@ -4656,10 +4863,12 @@ __name(typed, "typed");
 init_esm_shims();
 init_store();
 init_idb();
+init_hlc();
 init_env();
 
 // functions/memory/journal.ts
 init_esm_shims();
+init_hlc();
 init_env();
 init_store();
 var g2 = globalThis;
@@ -5309,19 +5518,22 @@ var memory = {
   async patch(key, patches) {
     const entry = await this._getEntry(key);
     if (!entry) return;
+    const patchedValue = JSON.parse(JSON.stringify(entry.value ?? {}));
     let patched = false;
     for (const p of patches) {
+      const relativePath = p.path.replace(/^[^.]+\./, "");
       if (p.op === "set") {
-        setNestedPath({ [entry.key]: entry.value }, p.path.replace(/^[^.]+\./, ""), p.value);
+        setNestedPath(patchedValue, relativePath, p.value);
         patched = true;
       } else if (p.op === "delete") {
-        deleteNestedPath({ [entry.key]: entry.value }, p.path.replace(/^[^.]+\./, ""));
+        deleteNestedPath(patchedValue, relativePath);
         patched = true;
       }
     }
     if (!patched) return;
     const updated = {
       ...entry,
+      value: patchedValue,
       updatedAt: now(),
       lastConfirmedAt: now(),
       version: (entry.version ? entry.version : 0) + 1,
@@ -5572,6 +5784,7 @@ if (!("memorio" in globalThis)) {
   );
   memorio.memory = memory;
   memorio.encryption = encryption;
+  memorio.sqlite = sqlite;
   initializePlatform();
   memorio.isBrowser = isBrowser;
   memorio.isNode = isNode;