memorio 4.9.31 → 5.0.0

package/index.js

@@ -17,8 +17,11 @@ var DEV, PROD;
 var init_env = __esm({
   "core/env.ts"() {
     init_esm_shims();
-    DEV = typeof process !== "undefined" ? false : true;
+    DEV = false ;
     PROD = !DEV;
+    if (typeof globalThis !== "undefined") {
+      globalThis["__DEV__"] = DEV;
+    }
   }
 });
 
@@ -945,8 +948,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;
@@ -990,8 +993,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();
@@ -1015,8 +1018,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();
@@ -1050,8 +1053,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();
@@ -1087,8 +1090,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();
@@ -1750,9 +1753,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);
@@ -1886,11 +1905,500 @@ var schema = {
 };
 
 // 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;
@@ -1900,6 +2408,7 @@ var deepRaw = /* @__PURE__ */ __name((val, seen = null) => {
   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;
@@ -1952,8 +2461,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];
                 }
               }
@@ -2027,6 +2536,16 @@ var buildProxy = /* @__PURE__ */ __name((obj, callback, tree = []) => {
             }
           );
           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") {
@@ -2083,6 +2602,17 @@ var buildProxy = /* @__PURE__ */ __name((obj, callback, tree = []) => {
           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);
@@ -2104,28 +2634,87 @@ if (globalThis[STATE_INSTANCE_KEY]) {
   state2 = globalThis[STATE_INSTANCE_KEY];
 } else {
   state2 = buildProxy({}, (mutation) => {
-    if (internal_default.historyEnabled) {
-      internal_default.recordMutation({
-        path: mutation.path,
-        action: mutation.action,
-        newValue: mutation.newValue,
-        previousValue: mutation.previousValue,
-        timestamp: Date.now()
-      });
+    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);
     }
   });
-  state2.lock = () => {
-    internal_default.locked = true;
-    message_default("State is now locked. All modifications are blocked.");
-  };
-  state2.unlock = () => {
-    internal_default.locked = false;
-    message_default("State is now unlocked. Modifications are allowed.");
-  };
-  globalThis[STATE_INSTANCE_KEY] = state2;
-}
-
-// index.ts
+  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
@@ -2473,12 +3062,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;
@@ -2541,7 +3135,6 @@ Object.defineProperties(
 init_esm_shims();
 init_message();
 init_internal();
-init_env();
 var useObserver = /* @__PURE__ */ __name(((func, deps = []) => {
   if (!deps || typeof func !== "function") {
     return () => {
@@ -2602,20 +3195,6 @@ var useObserver = /* @__PURE__ */ __name(((func, deps = []) => {
     };
   }
 }), "useObserver");
-if (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();
@@ -2699,7 +3278,7 @@ var clearHistory = /* @__PURE__ */ __name(() => {
   logHistory.length = 0;
 }, "clearHistory");
 var getStats = /* @__PURE__ */ __name(() => {
-  const stats2 = {
+  const stats = {
     total: logHistory.length,
     state: 0,
     store: 0,
@@ -2715,11 +3294,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);
@@ -2736,378 +3315,6 @@ var logger = {
   exportLogs
 };
 
-// functions/devtools/index.ts
-init_esm_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 DEV && internal_default.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, path2) => {
-  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[path2];
-  console.debug(`Watching ${moduleName}.${path2} (initial: ${JSON.stringify(initialValue)})`);
-  if (moduleName === "state" && globalThis.memorio?.dispatch) {
-    const handler = /* @__PURE__ */ __name((e) => {
-      const detail = e.detail;
-      if (detail?.name?.includes(path2)) {
-        console.debug(`Change: ${moduleName}.${path2} =`, 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_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/fractional.ts
 init_esm_shims();
 function generateBetween(left, right, minChars = 2) {
@@ -3300,7 +3507,7 @@ init_internal();
 
 // package.json
 var package_default = {
-  version: "4.9.31"};
+  version: "5.0.0"};
 
 // core/global.ts
 init_env();
@@ -3385,7 +3592,7 @@ var undo = /* @__PURE__ */ __name(() => {
   }
   const record = internal_default.popUndo();
   if (!record) return void 0;
-  _applyInverse(record);
+  _applyInverse2(record);
   message_default(`[memorio history] Undid: ${record.action} ${record.path}`);
   return record;
 }, "undo");
@@ -3400,41 +3607,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 = internal_default.historyEnabled;
   internal_default.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 {
     internal_default.historyEnabled = wasEnabled;
   }
 }
-__name(_applyInverse, "_applyInverse");
+__name(_applyInverse2, "_applyInverse");
 function _applyForward(record) {
   const wasEnabled = internal_default.historyEnabled;
   internal_default.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 {
     internal_default.historyEnabled = wasEnabled;
   }
 }
 __name(_applyForward, "_applyForward");
-function _setPath(path2, value) {
+function _setPath2(path2, value) {
   const parts = path2.split(".");
   let current = state2;
   for (let i = 0; i < parts.length - 1; i++) {
@@ -3446,8 +3653,8 @@ function _setPath(path2, value) {
   }
   current[parts[parts.length - 1]] = value;
 }
-__name(_setPath, "_setPath");
-function _deletePath(path2) {
+__name(_setPath2, "_setPath");
+function _deletePath2(path2) {
   const parts = path2.split(".");
   if (parts.length === 1) {
     state2.remove(parts[0]);
@@ -3461,7 +3668,7 @@ function _deletePath(path2) {
   }
   delete current[parts[parts.length - 1]];
 }
-__name(_deletePath, "_deletePath");
+__name(_deletePath2, "_deletePath");
 var rollback = /* @__PURE__ */ __name((snap) => {
   state2.removeAll();
   for (const key of Object.keys(snap)) {
@@ -4169,84 +4376,6 @@ var memory = {
   }
 };
 
-// functions/inspect/index.ts
-init_esm_shims();
-init_env();
-var stateKeys = /* @__PURE__ */ __name(() => {
-  const raw = deepRaw(state2);
-  return Object.keys(raw).filter(
-    (k) => !["list", "remove", "removeAll", "lock", "unlock"].includes(k)
-  );
-}, "stateKeys");
-var pathExists = /* @__PURE__ */ __name((path2) => {
-  if (!path2 || typeof path2 !== "string") return false;
-  const parts = path2.replace(/^state\./, "").split(".");
-  let current = state2;
-  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((path2) => {
-  const [exists, value] = _getValue(path2);
-  if (!exists || value === void 0) return "undefined";
-  return Array.isArray(value) ? "array" : typeof value;
-}, "stateType");
-var stateGet = /* @__PURE__ */ __name((path2) => {
-  const [exists, value] = _getValue(path2);
-  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(state2), "");
-  return result;
-}, "stateSchema");
-function _getValue(path2) {
-  if (!path2 || typeof path2 !== "string") return [false, void 0];
-  const parts = path2.replace(/^state\./, "").split(".");
-  let current = state2;
-  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 (DEV) console.warn("[memorio inspect] deep clone failed:", err);
-    return value;
-  }
-}
-__name(_clone2, "_clone");
-
 // core/global.ts
 if (!("memorio" in globalThis)) {
   Object.defineProperty(
@@ -4280,6 +4409,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?.());
   }
@@ -4321,10 +4470,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 = DEV;
   memorio.env = {
-    isDev,
+    isDev: DEV,
     isProd: PROD
   };
   memorio.global = function() {
@@ -4343,146 +4499,28 @@ 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 (DEV) {
-    Object.defineProperty(
-      memorio,
-      "debug",
-      {
-        get: /* @__PURE__ */ __name(() => internal_default.debug, "get"),
-        set: /* @__PURE__ */ __name((v) => {
-          internal_default.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 = 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) => internal_default.currentContext = id, "setContext");
 var getContext = /* @__PURE__ */ __name(() => internal_default.currentContext, "getContext");
 var index_default = memorio2;
 
-export { DEV, PROD, cache, canRedo, canUndo, clearHistory2 as clearHistory, clearRedo, createContext, index_default as default, deleteContext, devtools2 as devtools, diff, dispatch, enableHistory, events, fractional, getCapabilities, getContext, help2 as help, hlc, idb, internal_default as internal, isBrowser, isDeno, isEdge, isNode, isolate, listContexts, listSchemas, logger, memorio2 as memorio, memory, message, observer, propertyName, redo, registerSchema, rollback, schema, session, setContext, snapshot, sqlite, state2 as state, store, trace, typed, undo, unregisterSchema, useObserver, validate };
+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=index.js.map
 //# sourceMappingURL=index.js.map