memorio 4.9.31 → 5.0.0

package/modules/redux.cjs

@@ -178,7 +178,10 @@ var DEV;
 var init_env = __esm({
   "core/env.ts"() {
     init_cjs_shims();
-    DEV = typeof process !== "undefined" ? false : true;
+    DEV = false ;
+    if (typeof globalThis !== "undefined") {
+      globalThis["__DEV__"] = DEV;
+    }
   }
 });
 
@@ -808,9 +811,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);
@@ -943,246 +962,6 @@ var schema = {
   get: getSchema
 };
 
-// functions/state/index.ts
-init_env();
-var TARGET = /* @__PURE__ */ Symbol("memorio.target");
-var wrapperCache = /* @__PURE__ */ new WeakMap();
-var deepRaw = /* @__PURE__ */ __name((val, seen = null) => {
-  if (val === null || typeof val !== "object") return val;
-  if (val[TARGET] !== void 0) return deepRaw(val[TARGET], seen);
-  if (seen) {
-    if (seen.has(val)) return val;
-    seen.add(val);
-  }
-  const ctor = val.constructor?.name;
-  if (ctor !== "Object" && ctor !== "Array") return val;
-  const copy = Array.isArray(val) ? [] : {};
-  for (const k of Reflect.ownKeys(val)) {
-    copy[k] = deepRaw(val[k], seen);
-  }
-  return copy;
-}, "deepRaw");
-var objPath = /* @__PURE__ */ __name((prop, object, separator = ".") => {
-  return object.concat(prop).join(separator);
-}, "objPath");
-var buildProxy = /* @__PURE__ */ __name((obj, callback, tree = []) => {
-  const event = /* @__PURE__ */ __name((name) => {
-    try {
-      dispatch.set(name, { detail: { name } });
-    } catch (err) {
-      if (DEV) console.warn("[memorio state] event dispatch failed:", err);
-    }
-    return;
-  }, "event");
-  return new Proxy(
-    obj,
-    {
-      get(target, prop) {
-        if (prop === "__path") {
-          return tree.length > 0 ? "state." + tree.join(".") : "state";
-        }
-        if (prop === TARGET) {
-          return target;
-        }
-        if (target[TARGET] !== void 0) {
-          return target;
-        }
-        if (prop === "list") {
-          message_default('Some state could be hidden when you use "state.list". Use "state" to see the complete list ');
-          return deepRaw(target, /* @__PURE__ */ new WeakSet());
-        }
-        if (typeof prop === "string") {
-          const path = tree.length > 0 ? "state." + tree.concat(prop).join(".") : "state." + prop;
-          internal_default.lastAccessedPath = path;
-          if (internal_default.tracking) {
-            internal_default.trackedPaths.add(path);
-          }
-        }
-        if (prop === "_lastPath") {
-          return internal_default.lastAccessedPath;
-        }
-        if (prop === "remove") {
-          return (key) => {
-            delete target[key];
-            return true;
-          };
-        }
-        if (prop === "removeAll") {
-          return () => {
-            try {
-              for (const key in target) {
-                if (typeof target[key] !== "function" && !["list", "remove", "removeAll", "lock", "unlock"].includes(key)) {
-                  delete target[key];
-                }
-              }
-            } catch (error) {
-              console.error(error);
-            }
-            return;
-          };
-        }
-        if (Object.isFrozen(target[prop])) return target[prop];
-        if (prop === "lock" || prop === "unlock") {
-          const value = Reflect.get(target, prop);
-          if (value) return value;
-        }
-        try {
-          const value = Reflect.get(target, prop);
-          if (value && typeof value === "object" && ["Array", "Object"].includes(value.constructor.name)) {
-            let wrapper = wrapperCache.get(value);
-            if (!wrapper) {
-              wrapper = buildProxy(value, callback, tree.concat(prop));
-              wrapperCache.set(value, wrapper);
-            }
-            return wrapper;
-          }
-          return value;
-        } catch (error) {
-          console.error("Error: ", error);
-          return void 0;
-        }
-      },
-      set(target, key, value) {
-        if (internal_default.locked) {
-          console.error("Error: state is locked. Use state.unlock() to enable modifications.");
-          return false;
-        }
-        if (protect.includes(key)) {
-          console.error("key " + key + " is protected");
-          return false;
-        }
-        if (target[key] && typeof target[key] === "object" && Object.isFrozen(target[key])) {
-          console.error(`Error: state '${key}' is locked`);
-          return false;
-        }
-        if (target[key] && typeof target[key] === "object" && target[key].__locked) {
-          console.error(`Error: state '${key}' is locked. Use state.${key}.unlock() to enable modifications.`);
-          return false;
-        }
-        try {
-          const path = objPath(key, tree);
-          const rawValue = deepRaw(value);
-          const _schemaResult = schema.validate(path, rawValue);
-          if (!_schemaResult.valid) {
-            if (DEV && internal_default.debug) {
-              console.error(
-                `[memorio schema] Validation failed for '${path}':`,
-                _schemaResult.errors
-              );
-            }
-            message_default(
-              `[memorio schema] Validation failed for '${path}': ` + (_schemaResult.errors?.join(", ") || "unknown error")
-            );
-            return false;
-          }
-          callback(
-            {
-              action: "set",
-              path,
-              target,
-              newValue: rawValue,
-              previousValue: Reflect.get(target, key)
-            }
-          );
-          event("state." + path);
-          Reflect.set(target, key, rawValue);
-          internal_default.bumpStateVersion();
-          if (target[key] && typeof target[key] === "object") {
-            const lockValue = target[key];
-            if (lockValue && typeof lockValue === "object") {
-              try {
-                Object.defineProperty(lockValue, "__locked", {
-                  writable: true,
-                  enumerable: false,
-                  configurable: false,
-                  value: false
-                });
-                Object.defineProperty(lockValue, "lock", {
-                  writable: false,
-                  enumerable: false,
-                  configurable: false,
-                  value: /* @__PURE__ */ __name(() => {
-                    Object.defineProperty(lockValue, "__locked", {
-                      writable: true,
-                      enumerable: false,
-                      configurable: false,
-                      value: true
-                    });
-                    message_default(`State '${key}' is now locked.`);
-                  }, "value")
-                });
-                Object.defineProperty(lockValue, "unlock", {
-                  writable: false,
-                  enumerable: false,
-                  configurable: false,
-                  value: /* @__PURE__ */ __name(() => {
-                    Object.defineProperty(lockValue, "__locked", {
-                      writable: true,
-                      enumerable: false,
-                      configurable: false,
-                      value: false
-                    });
-                    message_default(`State '${key}' is now unlocked.`);
-                  }, "value")
-                });
-              } catch (err) {
-                if (DEV) console.warn("[memorio state] lock/unlock defineProperty failed:", err);
-              }
-            }
-          }
-          return true;
-        } catch (error) {
-          console.error("Error in set trap:", error);
-          return false;
-        }
-      },
-      deleteProperty(target, prop) {
-        try {
-          const path = objPath(prop, tree);
-          const previousValue = Reflect.get(target, prop);
-          callback({ action: "delete", path, target, previousValue });
-          return Reflect.deleteProperty(target, prop);
-        } catch (error) {
-          console.error("Error in deleteProperty trap:", error);
-          return false;
-        }
-      },
-      ownKeys(target) {
-        return Reflect.ownKeys(target);
-      },
-      getOwnPropertyDescriptor(target, prop) {
-        return Reflect.getOwnPropertyDescriptor(target, prop);
-      }
-    }
-  );
-}, "buildProxy");
-var STATE_INSTANCE_KEY = "__memorio_state_instance__";
-var state2;
-if (globalThis[STATE_INSTANCE_KEY]) {
-  state2 = globalThis[STATE_INSTANCE_KEY];
-} else {
-  state2 = buildProxy({}, (mutation) => {
-    if (internal_default.historyEnabled) {
-      internal_default.recordMutation({
-        path: mutation.path,
-        action: mutation.action,
-        newValue: mutation.newValue,
-        previousValue: mutation.previousValue,
-        timestamp: Date.now()
-      });
-    }
-  });
-  state2.lock = () => {
-    internal_default.locked = true;
-    message_default("State is now locked. All modifications are blocked.");
-  };
-  state2.unlock = () => {
-    internal_default.locked = false;
-    message_default("State is now unlocked. Modifications are allowed.");
-  };
-  globalThis[STATE_INSTANCE_KEY] = state2;
-}
-
 // functions/store/index.ts
 init_cjs_shims();
 init_platform();
