memorio 4.9.35 → 5.0.0

package/index.cjs

@@ -20,8 +20,11 @@ exports.DEV = void 0; exports.PROD = void 0;
 var init_env = __esm({
   "core/env.ts"() {
     init_cjs_shims();
-    exports.DEV = typeof process !== "undefined" ? false : true;
+    exports.DEV = false ;
     exports.PROD = !exports.DEV;
+    if (typeof globalThis !== "undefined") {
+      globalThis["__DEV__"] = exports.DEV;
+    }
   }
 });
 
@@ -948,8 +951,8 @@ var init_table_size = __esm({
         if (!db.objectStoreNames.contains(table)) return resolve(0);
         let size = 0;
         let count = 0;
-        const transaction = db.transaction([table], "readonly");
-        const store2 = transaction.objectStore(table);
+        const transaction2 = db.transaction([table], "readonly");
+        const store2 = transaction2.objectStore(table);
         const request = store2.openCursor();
         request.onsuccess = async (event) => {
           const cursor = event.target.result;
@@ -993,8 +996,8 @@ var init_data_delete = __esm({
             db.close();
             return reject(new Error(`Table ${table} not found`));
           }
-          const transaction = db.transaction(table, "readwrite");
-          const objectStore = transaction.objectStore(table);
+          const transaction2 = db.transaction(table, "readwrite");
+          const objectStore = transaction2.objectStore(table);
           const deleteRequest = objectStore.delete(key);
           deleteRequest.onsuccess = () => {
             db.close();
@@ -1018,8 +1021,8 @@ var init_data_delete = __esm({
             db.close();
             return reject(new Error(`Table ${table} not found`));
           }
-          const transaction = db.transaction(table, "readwrite");
-          const store2 = transaction.objectStore(table);
+          const transaction2 = db.transaction(table, "readwrite");
+          const store2 = transaction2.objectStore(table);
           const clearRequest = store2.clear();
           clearRequest.onsuccess = () => {
             db.close();
@@ -1053,8 +1056,8 @@ var init_data_set = __esm({
             db.close();
             return reject(new Error(`Table ${table} does not exist in ${storeName}`));
           }
-          const transaction = db.transaction(table, "readwrite");
-          const objectStore = transaction.objectStore(table);
+          const transaction2 = db.transaction(table, "readwrite");
+          const objectStore = transaction2.objectStore(table);
           const putRequest = objectStore.put(value);
           putRequest.onsuccess = () => {
             db.close();
@@ -1090,8 +1093,8 @@ var init_data_get = __esm({
             db.close();
             return reject(new Error(`Table ${table} not found in ${storeName}`));
           }
-          const transaction = db.transaction(table, "readonly");
-          const store2 = transaction.objectStore(table);
+          const transaction2 = db.transaction(table, "readonly");
+          const store2 = transaction2.objectStore(table);
           const getRequest = store2.get(key);
           getRequest.onsuccess = () => {
             db.close();
@@ -1753,9 +1756,25 @@ var dispatch = {
     const wrapped = /* @__PURE__ */ __name((e) => {
       const target = e;
       if (globalThis.queueMicrotask) {
-        globalThis.queueMicrotask(() => cb(target));
+        globalThis.queueMicrotask(() => {
+          try {
+            cb(target);
+          } catch (err) {
+            if (typeof console !== "undefined") {
+              console.error("[memorio dispatch] observer error:", err);
+            }
+          }
+        });
       } else {
-        Promise.resolve().then(() => cb(target));
+        Promise.resolve().then(() => {
+          try {
+            cb(target);
+          } catch (err) {
+            if (typeof console !== "undefined") {
+              console.error("[memorio dispatch] observer error:", err);
+            }
+          }
+        });
       }
     }, "wrapped");
     globalThis.addEventListener(name, wrapped);
@@ -1891,10 +1910,498 @@ var schema = {
 // functions/state/index.ts
 init_store();
 init_env();
+
+// core/mutation/engine.ts
+init_cjs_shims();
+init_internal();
+
+// core/hlc.ts
+init_cjs_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_cjs_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_cjs_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(path, before2, after2) {
+  if (before2 === after2) return null;
+  if (after2 === void 0) {
+    return { op: "remove", path, oldValue: before2 };
+  }
+  if (before2 === void 0) {
+    return { op: "add", path, value: after2 };
+  }
+  return { op: "replace", path, 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_cjs_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(path, value) {
+  const parts = path.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(path) {
+  const parts = path.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 = exports.internal.historyEnabled;
+  const wasRecording = exports.internal._recording;
+  exports.internal.historyEnabled = false;
+  exports.internal._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 {
+    exports.internal.historyEnabled = wasEnabled;
+    exports.internal._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 = exports.internal.undoStack;
+    const idx = undoStack.findIndex((r) => r.id === ctx.mutations[i]);
+    if (idx >= 0) {
+      const record = undoStack[idx];
+      exports.internal.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(path, operation, before2, after2, options) {
+  const now2 = hlc.tick();
+  const mutation = {
+    id: generateMutationId(),
+    path,
+    operation,
+    after: after2,
+    before: before2,
+    timestamp: now2.physical,
+    hlc: hlc.serialize(now2),
+    context: options?.context || exports.internal.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 (!exports.internal.historyEnabled) return;
+  exports.internal.recordMutation(mutation);
+}
+__name(recordMutation, "recordMutation");
+function toPatch(mutation) {
+  return mutationToPatch(mutation);
+}
+__name(toPatch, "toPatch");
+function mutate(path, value, options) {
+  const normalizedPath = path.startsWith("state.") ? path : "state." + path;
+  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 = exports.internal._recording;
+  exports.internal._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;
+  }
+  exports.internal._recording = wasRecording;
+  recordMutation(mutation);
+  return mutation;
+}
+__name(mutate, "mutate");
+function activeTransactionId() {
+  return exports.internal.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;
@@ -1957,8 +2464,8 @@ var buildProxy = /* @__PURE__ */ __name((obj, callback, tree = []) => {
         if (prop === "removeAll") {
           return () => {
             try {
-              for (const key in target) {
-                if (typeof target[key] !== "function" && !["list", "remove", "removeAll", "lock", "unlock"].includes(key)) {
+              for (const key of Reflect.ownKeys(target)) {
+                if (typeof target[key] !== "function" && !["list", "remove", "removeAll", "lock", "unlock", "persist"].includes(key)) {
                   delete target[key];
                 }
               }
@@ -2032,6 +2539,16 @@ var buildProxy = /* @__PURE__ */ __name((obj, callback, tree = []) => {
             }
           );
           event("state." + path);
+          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);
           exports.internal.bumpStateVersion();
           if (target[key] && typeof target[key] === "object") {
@@ -2088,6 +2605,17 @@ var buildProxy = /* @__PURE__ */ __name((obj, callback, tree = []) => {
           const path = objPath(prop, tree);
           const previousValue = Reflect.get(target, prop);
           callback({ action: "delete", path, target, previousValue });
+          event("state." + path);
+          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);
@@ -2109,57 +2637,83 @@ if (globalThis[STATE_INSTANCE_KEY]) {
   exports.state = globalThis[STATE_INSTANCE_KEY];
 } else {
   exports.state = buildProxy({}, (mutation) => {
-    if (exports.internal.historyEnabled) {
-      exports.internal.recordMutation({
-        path: mutation.path,
-        action: mutation.action,
-        newValue: mutation.newValue,
-        previousValue: mutation.previousValue,
-        timestamp: Date.now()
-      });
-    }
-  });
-  exports.state.lock = () => {
-    exports.internal.locked = true;
-    message_default("State is now locked. All modifications are blocked.");
-  };
-  exports.state.unlock = () => {
-    exports.internal.locked = false;
-    message_default("State is now unlocked. Modifications are allowed.");
-  };
-  exports.state.persist = (path) => {
-    if (typeof path !== "string" || !path.length) {
-      if (exports.DEV) console.warn('[memorio state] state.persist() requires a non-empty path string (e.g. "state.user")');
-      return () => {
-      };
-    }
-    const normalized = path.startsWith("state.") ? path : "state." + path;
-    const key = normalized.replace(/^state\./, "");
-    const segments = key.split(".");
-    const initial = exports.store.get(key);
-    if (initial !== void 0 && initial !== null) {
-      let acc = exports.state;
-      for (let i = 0; i < segments.length; i++) {
-        const seg = segments[i];
-        if (i === segments.length - 1) {
-          acc[seg] = deepRaw(initial);
-        } else {
-          if (acc[seg] === void 0 || acc[seg] === null) acc[seg] = {};
-          acc = acc[seg];
+    if (exports.internal.historyEnabled && exports.internal._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
         }
-      }
+      );
+      exports.internal.recordMutation(record);
     }
-    const handler = /* @__PURE__ */ __name(() => {
-      let current = exports.state;
-      for (const seg of segments) {
-        current = current === void 0 || current === null ? void 0 : current[seg];
-      }
-      exports.store.set(key, deepRaw(current));
-    }, "handler");
-    const off = dispatch.listen(normalized, handler);
-    return typeof off === "function" ? off : () => {
-    };
-  };
+  });
+  const _rawTarget = exports.state[TARGET];
+  try {
+    Object.defineProperty(_rawTarget, "lock", {
+      value: /* @__PURE__ */ __name(() => {
+        exports.internal.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(() => {
+        exports.internal.locked = false;
+        message_default("State is now unlocked. Modifications are allowed.");
+      }, "value"),
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  } catch (e) {
+    if (exports.DEV) console.warn("[memorio state] lock/unlock defineProperty failed:", e);
+  }
+  try {
+    Object.defineProperty(_rawTarget, "persist", {
+      value: /* @__PURE__ */ __name((path) => {
+        if (typeof path !== "string" || !path.length) {
+          if (exports.DEV) console.warn('[memorio state] state.persist() requires a non-empty path string (e.g. "state.user")');
+          return () => {
+          };
+        }
+        const normalized = path.startsWith("state.") ? path : "state." + path;
+        const key = normalized.replace(/^state\./, "");
+        const segments = key.split(".");
+        const initial = exports.store.get(key);
+        if (initial !== void 0 && initial !== null) {
+          let acc = exports.state;
+          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 = exports.state;
+          for (const seg of segments) {
+            current = current === void 0 || current === null ? void 0 : current[seg];
+          }
+          exports.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 (exports.DEV) console.warn("[memorio state] persist defineProperty failed:", e);
+  }
   globalThis[STATE_INSTANCE_KEY] = exports.state;
 }
 
@@ -2511,12 +3065,17 @@ var observerFunction = /* @__PURE__ */ __name((s, cb = null, option = true) => {
     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") {
-        dispatch.listen(resolvedPath, callback, option);
+        const off = dispatch.listen(resolvedPath, callback, option);
+        if (typeof off === "function") unsubs.push(off);
       }
     });
-    return;
+    if (unsubs.length === 1) return unsubs[0];
+    if (unsubs.length > 1) return () => unsubs.forEach((u) => u());
+    return () => {
+    };
   }
 }, "observerFunction");
 var observer = observerFunction;
@@ -2579,7 +3138,6 @@ Object.defineProperties(
 init_cjs_shims();
 init_message();
 init_internal();
-init_env();
 var useObserver = /* @__PURE__ */ __name(((func, deps = []) => {
   if (!deps || typeof func !== "function") {
     return () => {
@@ -2640,20 +3198,6 @@ var useObserver = /* @__PURE__ */ __name(((func, deps = []) => {
     };
   }
 }), "useObserver");
-if (exports.DEV && !("useObserver" in globalThis)) {
-  if (!globalThis.useObserver) globalThis.useObserver = null;
-  Object.defineProperty(
-    globalThis,
-    "useObserver",
-    {
-      value: useObserver,
-      writable: true,
-      enumerable: false,
-      configurable: true
-    }
-  );
-  Object.freeze(globalThis.useObserver);
-}
 
 // index.ts
 init_message();
@@ -2737,7 +3281,7 @@ var clearHistory = /* @__PURE__ */ __name(() => {
   logHistory.length = 0;
 }, "clearHistory");
 var getStats = /* @__PURE__ */ __name(() => {
-  const stats2 = {
+  const stats = {
     total: logHistory.length,
     state: 0,
     store: 0,
@@ -2753,11 +3297,11 @@ var getStats = /* @__PURE__ */ __name(() => {
     if (entry) {
       const module = entry.module;
       const action = entry.action;
-      if (module && typeof stats2[module] === "number") stats2[module]++;
-      if (action && typeof stats2[action] === "number") stats2[action]++;
+      if (module && typeof stats[module] === "number") stats[module]++;
+      if (action && typeof stats[action] === "number") stats[action]++;
     }
   }
-  return stats2;
+  return stats;
 }, "getStats");
 var exportLogs = /* @__PURE__ */ __name(() => {
   return JSON.stringify(logHistory, null, 2);
@@ -2774,378 +3318,6 @@ var logger = {
   exportLogs
 };
 
-// functions/devtools/index.ts
-init_cjs_shims();
-init_internal();
-init_env();
-var _state = globalThis.__memorio_state_instance__;
-var _store = globalThis.__memorio_store_instance__;
-var _session = globalThis.__memorio_session_instance__;
-var _cache = globalThis.__memorio_cache_instance__;
-function isDebugEnabled2() {
-  return exports.DEV && exports.internal.debug === true;
-}
-__name(isDebugEnabled2, "isDebugEnabled");
-function extractStoreData() {
-  if (!_store) return {};
-  const result = {};
-  const store2 = _store;
-  if (typeof store2.list === "function") {
-    try {
-      return store2.list();
-    } catch {
-    }
-  }
-  if (typeof store2.get === "function") {
-    for (const key of Object.keys(store2)) {
-      if (!["get", "set", "remove", "delete", "removeAll", "clearAll", "size", "isPersistent", "list"].includes(key)) {
-        try {
-          const val = store2.get(key);
-          if (val !== null && val !== void 0) {
-            result[key] = val;
-          }
-        } catch {
-        }
-      }
-    }
-  }
-  return result;
-}
-__name(extractStoreData, "extractStoreData");
-function extractSessionData() {
-  if (!_session) return {};
-  const result = {};
-  const session2 = _session;
-  if (typeof session2.list === "function") {
-    try {
-      return session2.list();
-    } catch {
-    }
-  }
-  if (typeof session2.get === "function") {
-    for (const key of Object.keys(session2)) {
-      if (!["get", "set", "remove", "delete", "removeAll", "clearAll", "size", "isPersistent", "list"].includes(key)) {
-        try {
-          const val = session2.get(key);
-          if (val !== null && val !== void 0) {
-            result[key] = val;
-          }
-        } catch {
-        }
-      }
-    }
-  }
-  return result;
-}
-__name(extractSessionData, "extractSessionData");
-var inspect = /* @__PURE__ */ __name(() => {
-  if (!isDebugEnabled2()) return;
-  if (_state) {
-    const stateList = _state.list;
-    let stateData;
-    if (typeof stateList === "function") {
-      stateData = stateList();
-    } else if (typeof stateList === "object" && stateList !== null) {
-      stateData = stateList;
-    } else {
-      stateData = _state;
-    }
-    console.table(stateData);
-  }
-  if (_store) {
-    console.table(extractStoreData());
-  }
-  if (_session) {
-    console.table(extractSessionData());
-  }
-  if (_cache) {
-    const cacheList = _cache.list;
-    let cacheData2;
-    if (typeof cacheList === "function") {
-      cacheData2 = cacheList();
-    } else if (typeof cacheList === "object" && cacheList !== null) {
-      cacheData2 = cacheList;
-    } else {
-      cacheData2 = _cache;
-    }
-    console.table(cacheData2);
-  }
-}, "inspect");
-var stats = /* @__PURE__ */ __name(() => {
-  const getKeys = /* @__PURE__ */ __name((obj) => {
-    if (!obj) return 0;
-    if (typeof obj.list === "function") {
-      try {
-        const list = obj.list();
-        return Object.keys(list).length;
-      } catch {
-      }
-    }
-    return Object.keys(obj).length;
-  }, "getKeys");
-  return {
-    stateKeys: getKeys(_state),
-    storeKeys: getKeys(_store),
-    sessionKeys: getKeys(_session),
-    cacheKeys: getKeys(_cache),
-    idbDatabases: 0,
-    sqliteDbCount: 0,
-    lastUpdate: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}, "stats");
-var clear = /* @__PURE__ */ __name((moduleName) => {
-  const targets = { state: _state, store: _store, session: _session, cache: _cache };
-  const target = targets[moduleName];
-  if (target && typeof target.clear === "function") {
-    target.clear();
-  } else if (target && typeof target.removeAll === "function") {
-    target.removeAll();
-  } else {
-    console.debug(`Module ${moduleName} not found or does not support clear()/removeAll()`);
-  }
-}, "clear");
-var clearAll = /* @__PURE__ */ __name(() => {
-  clear("state");
-  clear("store");
-  clear("session");
-  clear("cache");
-}, "clearAll");
-var exportData = /* @__PURE__ */ __name(() => {
-  const getStateData = /* @__PURE__ */ __name(() => {
-    if (!_state) return void 0;
-    try {
-      if (typeof _state.list === "function") {
-        return _state.list();
-      }
-      return _state;
-    } catch {
-      return void 0;
-    }
-  }, "getStateData");
-  const getStoreData = /* @__PURE__ */ __name(() => {
-    return extractStoreData();
-  }, "getStoreData");
-  const getSessionData = /* @__PURE__ */ __name(() => {
-    return extractSessionData();
-  }, "getSessionData");
-  const getCacheData = /* @__PURE__ */ __name(() => {
-    if (!_cache) return void 0;
-    try {
-      if (typeof _cache.list === "function") {
-        return _cache.list();
-      }
-      return _cache;
-    } catch {
-      return void 0;
-    }
-  }, "getCacheData");
-  const data = {
-    state: getStateData(),
-    store: getStoreData(),
-    session: getSessionData(),
-    cache: getCacheData(),
-    exportedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  return JSON.stringify(data, null, 2);
-}, "exportData");
-var importData = /* @__PURE__ */ __name((jsonString) => {
-  try {
-    const data = JSON.parse(jsonString);
-    if (data.state) {
-      Object.entries(data.state).forEach(([key, value]) => {
-        if (_state && key !== "list" && key !== "remove" && key !== "removeAll") {
-          ;
-          _state[key] = value;
-        }
-      });
-    }
-    if (data.store && _store && typeof _store.set === "function") {
-      Object.entries(data.store).forEach(([key, value]) => {
-        ;
-        _store.set(key, value);
-      });
-    }
-    if (data.session && _session && typeof _session.set === "function") {
-      Object.entries(data.session).forEach(([key, value]) => {
-        ;
-        _session.set(key, value);
-      });
-    }
-    if (data.cache && _cache) {
-      Object.entries(data.cache).forEach(([key, value]) => {
-        if (_cache && key !== "get" && key !== "set" && key !== "remove" && key !== "clear") {
-          ;
-          _cache[key] = value;
-        }
-      });
-    }
-  } catch (error) {
-    console.debug("Import failed:", error);
-  }
-}, "importData");
-var watch = /* @__PURE__ */ __name((moduleName, path) => {
-  const targets = { state: _state, store: _store, session: _session, cache: _cache };
-  const target = targets[moduleName];
-  if (!target) {
-    console.debug(`Module ${moduleName} not found`);
-    return;
-  }
-  const initialValue = target[path];
-  console.debug(`Watching ${moduleName}.${path} (initial: ${JSON.stringify(initialValue)})`);
-  if (moduleName === "state" && globalThis.memorio?.dispatch) {
-    const handler = /* @__PURE__ */ __name((e) => {
-      const detail = e.detail;
-      if (detail?.name?.includes(path)) {
-        console.debug(`Change: ${moduleName}.${path} =`, e.detail.value);
-      }
-    }, "handler");
-    target.addEventListener?.("memorio-change", handler);
-  }
-}, "watch");
-var help = /* @__PURE__ */ __name(() => {
-  console.debug(`
-Memorio DevTools Help
-
-Available commands:
-  memorio.devtools.inspect()          - Inspect all state modules
-  memorio.devtools.stats()            - Show statistics
-  memorio.devtools.clear('module')    - Clear specific module
-  memorio.devtools.clearAll()         - Clear all modules
-  memorio.devtools.exportData()       - Export all data as JSON
-  memorio.devtools.importData(json)   - Import data from JSON
-  memorio.devtools.watch(module, path) - Watch a path for changes
-  memorio.devtools.help()             - Show this help
-
-Shortcuts (dev only):
-  state    - global state proxy
-  store    - localStorage wrapper
-  session  - sessionStorage wrapper
-  cache    - in-memory cache
-  `);
-}, "help");
-var devtools = {
-  inspect,
-  stats,
-  clear,
-  clearAll,
-  exportData,
-  importData,
-  watch,
-  help
-};
-
-// core/hlc.ts
-init_cjs_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/fractional.ts
 init_cjs_shims();
 function generateBetween(left, right, minChars = 2) {
@@ -3338,7 +3510,7 @@ init_internal();
 
 // package.json
 var package_default = {
-  version: "4.9.35"};
+  version: "5.0.0"};
 
 // core/global.ts
 init_env();
@@ -3423,7 +3595,7 @@ var undo = /* @__PURE__ */ __name(() => {
   }
   const record = exports.internal.popUndo();
   if (!record) return void 0;
-  _applyInverse(record);
+  _applyInverse2(record);
   message_default(`[memorio history] Undid: ${record.action} ${record.path}`);
   return record;
 }, "undo");
@@ -3438,41 +3610,41 @@ var redo = /* @__PURE__ */ __name(() => {
   message_default(`[memorio history] Redid: ${record.action} ${record.path}`);
   return record;
 }, "redo");
-function _applyInverse(record) {
+function _applyInverse2(record) {
   const wasEnabled = exports.internal.historyEnabled;
   exports.internal.historyEnabled = false;
   try {
     if (record.action === "set") {
       if (record.previousValue === void 0) {
-        _deletePath(record.path);
+        _deletePath2(record.path);
       } else {
-        _setPath(record.path, record.previousValue);
+        _setPath2(record.path, record.previousValue);
       }
     } else if (record.action === "delete") {
       if (record.previousValue !== void 0) {
-        _setPath(record.path, record.previousValue);
+        _setPath2(record.path, record.previousValue);
       }
     }
   } finally {
     exports.internal.historyEnabled = wasEnabled;
   }
 }
-__name(_applyInverse, "_applyInverse");
+__name(_applyInverse2, "_applyInverse");
 function _applyForward(record) {
   const wasEnabled = exports.internal.historyEnabled;
   exports.internal.historyEnabled = false;
   try {
     if (record.action === "set") {
-      _setPath(record.path, record.newValue);
+      _setPath2(record.path, record.newValue);
     } else if (record.action === "delete") {
-      _deletePath(record.path);
+      _deletePath2(record.path);
     }
   } finally {
     exports.internal.historyEnabled = wasEnabled;
   }
 }
 __name(_applyForward, "_applyForward");
-function _setPath(path, value) {
+function _setPath2(path, value) {
   const parts = path.split(".");
   let current = exports.state;
   for (let i = 0; i < parts.length - 1; i++) {
@@ -3484,8 +3656,8 @@ function _setPath(path, value) {
   }
   current[parts[parts.length - 1]] = value;
 }
-__name(_setPath, "_setPath");
-function _deletePath(path) {
+__name(_setPath2, "_setPath");
+function _deletePath2(path) {
   const parts = path.split(".");
   if (parts.length === 1) {
     exports.state.remove(parts[0]);
@@ -3499,7 +3671,7 @@ function _deletePath(path) {
   }
   delete current[parts[parts.length - 1]];
 }
-__name(_deletePath, "_deletePath");
+__name(_deletePath2, "_deletePath");
 var rollback = /* @__PURE__ */ __name((snap) => {
   exports.state.removeAll();
   for (const key of Object.keys(snap)) {
@@ -4207,84 +4379,6 @@ var memory = {
   }
 };
 
-// functions/inspect/index.ts
-init_cjs_shims();
-init_env();
-var stateKeys = /* @__PURE__ */ __name(() => {
-  const raw = deepRaw(exports.state);
-  return Object.keys(raw).filter(
-    (k) => !["list", "remove", "removeAll", "lock", "unlock"].includes(k)
-  );
-}, "stateKeys");
-var pathExists = /* @__PURE__ */ __name((path) => {
-  if (!path || typeof path !== "string") return false;
-  const parts = path.replace(/^state\./, "").split(".");
-  let current = exports.state;
-  for (const part of parts) {
-    if (current === null || current === void 0) {
-      return false;
-    }
-    current = current[part];
-  }
-  return current !== void 0;
-}, "pathExists");
-var stateType = /* @__PURE__ */ __name((path) => {
-  const [exists, value] = _getValue(path);
-  if (!exists || value === void 0) return "undefined";
-  return Array.isArray(value) ? "array" : typeof value;
-}, "stateType");
-var stateGet = /* @__PURE__ */ __name((path) => {
-  const [exists, value] = _getValue(path);
-  if (!exists || value === void 0) return void 0;
-  return _clone2(value);
-}, "stateGet");
-var stateSchema = /* @__PURE__ */ __name(() => {
-  const result = [];
-  const _walk = /* @__PURE__ */ __name((obj, prefix) => {
-    if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
-      return;
-    }
-    const keys = Object.keys(obj).filter(
-      (k) => !["list", "remove", "removeAll", "lock", "unlock"].includes(k)
-    );
-    for (const key of keys) {
-      const newPath = prefix ? `${prefix}.${key}` : key;
-      const value = obj[key];
-      const defined = value !== void 0;
-      const type = defined ? Array.isArray(value) ? "array" : typeof value : "undefined";
-      result.push({ path: newPath, type, defined });
-      if (defined && typeof value === "object" && !Array.isArray(value) && value.constructor?.name === "Object") {
-        _walk(value, newPath);
-      }
-    }
-  }, "_walk");
-  _walk(deepRaw(exports.state), "");
-  return result;
-}, "stateSchema");
-function _getValue(path) {
-  if (!path || typeof path !== "string") return [false, void 0];
-  const parts = path.replace(/^state\./, "").split(".");
-  let current = exports.state;
-  for (const part of parts) {
-    if (current === null || current === void 0) {
-      return [false, void 0];
-    }
-    current = current[part];
-  }
-  return [current !== void 0, current];
-}
-__name(_getValue, "_getValue");
-function _clone2(value) {
-  if (value === null || typeof value !== "object") return value;
-  try {
-    return deepRaw(value, /* @__PURE__ */ new WeakSet());
-  } catch (err) {
-    if (exports.DEV) console.warn("[memorio inspect] deep clone failed:", err);
-    return value;
-  }
-}
-__name(_clone2, "_clone");
-
 // core/global.ts
 if (!("memorio" in globalThis)) {
   Object.defineProperty(
@@ -4318,6 +4412,26 @@ if (!("memorio" in globalThis)) {
       }
     );
   }
+  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?.());
   }
@@ -4359,10 +4473,17 @@ if (!("memorio" in globalThis)) {
   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 });
-  const isDev = exports.DEV;
   memorio.env = {
-    isDev,
+    isDev: exports.DEV,
     isProd: exports.PROD
   };
   memorio.global = function() {
@@ -4381,163 +4502,57 @@ if (!("memorio" in globalThis)) {
         Object.defineProperty(globalThis, key, {
           value: globalDefinitions[key],
           writable: true,
-          enumerable: false,
-          configurable: true
+          configurable: true,
+          enumerable: false
         });
       }
     }
+    if (typeof globalThis.useObserver === "function") {
+      Object.freeze(globalThis.useObserver);
+    }
   };
-  if (isDev) {
-    memorio.global();
-  }
-  if (exports.DEV) {
-    Object.defineProperty(
-      memorio,
-      "debug",
-      {
-        get: /* @__PURE__ */ __name(() => exports.internal.debug, "get"),
-        set: /* @__PURE__ */ __name((v) => {
-          exports.internal.debug = v;
-        }, "set"),
-        enumerable: false
-      }
-    );
-    const caps = getCapabilities();
-    Object.defineProperty(memorio, "_platform", { writable: false, enumerable: false, value: caps.platform });
-    Object.defineProperty(memorio, "_capabilities", { writable: false, enumerable: false, value: caps });
-    Object.defineProperty(memorio, "_sessionId", { writable: false, enumerable: false, value: generateSessionId() });
-    memorio.logger = logger;
-    if (!("$state" in globalThis)) Object.defineProperty(globalThis, "$state", { get: /* @__PURE__ */ __name(() => globalThis.state, "get"), configurable: true });
-    if (!("$store" in globalThis)) Object.defineProperty(globalThis, "$store", { get: /* @__PURE__ */ __name(() => globalThis.store, "get"), configurable: true });
-    if (!("$session" in globalThis)) Object.defineProperty(globalThis, "$session", { get: /* @__PURE__ */ __name(() => globalThis.session, "get"), configurable: true });
-    if (!("$cache" in globalThis)) Object.defineProperty(globalThis, "$cache", { get: /* @__PURE__ */ __name(() => globalThis.cache, "get"), configurable: true });
-    memorio.devtools = devtools;
-    memorio.inspect = stateKeys;
-    memorio.stateKeys = stateKeys;
-    memorio.pathExists = pathExists;
-    memorio.stateType = stateType;
-    memorio.stateGet = stateGet;
-    memorio.stateSchema = stateSchema;
-    memorio.help = function() {
-      console.debug(`
-\u{1F9E0} Memorio ${package_default.version} - Help
-
-Core Modules (runtime):
-  state     - Reactive state management (DEV global)
-  store     - Persistent storage (localStorage/Map)
-  session   - Session storage (sessionStorage/Map)
-  cache     - In-memory cache
-  idb       - IndexedDB (browser only)
-  sqlite    - SQLite in browser (sql.js, optional)
-
-Platform Detection:
-  memorio.isBrowser()    - Browser environment
-  memorio.isNode()       - Node.js environment
-  memorio.isDeno()       - Deno environment
-  memorio.isEdge()       - Edge/Worker environment
-  memorio.getCapabilities() - Full capabilities object
-
-Context Management:
-  memorio.isolate(name)   - Create isolated context
-  memorio.listContexts()  - List all contexts
-  memorio.deleteContext(id) - Delete a context
-
-Schema Validation (runtime):
-  memorio.registerSchema()  - Register a validator for a state path
-  memorio.validate()         - Manually validate a value
-  memorio.unregisterSchema() - Remove a registered schema
-  memorio.listSchemas()      - List all registered schema paths
-  memorio.typed<T>()         - Type-safe view of global state (compile-time only)
-
-History & Time Travel (runtime):
-  memorio.snapshot()         - Capture a deep snapshot of state
-  memorio.diff(snap)         - Diff snapshot against current state
-  memorio.undo() / redo()    - Undo / redo the last mutation
-  memorio.canUndo() / canRedo() - Check availability
-  memorio.rollback(snap)     - Restore state from a snapshot
-  memorio.trace()            - List all recorded mutations
-  memorio.enableHistory()    - Enable/disable mutation tracking
-  memorio.clearHistory()     - Clear undo/redo stacks and trace log
-
-DevTools (development-only):
-  memorio.devtools.inspect()   - Inspect all modules
-  memorio.devtools.stats()     - Show statistics
-  memorio.devtools.watch()     - Watch a path
-  memorio.devtools.exportData() - Export as JSON
-  memorio.devtools.importData() - Import from JSON
-  memorio.devtools.clear()     - Clear specific module
-  memorio.devtools.clearAll()  - Clear all modules
-
-Introspection (development-only):
-  memorio.stateKeys()        - List top-level state keys
-  memorio.pathExists(path)   - Check if a state path exists
-  memorio.stateType(path)    - Get runtime type of a state value
-  memorio.stateGet(path)     - Get a deep-cloned value at a path
-  memorio.stateSchema()      - Get a schema report of all state paths
-
-Debug:
-  memorio.debug = true       - Enable debug output (DEV only)
-
-Memory System (runtime):
-  memorio.memory.remember(key, value, opts) - Store a memory with type, confidence, scope, TTL, tags
-  memorio.memory.recall(key, opts)          - Retrieve a memory with filtering
-  memorio.memory.update(key, value, opts)   - Update an existing memory
-  memorio.memory.forget(key)                 - Delete a specific memory
-  memorio.memory.context(opts)              - Get ranked relevant memories (semantic context for AI)
-  memorio.memory.stats()                     - Memory usage statistics
-  memorio.memory.forgetExpired()              - Remove all expired entries
-  memorio.memory.clear()                      - Wipe all memories
-  memorio.memory.configure({ sync })          - Optional cloud-sync provider + namespace
-  memorio.memory.journal.pending()            - Local op journal (SQLite/store)
-
-Scopes:
-  hot      - In-memory reactive state (volatile, fastest)
-  session  - sessionStorage (persists across page reloads, cleared on tab close)
-  local    - localStorage (persistent, survives browser restart)
-  durable  - IndexedDB (large datasets, async)
-  sql      - SQLite / sql.js (browser, optional, full SQL)
-
-TTL options:
-  ttl: number (milliseconds) or null (never expires)
-
-Memory types:
-  fact, preference, decision, task, context
-
-  Console shortcuts (DEV only):
-  state, store, session, cache, idb, sqlite - direct access to modules
-  $state, $store, $session, $cache - aliases for the above
-  `);
-    };
-  }
 }
 
 // index.ts
-var devtools2 = exports.DEV ? devtools : void 0;
+var transaction = beginTransaction;
+var devtools = void 0;
 var memorio2 = globalThis.memorio;
 var events = globalThis.events;
 var isolate = /* @__PURE__ */ __name((name) => createContext(name), "isolate");
-var help2 = globalThis.memorio?.help;
+var help = globalThis.memorio?.help;
 var setContext = /* @__PURE__ */ __name((id) => exports.internal.currentContext = id, "setContext");
 var getContext = /* @__PURE__ */ __name(() => exports.internal.currentContext, "getContext");
 var index_default = memorio2;
 
+exports.abortTransaction = abortTransaction;
+exports.activeTransactionId = activeTransactionId;
+exports.beginTransaction = beginTransaction;
 exports.cache = cache;
+exports.canMerge = canMerge;
 exports.canRedo = canRedo;
 exports.canUndo = canUndo;
 exports.clearHistory = clearHistory2;
 exports.clearRedo = clearRedo;
+exports.commitTransaction = commitTransaction;
 exports.createContext = createContext;
+exports.createMutation = createMutation;
+exports.currentTimestamp = currentTimestamp;
+exports.currentTransaction = currentTransaction;
 exports.default = index_default;
 exports.deleteContext = deleteContext;
-exports.devtools = devtools2;
+exports.devtools = devtools;
 exports.diff = diff;
+exports.diffToPatch = diffToPatch;
 exports.dispatch = dispatch;
 exports.enableHistory = enableHistory;
 exports.events = events;
 exports.fractional = fractional;
+exports.generateCommitId = generateCommitId;
+exports.generateMutationId = generateMutationId;
+exports.generateTransactionId = generateTransactionId;
 exports.getCapabilities = getCapabilities;
 exports.getContext = getContext;
-exports.help = help2;
+exports.help = help;
 exports.hlc = hlc;
 exports.isBrowser = isBrowser;
 exports.isDeno = isDeno;
@@ -4546,17 +4561,24 @@ exports.isNode = isNode;
 exports.isolate = isolate;
 exports.listContexts = listContexts;
 exports.listSchemas = listSchemas;
+exports.listTransactions = listTransactions;
 exports.logger = logger;
 exports.memorio = memorio2;
 exports.memory = memory;
+exports.mergePatches = mergePatches;
+exports.mutate = mutate;
+exports.mutationToPatch = mutationToPatch;
 exports.observer = observer;
+exports.recordMutation = recordMutation;
 exports.redo = redo;
 exports.registerSchema = registerSchema;
 exports.rollback = rollback;
 exports.schema = schema;
 exports.setContext = setContext;
 exports.snapshot = snapshot;
+exports.toPatch = toPatch;
 exports.trace = trace;
+exports.transaction = transaction;
 exports.typed = typed;
 exports.undo = undo;
 exports.unregisterSchema = unregisterSchema;