@@ -1455,25 +1234,547 @@ if (globalThis[STORE_INSTANCE_KEY]) {
   globalThis[STORE_INSTANCE_KEY] = store;
 }
 
-// functions/session/index.ts
+// functions/state/index.ts
+init_env();
+
+// core/mutation/engine.ts
 init_cjs_shims();
-init_platform();
 init_internal();
-init_message();
-var _sessionStorage = getSessionStorage();
-var _fallbackStorageByContext2 = /* @__PURE__ */ new Map();
-function _getFallbackStorage2() {
-  const contextName = internal_default.currentContext || "";
-  const key = contextName || "default";
-  if (!_fallbackStorageByContext2.has(key)) {
-    _fallbackStorageByContext2.set(key, /* @__PURE__ */ new Map());
-  }
-  return _fallbackStorageByContext2.get(key);
-}
-__name(_getFallbackStorage2, "_getFallbackStorage");
-var _hasStorage2 = _sessionStorage !== null;
-function _getPrefix2() {
-  const contextName = internal_default.currentContext || "";
+
+// 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 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();
+
+// 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 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 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 createMutation(path, operation, before, after, options) {
+  const now2 = hlc.tick();
+  const mutation = {
+    id: generateMutationId(),
+    path,
+    operation,
+    after,
+    before,
+    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: after,
+    previousValue: before
+  };
+  if (mutation.transactionId) {
+    registerMutationInTransaction(mutation.id);
+  }
+  return mutation;
+}
+__name(createMutation, "createMutation");
+
+// functions/state/index.ts
+var TARGET = /* @__PURE__ */ Symbol("memorio.target");
+var wrapperCache = /* @__PURE__ */ new WeakMap();
+var arrayRootDedup = /* @__PURE__ */ new Set();
+var deepRaw = /* @__PURE__ */ __name((val, seen = null) => {
+  if (val === null || typeof val !== "object") return val;
+  if (!seen) seen = /* @__PURE__ */ new WeakSet();
+  if (val[TARGET] !== void 0) return deepRaw(val[TARGET], seen);
+  if (seen) {
+    if (seen.has(val)) return val;
+    seen.add(val);
+  }
+  const ctor = val.constructor?.name;
+  if (ctor !== "Object" && ctor !== "Array") return val;
+  const copy = Array.isArray(val) ? [] : {};
+  for (const k of Reflect.ownKeys(val)) {
+    if (!Object.prototype.propertyIsEnumerable.call(val, k)) continue;
+    copy[k] = deepRaw(val[k], seen);
+  }
+  return copy;
+}, "deepRaw");
+var objPath = /* @__PURE__ */ __name((prop, object, separator = ".") => {
+  return object.concat(prop).join(separator);
+}, "objPath");
+var buildProxy = /* @__PURE__ */ __name((obj, callback, tree = []) => {
+  const event = /* @__PURE__ */ __name((name) => {
+    try {
+      dispatch.set(name, { detail: { name } });
+    } catch (err) {
+      if (DEV) console.warn("[memorio state] event dispatch failed:", err);
+    }
+    return;
+  }, "event");
+  return new Proxy(
+    obj,
+    {
+      get(target, prop) {
+        if (prop === "__path") {
+          return tree.length > 0 ? "state." + tree.join(".") : "state";
+        }
+        if (prop === TARGET) {
+          return target;
+        }
+        if (target[TARGET] !== void 0) {
+          return target;
+        }
+        if (prop === "list") {
+          message_default('Some state could be hidden when you use "state.list". Use "state" to see the complete list ');
+          return deepRaw(target, /* @__PURE__ */ new WeakSet());
+        }
+        if (typeof prop === "string") {
+          const path = tree.length > 0 ? "state." + tree.concat(prop).join(".") : "state." + prop;
+          internal_default.lastAccessedPath = path;
+          if (internal_default.tracking) {
+            internal_default.trackedPaths.add(path);
+          }
+        }
+        if (prop === "_lastPath") {
+          return internal_default.lastAccessedPath;
+        }
+        if (prop === "remove") {
+          return (key) => {
+            delete target[key];
+            return true;
+          };
+        }
+        if (prop === "removeAll") {
+          return () => {
+            try {
+              for (const key of Reflect.ownKeys(target)) {
+                if (typeof target[key] !== "function" && !["list", "remove", "removeAll", "lock", "unlock", "persist"].includes(key)) {
+                  delete target[key];
+                }
+              }
+            } catch (error) {
+              console.error(error);
+            }
+            return;
+          };
+        }
+        if (Object.isFrozen(target[prop])) return target[prop];
+        if (prop === "lock" || prop === "unlock") {
+          const value = Reflect.get(target, prop);
+          if (value) return value;
+        }
+        try {
+          const value = Reflect.get(target, prop);
+          if (value && typeof value === "object" && ["Array", "Object"].includes(value.constructor.name)) {
+            let wrapper = wrapperCache.get(value);
+            if (!wrapper) {
+              wrapper = buildProxy(value, callback, tree.concat(prop));
+              wrapperCache.set(value, wrapper);
+            }
+            return wrapper;
+          }
+          return value;
+        } catch (error) {
+          console.error("Error: ", error);
+          return void 0;
+        }
+      },
+      set(target, key, value) {
+        if (internal_default.locked) {
+          console.error("Error: state is locked. Use state.unlock() to enable modifications.");
+          return false;
+        }
+        if (protect.includes(key)) {
+          console.error("key " + key + " is protected");
+          return false;
+        }
+        if (target[key] && typeof target[key] === "object" && Object.isFrozen(target[key])) {
+          console.error(`Error: state '${key}' is locked`);
+          return false;
+        }
+        if (target[key] && typeof target[key] === "object" && target[key].__locked) {
+          console.error(`Error: state '${key}' is locked. Use state.${key}.unlock() to enable modifications.`);
+          return false;
+        }
+        try {
+          const path = objPath(key, tree);
+          const rawValue = deepRaw(value);
+          const _schemaResult = schema.validate(path, rawValue);
+          if (!_schemaResult.valid) {
+            if (DEV && internal_default.debug) {
+              console.error(
+                `[memorio schema] Validation failed for '${path}':`,
+                _schemaResult.errors
+              );
+            }
+            message_default(
+              `[memorio schema] Validation failed for '${path}': ` + (_schemaResult.errors?.join(", ") || "unknown error")
+            );
+            return false;
+          }
+          callback(
+            {
+              action: "set",
+              path,
+              target,
+              newValue: rawValue,
+              previousValue: Reflect.get(target, key)
+            }
+          );
+          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);
+          internal_default.bumpStateVersion();
+          if (target[key] && typeof target[key] === "object") {
+            const lockValue = target[key];
+            if (lockValue && typeof lockValue === "object") {
+              try {
+                Object.defineProperty(lockValue, "__locked", {
+                  writable: true,
+                  enumerable: false,
+                  configurable: false,
+                  value: false
+                });
+                Object.defineProperty(lockValue, "lock", {
+                  writable: false,
+                  enumerable: false,
+                  configurable: false,
+                  value: /* @__PURE__ */ __name(() => {
+                    Object.defineProperty(lockValue, "__locked", {
+                      writable: true,
+                      enumerable: false,
+                      configurable: false,
+                      value: true
+                    });
+                    message_default(`State '${key}' is now locked.`);
+                  }, "value")
+                });
+                Object.defineProperty(lockValue, "unlock", {
+                  writable: false,
+                  enumerable: false,
+                  configurable: false,
+                  value: /* @__PURE__ */ __name(() => {
+                    Object.defineProperty(lockValue, "__locked", {
+                      writable: true,
+                      enumerable: false,
+                      configurable: false,
+                      value: false
+                    });
+                    message_default(`State '${key}' is now unlocked.`);
+                  }, "value")
+                });
+              } catch (err) {
+                if (DEV) console.warn("[memorio state] lock/unlock defineProperty failed:", err);
+              }
+            }
+          }
+          return true;
+        } catch (error) {
+          console.error("Error in set trap:", error);
+          return false;
+        }
+      },
+      deleteProperty(target, prop) {
+        try {
+          const 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);
+          return false;
+        }
+      },
+      ownKeys(target) {
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        return Reflect.getOwnPropertyDescriptor(target, prop);
+      }
+    }
+  );
+}, "buildProxy");
+var STATE_INSTANCE_KEY = "__memorio_state_instance__";
+var state2;
+if (globalThis[STATE_INSTANCE_KEY]) {
+  state2 = globalThis[STATE_INSTANCE_KEY];
+} else {
+  state2 = buildProxy({}, (mutation) => {
+    if (internal_default.historyEnabled && internal_default._recording !== false) {
+      const operation = mutation.action === "delete" ? "delete" : "set";
+      const record = createMutation(
+        mutation.path,
+        operation,
+        mutation.previousValue,
+        mutation.newValue,
+        {
+          context: mutation.context,
+          source: mutation.source
+        }
+      );
+      internal_default.recordMutation(record);
+    }
+  });
+  const _rawTarget = state2[TARGET];
+  try {
+    Object.defineProperty(_rawTarget, "lock", {
+      value: /* @__PURE__ */ __name(() => {
+        internal_default.locked = true;
+        message_default("State is now locked. All modifications are blocked.");
+      }, "value"),
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+    Object.defineProperty(_rawTarget, "unlock", {
+      value: /* @__PURE__ */ __name(() => {
+        internal_default.locked = false;
+        message_default("State is now unlocked. Modifications are allowed.");
+      }, "value"),
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  } catch (e) {
+    if (DEV) console.warn("[memorio state] lock/unlock defineProperty failed:", e);
+  }
+  try {
+    Object.defineProperty(_rawTarget, "persist", {
+      value: /* @__PURE__ */ __name((path) => {
+        if (typeof path !== "string" || !path.length) {
+          if (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 = 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;
+}
+
+// functions/session/index.ts
+init_cjs_shims();
+init_platform();
+init_internal();
+init_message();
+var _sessionStorage = getSessionStorage();
+var _fallbackStorageByContext2 = /* @__PURE__ */ new Map();
+function _getFallbackStorage2() {
+  const contextName = internal_default.currentContext || "";
+  const key = contextName || "default";
+  if (!_fallbackStorageByContext2.has(key)) {
+    _fallbackStorageByContext2.set(key, /* @__PURE__ */ new Map());
+  }
+  return _fallbackStorageByContext2.get(key);
+}
+__name(_getFallbackStorage2, "_getFallbackStorage");
+var _hasStorage2 = _sessionStorage !== null;
+function _getPrefix2() {
+  const contextName = internal_default.currentContext || "";
   return contextName ? `${contextName}-` : `memorio_session_`;
 }
 __name(_getPrefix2, "_getPrefix");
@@ -1713,120 +2014,6 @@ if (globalThis[SESSION_INSTANCE_KEY]) {
 
 // functions/memory/index.ts
 init_idb();
-
-// 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
-};
-
-// functions/memory/index.ts
 init_env();
 
 // functions/memory/journal.ts