memorio 4.9.35 → 5.1.0

package/index.cjs

@@ -8,6 +8,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // node_modules/tsup/assets/cjs_shims.js
 var init_cjs_shims = __esm({
@@ -20,8 +24,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;
+    }
   }
 });
 
@@ -205,6 +212,241 @@ var init_message = __esm({
   }
 });
 
+// functions/encryption/index.ts
+function _hasWebCrypto() {
+  const g3 = globalThis;
+  return typeof g3.crypto !== "undefined" && typeof g3.crypto.subtle !== "undefined" && typeof g3.crypto.subtle.encrypt === "function";
+}
+function _b64encode(buf) {
+  const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
+  if (typeof btoa === "function") {
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+    return btoa(binary);
+  }
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  return "";
+}
+function _b64decode(b64) {
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(b64, "base64"));
+  }
+  if (typeof atob === "function") {
+    const binary = atob(b64);
+    const out = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+    return out;
+  }
+  throw new Error("memorio encryption: no base64 decoder available");
+}
+function _isEncrypted(value) {
+  return typeof value === "object" && value !== null && value.__memorio_encrypted === true && typeof value.alg === "string";
+}
+var AES_GCM, PBKDF2_ITERATIONS; exports.encryption = void 0;
+var init_encryption = __esm({
+  "functions/encryption/index.ts"() {
+    init_cjs_shims();
+    init_env();
+    init_message();
+    __name(_hasWebCrypto, "_hasWebCrypto");
+    __name(_b64encode, "_b64encode");
+    __name(_b64decode, "_b64decode");
+    __name(_isEncrypted, "_isEncrypted");
+    AES_GCM = { name: "AES-GCM", length: 256 };
+    PBKDF2_ITERATIONS = 6e5;
+    exports.encryption = {
+      ///
+      // Capability detection
+      ///
+      isAvailable() {
+        return _hasWebCrypto();
+      },
+      ///
+      // Derive a CryptoKey from a password using PBKDF2.
+      //
+      // @param password The password string.
+      // @param salt     Salt (string or Uint8Array). Defaults to a static value.
+      // @param alg      'AES-GCM' (default) or 'AES-CBC'.
+      // @returns        A Promise<CryptoKey>.
+      ///
+      async deriveKey(password, salt, alg = "AES-GCM", iterations = PBKDF2_ITERATIONS) {
+        if (!_hasWebCrypto()) {
+          throw new Error("memorio encryption: Web Crypto API is not available in this environment");
+        }
+        const enc = new TextEncoder();
+        const saltBytes = typeof salt === "string" ? enc.encode(salt) : salt ?? enc.encode("memorio:salt");
+        const keyMaterial = await globalThis.crypto.subtle.importKey(
+          "raw",
+          enc.encode(password),
+          { name: "PBKDF2" },
+          false,
+          ["deriveKey"]
+        );
+        return globalThis.crypto.subtle.deriveKey(
+          { name: "PBKDF2", salt: saltBytes, iterations, hash: "SHA-256" },
+          keyMaterial,
+          { name: alg, length: 256 },
+          false,
+          ["encrypt", "decrypt"]
+        );
+      },
+      ///
+      // Generate a fresh random CryptoKey (AES-GCM, 256-bit).
+      ///
+      async generateKey(alg = "AES-GCM") {
+        if (!_hasWebCrypto()) {
+          throw new Error("memorio encryption: Web Crypto API is not available in this environment");
+        }
+        return globalThis.crypto.subtle.generateKey(
+          { name: alg, length: 256 },
+          true,
+          ["encrypt", "decrypt"]
+        );
+      },
+      ///
+      // Generate a random salt for PBKDF2 key derivation.
+      ///
+      generateSalt(bytes = 16) {
+        const arr = new Uint8Array(bytes);
+        globalThis.crypto?.getRandomValues?.(arr);
+        return _b64encode(arr);
+      },
+      ///
+      // Export a CryptoKey to portable base64 strings so it can be stored
+      // (e.g. in an httpOnly cookie) and re-imported later with importKey().
+      //
+      // @param cryptoKey A raw CryptoKey (not a password string).
+      // @returns         { key: string, iv: string } base64-encoded.
+      ///
+      async exportKey(cryptoKey) {
+        if (!_hasWebCrypto()) {
+          throw new Error("memorio encryption: Web Crypto API is not available in this environment");
+        }
+        const exported = await globalThis.crypto.subtle.exportKey("raw", cryptoKey);
+        return {
+          key: _b64encode(exported),
+          iv: ""
+        };
+      },
+      ///
+      // Import a CryptoKey from base64 strings produced by exportKey().
+      //
+      // @param keyData Base64-encoded raw key bytes.
+      // @param _ivData Ignored (kept for API compatibility with exportKey return).
+      // @returns       A Promise<CryptoKey>.
+      ///
+      async importKey(keyData, _ivData) {
+        if (!_hasWebCrypto()) {
+          throw new Error("memorio encryption: Web Crypto API is not available in this environment");
+        }
+        const keyBytes = _b64decode(keyData);
+        if (keyBytes.length !== 32) {
+          throw new Error(`memorio encryption: AES-256 key must be exactly 32 bytes, got ${keyBytes.length}`);
+        }
+        return globalThis.crypto.subtle.importKey(
+          "raw",
+          keyBytes,
+          AES_GCM,
+          true,
+          ["encrypt", "decrypt"]
+        );
+      },
+      ///
+      // Encrypt a JavaScript value.
+      //
+      // @param value The value to encrypt (any JSON-serializable object).
+      // @param key   A CryptoKey or a password string (password is derived via PBKDF2).
+      // @param keyId Optional label, stored in the envelope for key rotation.
+      // @returns     An EncryptedEnvelope object.
+      ///
+      async encrypt(value, key, keyId) {
+        const cryptoKey = typeof key === "string" ? await this.deriveKey(key, void 0, "AES-GCM") : key;
+        const data = new TextEncoder().encode(JSON.stringify(value));
+        const iv = new Uint8Array(12);
+        globalThis.crypto.getRandomValues(iv);
+        const ciphertext = await globalThis.crypto.subtle.encrypt(
+          { name: "AES-GCM", iv },
+          cryptoKey,
+          data
+        );
+        const envelope = {
+          __memorio_encrypted: true,
+          v: 1,
+          alg: "AES-GCM",
+          iv: _b64encode(iv),
+          data: _b64encode(ciphertext)
+        };
+        if (keyId) envelope.keyId = keyId;
+        if (exports.DEV) message_default(`encryption: encrypted value (alg=${envelope.alg})`);
+        return envelope;
+      },
+      ///
+      // Decrypt an EncryptedEnvelope.
+      //
+      // @param envelope The envelope object returned by encrypt().
+      // @param key      A CryptoKey or a password string.
+      // @returns        The original value (parsed from JSON).
+      ///
+      async decrypt(envelope, key) {
+        if (!_isEncrypted(envelope)) {
+          throw new Error("memorio encryption: value is not a valid encrypted envelope");
+        }
+        const cryptoKey = typeof key === "string" ? await this.deriveKey(key, void 0, "AES-GCM") : key;
+        const iv = _b64decode(envelope.iv);
+        const data = _b64decode(envelope.data);
+        const decrypted = await globalThis.crypto.subtle.decrypt(
+          { name: "AES-GCM", iv },
+          cryptoKey,
+          data
+        );
+        return JSON.parse(new TextDecoder().decode(new Uint8Array(decrypted)));
+      },
+      ///
+      // Convenience: encrypt with a password (derives the key internally).
+      // Returns a JSON string you can store anywhere.
+      ///
+      async encryptWithPassword(value, password, salt, keyId) {
+        const env = await this.encrypt(value, password, keyId);
+        return JSON.stringify(env);
+      },
+      ///
+      // Convenience: decrypt a JSON envelope string with a password.
+      ///
+      async decryptWithPassword(envelopeJson, password, _salt) {
+        const envelope = JSON.parse(envelopeJson);
+        return this.decrypt(envelope, password);
+      },
+      ///
+      // Type guard: check whether a value is an encrypted envelope.
+      ///
+      isEncrypted(value) {
+        return _isEncrypted(value);
+      },
+      ///
+      // Configure a default encryption key for auto-encrypt mode.
+      // When set on `store` or `session`, all writes are encrypted and all
+      // reads attempt decryption automatically.
+      ///
+      config(opts) {
+        if (opts.key !== void 0) this._defaultKey = opts.key;
+        if (opts.keyId !== void 0) this._defaultKeyId = opts.keyId;
+        return this;
+      },
+      ///
+      // Internal: resolve the configured default key.
+      ///
+      get _key() {
+        return this._defaultKey ?? null;
+      },
+      get _keyId() {
+        return this._defaultKeyId;
+      }
+    };
+  }
+});
+
 // core/platform.ts
 function generateSessionId() {
   const anyGlobal = globalThis;
@@ -219,6 +461,9 @@ function generateSessionId() {
   return `session_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
 }
 function detectPlatform() {
+  if (_isBun()) {
+    return "bun";
+  }
   const globalAny = globalThis;
   if (globalAny.Deno && globalAny.Deno.version) {
     return "deno";
@@ -234,6 +479,13 @@ function detectPlatform() {
   }
   return "unknown";
 }
+function _isBun() {
+  const globalAny = globalThis;
+  return typeof globalAny.Bun !== "undefined" && typeof globalAny.Bun.version === "string";
+}
+function isBun() {
+  return _isBun();
+}
 function isBrowser() {
   const platform = detectPlatform();
   return platform === "browser";
@@ -287,6 +539,9 @@ function hasSqlJs() {
   }
   return typeof anyGlobal.window !== "undefined";
 }
+function hasBunSqlite() {
+  return _isBun();
+}
 function hasDispatchEvent() {
   return typeof globalThis.dispatchEvent === "function";
 }
@@ -299,6 +554,7 @@ function getCapabilities() {
     hasLocalStorage: getLocalStorage() !== null,
     hasIndexedDB: hasIndexedDB(),
     hasSqlJs: hasSqlJs(),
+    hasBunSqlite: hasBunSqlite(),
     hasDispatchEvent: hasDispatchEvent(),
     hasNavigator: typeof navigator !== "undefined",
     hasProcess: typeof process !== "undefined",
@@ -358,8 +614,9 @@ function initializePlatform() {
     };
   }
 }
-function createContext(name) {
+function createContext(name, opts) {
   const contextId = name || `context_${generateSessionId()}`;
+  const encKey = opts?.encryptionKey;
   setCurrentContext(contextId);
   const contextStorage = {
     state: {},
@@ -368,10 +625,31 @@ function createContext(name) {
     cache: /* @__PURE__ */ new Map()
   };
   _contexts.set(contextId, contextStorage);
+  function _isEncrypted2(value) {
+    return exports.encryption.isEncrypted(value);
+  }
+  __name(_isEncrypted2, "_isEncrypted");
   return {
     id: contextId,
     state: contextStorage.state,
-    store: {
+    store: encKey ? {
+      get: /* @__PURE__ */ __name(async (key) => {
+        const data = contextStorage.store.get(key);
+        if (!data) return null;
+        const parsed = JSON.parse(data);
+        if (_isEncrypted2(parsed)) return exports.encryption.decrypt(parsed, encKey);
+        return parsed;
+      }, "get"),
+      set: /* @__PURE__ */ __name(async (key, value) => {
+        const env = await exports.encryption.encrypt(value, encKey);
+        contextStorage.store.set(key, JSON.stringify(env));
+      }, "set"),
+      remove: /* @__PURE__ */ __name((key) => contextStorage.store.delete(key), "remove"),
+      removeAll: /* @__PURE__ */ __name(() => contextStorage.store.clear(), "removeAll"),
+      clearAll: /* @__PURE__ */ __name(() => contextStorage.store.clear(), "clearAll"),
+      size: /* @__PURE__ */ __name(() => contextStorage.store.size, "size"),
+      isPersistent: false
+    } : {
       get: /* @__PURE__ */ __name((key) => {
         const data = contextStorage.store.get(key);
         return data ? JSON.parse(data) : null;
@@ -385,7 +663,24 @@ function createContext(name) {
       size: /* @__PURE__ */ __name(() => contextStorage.store.size, "size"),
       isPersistent: false
     },
-    session: {
+    session: encKey ? {
+      get: /* @__PURE__ */ __name(async (key) => {
+        const data = contextStorage.session.get(key);
+        if (!data) return null;
+        const parsed = JSON.parse(data);
+        if (_isEncrypted2(parsed)) return exports.encryption.decrypt(parsed, encKey);
+        return parsed;
+      }, "get"),
+      set: /* @__PURE__ */ __name(async (key, value) => {
+        const env = await exports.encryption.encrypt(value, encKey);
+        contextStorage.session.set(key, JSON.stringify(env));
+      }, "set"),
+      remove: /* @__PURE__ */ __name((key) => contextStorage.session.delete(key), "remove"),
+      removeAll: /* @__PURE__ */ __name(() => contextStorage.session.clear(), "removeAll"),
+      clearAll: /* @__PURE__ */ __name(() => contextStorage.session.clear(), "clearAll"),
+      size: /* @__PURE__ */ __name(() => contextStorage.session.size, "size"),
+      isPersistent: false
+    } : {
       get: /* @__PURE__ */ __name((key) => {
         const data = contextStorage.session.get(key);
         return data ? JSON.parse(data) : null;
@@ -405,7 +700,8 @@ function createContext(name) {
       remove: /* @__PURE__ */ __name((key) => contextStorage.cache.delete(key), "remove"),
       removeAll: /* @__PURE__ */ __name(() => contextStorage.cache.clear(), "removeAll"),
       clear: /* @__PURE__ */ __name(() => contextStorage.cache.clear(), "clear")
-    }
+    },
+    encryptionKey: encKey
   };
 }
 function listContexts() {
@@ -422,8 +718,11 @@ var init_platform = __esm({
   "core/platform.ts"() {
     init_cjs_shims();
     init_internal();
+    init_encryption();
     __name(generateSessionId, "generateSessionId");
     __name(detectPlatform, "detectPlatform");
+    __name(_isBun, "_isBun");
+    __name(isBun, "isBun");
     __name(isBrowser, "isBrowser");
     __name(isNode, "isNode");
     __name(isDeno, "isDeno");
@@ -432,6 +731,7 @@ var init_platform = __esm({
     __name(getLocalStorage, "getLocalStorage");
     __name(hasIndexedDB, "hasIndexedDB");
     __name(hasSqlJs, "hasSqlJs");
+    __name(hasBunSqlite, "hasBunSqlite");
     __name(hasDispatchEvent, "hasDispatchEvent");
     __name(getCapabilities, "getCapabilities");
     _eventListenerStorage = /* @__PURE__ */ new Map();
@@ -457,6 +757,9 @@ function _getFallbackStorage() {
   }
   return _fallbackStorageByContext.get(key);
 }
+function _isEncryptedEnvelope(value) {
+  return exports.encryption.isEncrypted(value);
+}
 function _getPrefix() {
   const contextName = exports.internal.currentContext || "";
   return contextName ? `${contextName}-` : `memorio_store_`;
@@ -493,17 +796,23 @@ function _remove(prefixedName) {
   }
   return false;
 }
-var _localStorage, _fallbackStorageByContext, _hasStorage, STORE_INSTANCE_KEY; exports.store = void 0;
+var _localStorage, _fallbackStorageByContext, _hasStorage, _encryptionKey, _onError, _maxObjectSize, _maxTotalSize, STORE_INSTANCE_KEY; exports.store = void 0;
 var init_store = __esm({
   "functions/store/index.ts"() {
     init_cjs_shims();
     init_platform();
     init_internal();
     init_message();
+    init_encryption();
     _localStorage = getLocalStorage();
     _fallbackStorageByContext = /* @__PURE__ */ new Map();
     __name(_getFallbackStorage, "_getFallbackStorage");
     _hasStorage = _localStorage !== null;
+    _encryptionKey = null;
+    _onError = null;
+    _maxObjectSize = 0;
+    _maxTotalSize = 0;
+    __name(_isEncryptedEnvelope, "_isEncryptedEnvelope");
     __name(_getPrefix, "_getPrefix");
     __name(_prefixKey, "_prefixKey");
     __name(_read, "_read");
@@ -520,16 +829,24 @@ var init_store = __esm({
           /**
            * Gets a value from storage.
            * @param name The key to retrieve.
-           * @returns The parsed value or null if not found.
+           * @param opts Optional { decrypt: key } to decrypt an encrypted envelope.
+           *              When no key is passed, encrypted envelopes are returned as-is.
+           *              If a default key was configured via store.config(), it is used automatically.
+           * @returns The parsed value, a Promise<parsed value> when decrypting, or null if not found.
            */
           get: {
-            value: /* @__PURE__ */ __name((name) => {
+            value: /* @__PURE__ */ __name((name, opts) => {
               if (!name) {
                 console.warn("[memorio store] store.get() called with empty or null key - returning null");
                 return null;
               }
               try {
-                return _read(_prefixKey(name));
+                const raw = _read(_prefixKey(name));
+                const key = opts?.decrypt ?? _encryptionKey;
+                if (key && _isEncryptedEnvelope(raw)) {
+                  return exports.encryption.decrypt(raw, key);
+                }
+                return raw;
               } catch (err) {
                 exports.message(`Error parsing store item '${name}': ${err}`);
               }
@@ -554,10 +871,13 @@ var init_store = __esm({
            * Sets a value in storage.
            * @param name The key to set.
            * @param value The value to store (objects, arrays, primitives).
-           * @returns true if written, false if the key was rejected.
+           * @param opts Optional { encrypt: key } to encrypt the value before storage.
+           *              If a default key was configured via store.config(), it is used automatically.
+           *              When encryption is used, returns a Promise<boolean>.
+           * @returns true if written, false if rejected or error.
            */
           set: {
-            value: /* @__PURE__ */ __name((name, value) => {
+            value: /* @__PURE__ */ __name((name, value, opts) => {
               if (!name) {
                 console.warn("[memorio store] store.set() called with empty or null key - write aborted");
                 return false;
@@ -569,15 +889,66 @@ var init_store = __esm({
                 exports.message("Storing functions is not secure and is blocked for safety.");
                 return false;
               }
+              if (_maxObjectSize > 0 || _maxTotalSize > 0) {
+                let serializedSize = 0;
+                try {
+                  serializedSize = new TextEncoder().encode(JSON.stringify(value)).length;
+                } catch {
+                  serializedSize = 0;
+                }
+                if (_maxObjectSize > 0 && serializedSize > _maxObjectSize) {
+                  const err = new Error(`Object size (${serializedSize} bytes) exceeds maxObjectSize (${_maxObjectSize} bytes)`);
+                  _onError?.(err, { operation: "set" });
+                  return false;
+                }
+                if (_maxTotalSize > 0) {
+                  const currentTotal = exports.store.size() * 1024;
+                  const existingItemSize = _hasStorage ? _localStorage.getItem(prefixedName)?.length ?? 0 : _getFallbackStorage().get(prefixedName)?.length ?? 0;
+                  const projected = currentTotal * 1024 - existingItemSize + serializedSize;
+                  if (projected > _maxTotalSize) {
+                    const err = new Error(`Total store size (${projected} bytes) exceeds maxTotalSize (${_maxTotalSize} bytes)`);
+                    _onError?.(err, { operation: "set" });
+                    return false;
+                  }
+                }
+              }
+              const key = opts?.encrypt ?? _encryptionKey;
+              if (key) {
+                return exports.encryption.encrypt(value, key).then((env) => {
+                  _write(prefixedName, env);
+                  return true;
+                }).catch((err) => {
+                  exports.message(`Error encrypting store item '${name}': ${err}`);
+                  _onError?.(err, { operation: "set" });
+                  return false;
+                });
+              }
               try {
                 _write(prefixedName, value);
               } catch (err) {
                 exports.message(`Error setting store item '${name}': ${err}`);
+                _onError?.(err, { operation: "set" });
                 return false;
               }
               return true;
             }, "value")
           },
+          /**
+           * Configure store-wide behavior.
+           * @param opts Optional { encryptionKey } to enable automatic encryption
+           *              for all set/get operations. When set, values are encrypted
+           *              on write and decrypted on read (if the value is an envelope).
+           * @returns The store instance for chaining.
+           */
+          config: {
+            value: /* @__PURE__ */ __name((opts) => {
+              if (opts.encryptionKey !== void 0) _encryptionKey = opts.encryptionKey;
+              if (opts.onError !== void 0) _onError = opts.onError;
+              if (opts.maxObjectSize !== void 0) _maxObjectSize = opts.maxObjectSize;
+              if (opts.maxTotalSize !== void 0) _maxTotalSize = opts.maxTotalSize;
+              return exports.store;
+            }, "value")
+          },
           /**
            * Removes a value from storage.
            * @param name The key to remove.
@@ -948,8 +1319,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 +1364,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 +1389,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 +1424,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 +1461,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();
@@ -1163,6 +1534,91 @@ var init_idb = __esm({
   }
 });
 
+// functions/sqlite/tools/bun-sqlite-adapter.ts
+var bun_sqlite_adapter_exports = {};
+__export(bun_sqlite_adapter_exports, {
+  BunSqlJsDatabase: () => BunSqlJsDatabase,
+  createBunSqlJs: () => createBunSqlJs
+});
+async function _loadDatabase() {
+  if (!_DatabaseClass) {
+    const mod = await import('bun:sqlite');
+    _DatabaseClass = mod.Database;
+  }
+  return _DatabaseClass;
+}
+async function createBunSqlJs() {
+  await _loadDatabase();
+  return {
+    Database: BunSqlJsDatabase,
+    version: "bun:sqlite"
+  };
+}
+var _DatabaseClass, BunSqlJsDatabase;
+var init_bun_sqlite_adapter = __esm({
+  "functions/sqlite/tools/bun-sqlite-adapter.ts"() {
+    init_cjs_shims();
+    _DatabaseClass = null;
+    __name(_loadDatabase, "_loadDatabase");
+    BunSqlJsDatabase = class {
+      static {
+        __name(this, "BunSqlJsDatabase");
+      }
+      _db;
+      _lastRunChanges = 0;
+      constructor(data) {
+        this._lastRunChanges = 0;
+        if (typeof data === "string") {
+          this._db = new _DatabaseClass(data);
+        } else {
+          this._db = new _DatabaseClass(":memory:");
+        }
+      }
+      run(sql, params = []) {
+        const info = this._db.run(sql, ...params);
+        this._lastRunChanges = info?.changes ?? 0;
+        return info;
+      }
+      getRowsModified() {
+        return this._lastRunChanges;
+      }
+      prepare(sql, params = []) {
+        const rows = params.length > 0 ? this._db.query(sql).all(...params) : this._db.query(sql).all();
+        return {
+          _rows: rows,
+          _idx: -1,
+          step() {
+            this._idx++;
+            return this._idx < this._rows.length;
+          },
+          getAsObject() {
+            return this._rows[this._idx] || {};
+          },
+          get() {
+            return this._rows[this._idx] ? Object.values(this._rows[this._idx]) : [];
+          },
+          free() {
+            this._rows = null;
+          }
+        };
+      }
+      export() {
+        throw new Error("Bun:sqlite does not support in-memory export - use store/session for persistence, or use the sql.js backend for export/import operations");
+      }
+      close() {
+        try {
+          this._db.close();
+        } catch {
+        }
+      }
+      get version() {
+        return "bun:sqlite";
+      }
+    };
+    __name(createBunSqlJs, "createBunSqlJs");
+  }
+});
+
 // functions/sqlite/tools/db.support.ts
 var db_support_exports2 = {};
 function _inDocument() {
@@ -1223,11 +1679,18 @@ var init_db_support2 = __esm({
       return g3.initSqlJs || g3;
     }, "_loadSqlJsFromCdn");
     exports.sqlite.db.support = () => {
-      return hasSqlJs();
+      return hasSqlJs() || hasBunSqlite();
     };
     exports.sqlite.db.getSQL = async () => {
       if (_SQL) return _SQL;
       if (_loading) return _loading;
+      if (hasBunSqlite()) {
+        const { createBunSqlJs: createBunSqlJs2 } = await Promise.resolve().then(() => (init_bun_sqlite_adapter(), bun_sqlite_adapter_exports));
+        _SQL = await createBunSqlJs2();
+        globalThis.sqliteVersion = _SQL.version;
+        message_default("Memorio SQLite: bun:sqlite engine loaded");
+        return _SQL;
+      }
       const g3 = globalThis;
       const cfg = g3.sqliteConfig || {};
       const p = (async () => {
@@ -1254,7 +1717,7 @@ var init_db_support2 = __esm({
         } catch (_) {
         }
         try {
-          exports.sqlite._warning = "Memorio SQLite: sql.js could not be loaded. Install sql.js (npm i sql.js) and pass a loader via sqlite.config({ loader: () => <your sql.js import>() }).";
+          exports.sqlite._warning = "Memorio SQLite: sql.js could not be loaded. Install sql.js (npm i sql.js) and pass a loader via sqlite.config({ loader: () => import(<your sql.js import>()) }).";
         } catch (_) {
         }
         console.warn("Memorio SQLite: failed to load sql.js", err);
@@ -1277,7 +1740,7 @@ function _ns() {
 function _key(name) {
   return `memorio:sqlite:db:${_ns()}:${name}`;
 }
-function _b64encode(buf) {
+function _b64encode2(buf) {
   const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
   let binary = "";
   const len = bytes.byteLength;
@@ -1285,7 +1748,7 @@ function _b64encode(buf) {
   if (typeof btoa === "function") return btoa(binary);
   return typeof Buffer !== "undefined" ? Buffer.from(bytes).toString("base64") : "";
 }
-function _b64decode(b64) {
+function _b64decode2(b64) {
   if (typeof Buffer !== "undefined") {
     return new Uint8Array(Buffer.from(b64, "base64"));
   }
@@ -1307,7 +1770,7 @@ function saveSnapshot(name) {
     }
     try {
       const blob = db.export();
-      exports.store.set(_key(name), _b64encode(blob));
+      exports.store.set(_key(name), _b64encode2(blob));
       message_default(`Memorio SQLite: persisted '${name}' to store`);
       resolve(true);
     } catch (err) {
@@ -1320,7 +1783,7 @@ function loadSnapshot(name) {
   const b64 = exports.store.get(_key(name));
   if (!b64) return null;
   try {
-    return _b64decode(b64);
+    return _b64decode2(b64);
   } catch {
     return null;
   }
@@ -1355,8 +1818,8 @@ var init_persist = __esm({
     _exportTimers = {};
     __name(_ns, "_ns");
     __name(_key, "_key");
-    __name(_b64encode, "_b64encode");
-    __name(_b64decode, "_b64decode");
+    __name(_b64encode2, "_b64encode");
+    __name(_b64decode2, "_b64decode");
     __name(saveSnapshot, "saveSnapshot");
     __name(loadSnapshot, "loadSnapshot");
     __name(removeSnapshot, "removeSnapshot");
@@ -1561,7 +2024,14 @@ var init_db_export = __esm({
     init_sqlite();
     exports.sqlite.db.export = async (name = "memorio") => {
       const db = exports.sqlite.db.get(name);
-      return db.export();
+      try {
+        return db.export();
+      } catch (err) {
+        if (db && db.version === "bun:sqlite") {
+          throw new Error(`memorio sqlite: export is not supported under Bun's native sqlite. Use \`store\` or \`session\` for persistence instead. If you need a binary dump, run this code under the browser/sql.js backend.`);
+        }
+        throw err;
+      }
     };
   }
 });
@@ -1645,13 +2115,14 @@ var init_data_get2 = __esm({
 });
 
 // functions/sqlite/index.ts
-var _hasSqlJs; exports.sqlite = void 0;
+var _hasSqlJs, _hasBunSqlite; exports.sqlite = void 0;
 var init_sqlite = __esm({
   "functions/sqlite/index.ts"() {
     init_cjs_shims();
     init_platform();
     init_env();
     _hasSqlJs = hasSqlJs();
+    _hasBunSqlite = hasBunSqlite();
     exports.sqlite = {
       db: {},
       query: {},
@@ -1678,7 +2149,7 @@ var init_sqlite = __esm({
         return g3.sqliteReady;
       }, "get")
     });
-    if (_hasSqlJs) {
+    if (_hasSqlJs || _hasBunSqlite) {
       (async () => {
         Object.defineProperty(exports.sqlite, "db", { value: {}, writable: false, configurable: true, enumerable: true });
         Object.defineProperty(exports.sqlite, "query", { value: {}, writable: false, configurable: true, enumerable: true });
@@ -1706,11 +2177,11 @@ var init_sqlite = __esm({
       })();
     } else {
       exports.sqlite._disabled = true;
-      exports.sqlite._warning = 'SQLite (sql.js) is not available in this environment. It requires a browser with WebAssembly support. Install the optional "sql.js" package to enable it.';
+      exports.sqlite._warning = 'SQLite is not available in this environment. It requires a browser with WebAssembly (sql.js) or the Bun runtime (bun:sqlite). Install the optional "sql.js" package to enable it in browsers.';
       if (exports.DEV) {
         globalThis.sqliteDisabled = true;
         globalThis.sqliteWarning = exports.sqlite._warning;
-        console.warn("Memorio SQLite: sql.js is not available in this environment (requires browser + WebAssembly). Use store or session for persistence.");
+        console.warn("Memorio SQLite: no engine available in this environment (requires browser + WebAssembly, or Bun runtime with bun:sqlite). Use store or session for persistence.");
       }
     }
   }
@@ -1753,9 +2224,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,101 +2378,589 @@ var schema = {
 // functions/state/index.ts
 init_store();
 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);
+
+// 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 {
   }
-  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);
+  if (!globalThis.__memorioHlcNodeId) {
+    globalThis.__memorioHlcNodeId = generateNodeId();
   }
-  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 (exports.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;
-          exports.internal.lastAccessedPath = path;
-          if (exports.internal.tracking) {
-            exports.internal.trackedPaths.add(path);
-          }
-        }
-        if (prop === "_lastPath") {
-          return exports.internal.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 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;
+    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 (exports.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;
+          exports.internal.lastAccessedPath = path;
+          if (exports.internal.tracking) {
+            exports.internal.trackedPaths.add(path);
+          }
+        }
+        if (prop === "_lastPath") {
+          return exports.internal.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;
         }
       },
@@ -2032,6 +3007,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 +3073,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 +3105,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()
-      });
+    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);
     }
   });
-  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];
+  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 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 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;
 }
 
@@ -2171,6 +3193,7 @@ init_cjs_shims();
 init_platform();
 init_internal();
 init_message();
+init_encryption();
 var _sessionStorage = getSessionStorage();
 var _fallbackStorageByContext2 = /* @__PURE__ */ new Map();
 function _getFallbackStorage2() {
@@ -2183,6 +3206,14 @@ function _getFallbackStorage2() {
 }
 __name(_getFallbackStorage2, "_getFallbackStorage");
 var _hasStorage2 = _sessionStorage !== null;
+var _encryptionKey2 = null;
+var _onError2 = null;
+var _maxObjectSize2 = 0;
+var _maxTotalSize2 = 0;
+function _isEncryptedEnvelope2(value) {
+  return exports.encryption.isEncrypted(value);
+}
+__name(_isEncryptedEnvelope2, "_isEncryptedEnvelope");
 function _getPrefix2() {
   const contextName = exports.internal.currentContext || "";
   return contextName ? `${contextName}-` : `memorio_session_`;
@@ -2236,16 +3267,22 @@ if (globalThis[SESSION_INSTANCE_KEY]) {
       /**
        * Gets a value from storage.
        * @param name The key to retrieve.
-       * @returns The parsed value or null if not found.
+       * @param opts Optional { decrypt: key } to decrypt an encrypted envelope.
+       * @returns The parsed value, a Promise when decrypting, or null if not found.
        */
       get: {
-        value: /* @__PURE__ */ __name((name) => {
+        value: /* @__PURE__ */ __name((name, opts) => {
           if (!name) {
             console.warn("[memorio session] session.get() called with empty or null key - returning null");
             return null;
           }
           try {
-            return _read2(_prefixKey2(name));
+            const raw = _read2(_prefixKey2(name));
+            const key = opts?.decrypt ?? _encryptionKey2;
+            if (key && _isEncryptedEnvelope2(raw)) {
+              return exports.encryption.decrypt(raw, key);
+            }
+            return raw;
           } catch (err) {
             exports.message(`Error parsing session item '${name}':${err}`);
           }
@@ -2256,10 +3293,11 @@ if (globalThis[SESSION_INSTANCE_KEY]) {
        * Sets a value in storage.
        * @param name The key to set.
        * @param value The value to store.
-       * @returns true if written, false if the key was rejected.
+       * @param opts Optional { encrypt: key } to encrypt before storage.
+       * @returns true if written, false if rejected. Returns a Promise when encrypting.
        */
       set: {
-        value: /* @__PURE__ */ __name((name, value) => {
+        value: /* @__PURE__ */ __name((name, value, opts) => {
           if (!name) {
             console.warn("[memorio session] session.set() called with empty or null key - write aborted");
             return false;
@@ -2271,15 +3309,63 @@ if (globalThis[SESSION_INSTANCE_KEY]) {
             exports.message("It's not secure to session functions.");
             return false;
           }
+          if (_maxObjectSize2 > 0 || _maxTotalSize2 > 0) {
+            let serializedSize = 0;
+            try {
+              serializedSize = new TextEncoder().encode(JSON.stringify(value)).length;
+            } catch {
+              serializedSize = 0;
+            }
+            if (_maxObjectSize2 > 0 && serializedSize > _maxObjectSize2) {
+              const err = new Error(`Object size (${serializedSize} bytes) exceeds maxObjectSize (${_maxObjectSize2} bytes)`);
+              _onError2?.(err, { operation: "set" });
+              return false;
+            }
+            if (_maxTotalSize2 > 0) {
+              const currentTotal = exports.session.size() * 1024;
+              const existingItemSize = _sessionStorage ? _sessionStorage.getItem(prefixedName)?.length ?? 0 : _getFallbackStorage2().get(prefixedName)?.length ?? 0;
+              const projected = currentTotal - existingItemSize + serializedSize;
+              if (projected > _maxTotalSize2) {
+                const err = new Error(`Total session size (${projected} bytes) exceeds maxTotalSize (${_maxTotalSize2} bytes)`);
+                _onError2?.(err, { operation: "set" });
+                return false;
+              }
+            }
+          }
+          const key = opts?.encrypt ?? _encryptionKey2;
+          if (key) {
+            return exports.encryption.encrypt(value, key).then((env) => {
+              _write2(prefixedName, env);
+              return true;
+            }).catch((err) => {
+              exports.message(`Error encrypting session item '${name}': ${err}`);
+              _onError2?.(err, { operation: "set" });
+              return false;
+            });
+          }
           try {
             _write2(prefixedName, value);
           } catch (err) {
             exports.message(`Error setting session item '${name}': ${err}`);
+            _onError2?.(err, { operation: "set" });
             return false;
           }
           return true;
         }, "value")
       },
+      /**
+       * Configure session-wide behavior.
+       * @param opts { encryptionKey, onError, maxObjectSize, maxTotalSize }
+       */
+      config: {
+        value: /* @__PURE__ */ __name((opts) => {
+          if (opts.encryptionKey !== void 0) _encryptionKey2 = opts.encryptionKey;
+          if (opts.onError !== void 0) _onError2 = opts.onError;
+          if (opts.maxObjectSize !== void 0) _maxObjectSize2 = opts.maxObjectSize;
+          if (opts.maxTotalSize !== void 0) _maxTotalSize2 = opts.maxTotalSize;
+          return exports.session;
+        }, "value")
+      },
       /**
        * Removes a value from storage.
        * @param name The key to remove.
@@ -2511,12 +3597,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 +3670,6 @@ Object.defineProperties(
 init_cjs_shims();
 init_message();
 init_internal();
-init_env();
 var useObserver = /* @__PURE__ */ __name(((func, deps = []) => {
   if (!deps || typeof func !== "function") {
     return () => {
@@ -2623,37 +3713,616 @@ var useObserver = /* @__PURE__ */ __name(((func, deps = []) => {
         });
       }
     });
-    if (handlers.length > 0) {
-      message_default(`useObserver: Monitoring ${handlers.length} paths.`);
-    } else {
-      console.warn(`useObserver: No paths resolved for monitoring. Check your dependencies!`);
+    if (handlers.length > 0) {
+      message_default(`useObserver: Monitoring ${handlers.length} paths.`);
+    } else {
+      console.warn(`useObserver: No paths resolved for monitoring. Check your dependencies!`);
+    }
+    return () => {
+      unsubs.forEach(({ path, off }) => {
+        off();
+        message_default(`useObserver: Stopped monitoring "${path}"`);
+      });
+    };
+  } catch (err) {
+    message_default(`useObserver Error: ${err}`);
+    return () => {
+    };
+  }
+}), "useObserver");
+
+// index.ts
+init_encryption();
+
+// functions/computed/index.ts
+init_cjs_shims();
+init_env();
+init_message();
+var DEFAULT_EQUALITY = /* @__PURE__ */ __name((prev, next) => {
+  if (prev === next) return true;
+  if (prev == null || next == null) return false;
+  if (typeof prev !== typeof next) return false;
+  if (typeof prev !== "object") return false;
+  try {
+    return JSON.stringify(prev) === JSON.stringify(next);
+  } catch {
+    return false;
+  }
+}, "DEFAULT_EQUALITY");
+var computedMap = /* @__PURE__ */ new Map();
+function _normalizeKey(key) {
+  if (!key || typeof key !== "string") return "";
+  const normalized = key.startsWith("state.") ? key : `state.${key}`;
+  return normalized;
+}
+__name(_normalizeKey, "_normalizeKey");
+function _invalidate(key) {
+  const entry = computedMap.get(key);
+  if (!entry) return;
+  const newValue = _recompute(entry);
+  if (entry.equality(entry.lastValue, newValue)) {
+    return;
+  }
+  entry.lastValue = newValue;
+  for (const sub of entry.subscribers) {
+    try {
+      sub(newValue);
+    } catch (err) {
+      if (exports.DEV) console.error("[memorio computed] subscriber error:", err);
+    }
+  }
+  dispatch.set("memorio:computed:" + key, { detail: { key, value: newValue } });
+}
+__name(_invalidate, "_invalidate");
+function _readStatePath(path) {
+  const entry = computedMap.get(path);
+  if (entry) {
+    return entry.lastValue;
+  }
+  const normalized = path.startsWith("state.") ? path : `state.${path}`;
+  const segments = normalized.replace(/^state\./, "").split(".");
+  let current = globalThis.state;
+  if (current) {
+    for (const seg of segments) {
+      if (current === null || current === void 0) break;
+      try {
+        current = current[seg];
+      } catch {
+        return void 0;
+      }
+    }
+  }
+  return current === void 0 ? null : current;
+}
+__name(_readStatePath, "_readStatePath");
+function _recompute(entry) {
+  const newDeps = /* @__PURE__ */ new Set();
+  const trackerGet = /* @__PURE__ */ __name((path) => {
+    if (!path || typeof path !== "string") return void 0;
+    newDeps.add(path);
+    return _readStatePath(path);
+  }, "trackerGet");
+  try {
+    return entry.selector(trackerGet);
+  } catch (err) {
+    if (exports.DEV) console.error("[memorio computed] selector error:", err);
+    message_default(`[memorio computed] selector error: ${err}`);
+    return entry.lastValue;
+  }
+}
+__name(_recompute, "_recompute");
+function _setupDeps(key, entry, deps) {
+  for (const off of entry._dispatchUnsubscribers) off();
+  entry._dispatchUnsubscribers = [];
+  for (const dep of deps) {
+    if (computedMap.has(dep)) {
+      const computedEvent = "memorio:computed:" + dep;
+      const off = dispatch.listen(computedEvent, () => _invalidate(key));
+      if (off) entry._dispatchUnsubscribers.push(off);
+    } else {
+      const off = dispatch.listen(dep, () => _invalidate(key));
+      if (off) entry._dispatchUnsubscribers.push(off);
+    }
+  }
+  entry.deps = deps;
+}
+__name(_setupDeps, "_setupDeps");
+function _compute(key, selector, opts) {
+  const normalizedKey = _normalizeKey(key);
+  const cacheKey = opts?.equalityKey ? `${opts.equalityKey}:${normalizedKey}` : normalizedKey;
+  if (computedMap.has(cacheKey)) {
+    const entry2 = computedMap.get(cacheKey);
+    entry2.selector = selector;
+    entry2.equality = opts?.equality || DEFAULT_EQUALITY;
+    const newDeps2 = /* @__PURE__ */ new Set();
+    const wrappedGet = /* @__PURE__ */ __name((path) => {
+      newDeps2.add(path);
+      return _readStatePath(path);
+    }, "wrappedGet");
+    let newValue;
+    try {
+      newValue = selector(wrappedGet);
+    } catch (err) {
+      if (exports.DEV) console.error("[memorio computed] selector error:", err);
+      return entry2.lastValue;
+    }
+    if (entry2.equality(entry2.lastValue, newValue)) {
+      return entry2.lastValue;
+    }
+    entry2.lastValue = newValue;
+    _setupDeps(cacheKey, entry2, newDeps2);
+    for (const sub of entry2.subscribers) {
+      try {
+        sub(newValue);
+      } catch (err) {
+        if (exports.DEV) console.error("[memorio computed] subscriber error:", err);
+      }
+    }
+    return newValue;
+  }
+  const newDeps = /* @__PURE__ */ new Set();
+  const get = /* @__PURE__ */ __name((path) => {
+    newDeps.add(path);
+    return _readStatePath(path);
+  }, "get");
+  let lastValue;
+  try {
+    lastValue = selector(get);
+  } catch (err) {
+    if (exports.DEV) console.error("[memorio computed] selector error:", err);
+    message_default(`[memorio computed] selector error: ${err}`);
+    lastValue = null;
+  }
+  const entry = {
+    selector,
+    lastValue,
+    deps: newDeps,
+    equality: opts?.equality || DEFAULT_EQUALITY,
+    subscribers: /* @__PURE__ */ new Set(),
+    _dispatchUnsubscribers: []
+  };
+  computedMap.set(cacheKey, entry);
+  _setupDeps(cacheKey, entry, newDeps);
+  return lastValue;
+}
+__name(_compute, "_compute");
+function _getValue(key) {
+  const normalizedKey = _normalizeKey(key);
+  const entry = computedMap.get(normalizedKey);
+  if (!entry) return null;
+  return entry.lastValue;
+}
+__name(_getValue, "_getValue");
+function _subscribe(key, cb) {
+  const normalizedKey = _normalizeKey(key);
+  const entry = computedMap.get(normalizedKey);
+  if (!entry) {
+    if (exports.DEV) console.warn(`[memorio computed] subscribe: no computed value registered for key '${key}'`);
+    return () => {
+    };
+  }
+  entry.subscribers.add(cb);
+  return () => {
+    entry.subscribers.delete(cb);
+  };
+}
+__name(_subscribe, "_subscribe");
+function _remove3(key) {
+  const normalizedKey = _normalizeKey(key);
+  if (!computedMap.has(normalizedKey)) return false;
+  const entry = computedMap.get(normalizedKey);
+  for (const off of entry._dispatchUnsubscribers) off();
+  computedMap.delete(normalizedKey);
+  return true;
+}
+__name(_remove3, "_remove");
+function _list() {
+  return Array.from(computedMap.keys());
+}
+__name(_list, "_list");
+function _clear() {
+  for (const [, entry] of computedMap) {
+    for (const off of entry._dispatchUnsubscribers) off();
+  }
+  computedMap.clear();
+}
+__name(_clear, "_clear");
+var computed = {
+  compute: _compute,
+  getValue: _getValue,
+  subscribe: _subscribe,
+  remove: _remove3,
+  list: _list,
+  clear: _clear
+};
+
+// functions/broadcast/index.ts
+init_cjs_shims();
+init_env();
+init_message();
+var _channel = null;
+var _storageListener = null;
+var _originalDispatchSet = null;
+var _installed = false;
+var _targets = "all";
+var _isLocalChange = false;
+function _hasBroadcastChannel() {
+  return typeof BroadcastChannel !== "undefined";
+}
+__name(_hasBroadcastChannel, "_hasBroadcastChannel");
+function _hasStorageEvents() {
+  return typeof window !== "undefined" && "addEventListener" in window;
+}
+__name(_hasStorageEvents, "_hasStorageEvents");
+function _shouldSync(target) {
+  if (_targets === "all") return true;
+  return _targets === target;
+}
+__name(_shouldSync, "_shouldSync");
+function _onBroadcastMessage(event) {
+  let msg;
+  try {
+    msg = event.data;
+  } catch {
+    return;
+  }
+  if (!msg || !msg.__memorio_sync) return;
+  if (!_shouldSync(msg.target)) return;
+  if (_isLocalChange) return;
+  try {
+    if (msg.target === "state" || msg.target === "all") {
+      const s = globalThis.state;
+      if (s) {
+        _isLocalChange = true;
+        try {
+          const segments = msg.path.replace(/^state\./, "").split(".");
+          let current = s;
+          for (let i = 0; i < segments.length - 1; i++) {
+            const seg = segments[i];
+            if (current[seg] === void 0 || current[seg] === null) {
+              current[seg] = {};
+            }
+            current = current[seg];
+          }
+          const lastSeg = segments[segments.length - 1];
+          if (msg.action === "set") {
+            current[lastSeg] = msg.value;
+          } else if (msg.action === "delete") {
+            delete current[lastSeg];
+          }
+        } finally {
+          queueMicrotask(() => {
+            _isLocalChange = false;
+          });
+        }
+      }
+    }
+  } catch (err) {
+    if (exports.DEV) console.error("[memorio broadcast] apply state error:", err);
+  }
+}
+__name(_onBroadcastMessage, "_onBroadcastMessage");
+function _onStorageEvent(e) {
+  if (!e.key) return;
+  const prefixes = [
+    ["memorio_store_", "store"],
+    ["memorio_session_", "session"]
+  ];
+  for (const [prefix, target] of prefixes) {
+    if (e.key.startsWith(prefix)) {
+      if (!_shouldSync(target)) continue;
+      const cleanKey = e.key.slice(prefix.length);
+      dispatch.set(`memorio:broadcast:${target}:${cleanKey}`, {
+        detail: { key: cleanKey, oldValue: e.oldValue, newValue: e.newValue }
+      });
+      break;
+    }
+  }
+}
+__name(_onStorageEvent, "_onStorageEvent");
+function _wrapDispatchSet() {
+  if (_originalDispatchSet !== null) return;
+  _originalDispatchSet = dispatch.set;
+  const original = dispatch.set;
+  dispatch.set = (name, value) => {
+    original(name, value);
+    if (name.startsWith("state.") && _shouldSync("state") && _channel) {
+      _isLocalChange = true;
+      try {
+        _channel.postMessage({
+          __memorio_sync: true,
+          target: "state",
+          action: "set",
+          path: name,
+          value: _extractStateValue(name),
+          timestamp: Date.now()
+        });
+      } finally {
+        queueMicrotask(() => {
+          _isLocalChange = false;
+        });
+      }
+    }
+  };
+}
+__name(_wrapDispatchSet, "_wrapDispatchSet");
+function _restoreDispatchSet() {
+  if (_originalDispatchSet !== null) {
+    dispatch.set = _originalDispatchSet;
+    _originalDispatchSet = null;
+  }
+}
+__name(_restoreDispatchSet, "_restoreDispatchSet");
+function _extractStateValue(path) {
+  const s = globalThis.state;
+  if (!s) return void 0;
+  try {
+    const segments = path.replace(/^state\./, "").split(".");
+    let current = s;
+    for (const seg of segments) {
+      if (current === null || current === void 0) break;
+      current = current[seg];
+    }
+    return current === void 0 ? null : current;
+  } catch {
+    return null;
+  }
+}
+__name(_extractStateValue, "_extractStateValue");
+var broadcast = {
+  install: /* @__PURE__ */ __name((channelName, opts) => {
+    if (_installed) return;
+    const name = channelName || opts?.channelName || "memorio_sync";
+    _targets = opts?.targets || "all";
+    if (_hasBroadcastChannel()) {
+      _channel = new BroadcastChannel(name);
+      _channel.addEventListener("message", _onBroadcastMessage);
+      _installed = true;
+      _wrapDispatchSet();
+      if (exports.DEV) message_default(`memorio broadcast: installed (channel="${name}", targets="${_targets}")`);
+    }
+    if (_hasStorageEvents()) {
+      _storageListener = _onStorageEvent;
+      window.addEventListener("storage", _storageListener);
+      _installed = true;
+      if (!_hasBroadcastChannel() && exports.DEV) {
+        message_default(`memorio broadcast: using storage event fallback (targets="${_targets}")`);
+      }
+    }
+    if (!_installed) {
+      console.warn("[memorio broadcast] Neither BroadcastChannel nor storage events are available in this environment.");
+    }
+  }, "install"),
+  uninstall: /* @__PURE__ */ __name(() => {
+    if (_channel) {
+      _channel.removeEventListener("message", _onBroadcastMessage);
+      _channel.close();
+      _channel = null;
+    }
+    if (_storageListener && typeof window !== "undefined") {
+      window.removeEventListener("storage", _storageListener);
+      _storageListener = null;
+    }
+    _restoreDispatchSet();
+    _installed = false;
+  }, "uninstall"),
+  isInstalled: /* @__PURE__ */ __name(() => _installed, "isInstalled"),
+  broadcast: /* @__PURE__ */ __name((msg) => {
+    if (!_channel) return;
+    _channel.postMessage({ ...msg, timestamp: Date.now() });
+  }, "broadcast")
+};
+
+// functions/security/index.ts
+init_cjs_shims();
+init_env();
+function _safeRandomUUID() {
+  const g3 = globalThis;
+  if (typeof g3.crypto !== "undefined" && typeof g3.crypto.randomUUID === "function") {
+    try {
+      return g3.crypto.randomUUID();
+    } catch {
+    }
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+__name(_safeRandomUUID, "_safeRandomUUID");
+var REGEX_TIMEOUT_MS = 100;
+function _safeRegexTest(pattern, key) {
+  if (/\(.*[+*?].*.*\)[+*?]/.test(pattern)) {
+    if (exports.DEV) console.warn(`[memorio security] Potentially dangerous regex blocked: ${pattern}`);
+    return false;
+  }
+  if (pattern.length > 500) {
+    if (exports.DEV) console.warn("[memorio security] Regex pattern exceeds max length (500)");
+    return false;
+  }
+  const startTime = Date.now();
+  try {
+    const regex = new RegExp(pattern);
+    const result = regex.test(key);
+    const elapsed = Date.now() - startTime;
+    if (elapsed > REGEX_TIMEOUT_MS) {
+      if (exports.DEV) console.warn(`[memorio security] Slow regex detected (${elapsed}ms): ${pattern}`);
+    }
+    return result;
+  } catch {
+    return false;
+  }
+}
+__name(_safeRegexTest, "_safeRegexTest");
+function addAccessRule(rules, pattern, perms) {
+  const key = pattern instanceof RegExp ? pattern.source : pattern;
+  rules.set(key, perms);
+  return rules;
+}
+__name(addAccessRule, "addAccessRule");
+function hasPermission(rules, key, action, userId) {
+  if (rules.size === 0) return true;
+  for (const [pattern, perms] of rules) {
+    let matches;
+    if (typeof pattern === "function") {
+      try {
+        matches = pattern(key, userId);
+      } catch {
+        matches = false;
+      }
+    } else {
+      matches = _safeRegexTest(pattern, key);
+    }
+    if (matches) {
+      const allowed = perms.includes(action) || perms.includes("admin");
+      if (!allowed) {
+        logAudit({
+          action,
+          key,
+          userId,
+          success: false,
+          error: "RBAC Denied: insufficient permissions"
+        });
+      }
+      return allowed;
+    }
+  }
+  logAudit({
+    action: "permission_check",
+    key,
+    userId,
+    success: false,
+    error: "RBAC Denied: no matching rule"
+  });
+  return false;
+}
+__name(hasPermission, "hasPermission");
+var _auditLogger = null;
+function isAuditActive() {
+  return _auditLogger !== null;
+}
+__name(isAuditActive, "isAuditActive");
+function setAuditLogger(logger3) {
+  _auditLogger = logger3;
+}
+__name(setAuditLogger, "setAuditLogger");
+function logAudit(entry) {
+  if (!_auditLogger) return;
+  _auditLogger({
+    timestamp: Date.now(),
+    success: true,
+    ...entry
+  });
+}
+__name(logAudit, "logAudit");
+function sanitizeValue(value) {
+  if (typeof value === "string") {
+    let decoded = value.replace(/&#[xX]?[0-9a-fA-F]+;?/g, (match) => {
+      const hexMatch = match.match(/&#x([0-9a-fA-F]+);?/i);
+      if (hexMatch && hexMatch[1]) {
+        return String.fromCharCode(parseInt(hexMatch[1], 16));
+      }
+      const decMatch = match.match(/&#([0-9]+);?/);
+      if (decMatch && decMatch[1]) {
+        return String.fromCharCode(parseInt(decMatch[1], 10));
+      }
+      return match;
+    });
+    try {
+      decoded = decodeURIComponent(decoded);
+    } catch {
     }
-    return () => {
-      unsubs.forEach(({ path, off }) => {
-        off();
-        message_default(`useObserver: Stopped monitoring "${path}"`);
-      });
-    };
-  } catch (err) {
-    message_default(`useObserver Error: ${err}`);
-    return () => {
-    };
+    decoded = decoded.replace(/(javascript|vbscript|data:text\/html|about:blank|chrome:)/gi, "[SEC-REMOVED]");
+    return decoded.replace(/<script\b[^>]*>[\s\S]*?<\s*\/\s*script\b[^>]*>/gi, "[SEC-REMOVED]").replace(/on\w+\s*=/gi, "[SEC-REMOVED]=").replace(/<iframe\b[^<]*(?:(?!<\/iframe>)<[^<]*)*<\/iframe>/gi, "[SEC-REMOVED]").replace(/<object\b[^<]*(?:(?!<\/object>)<[^<]*)*<\/object>/gi, "[SEC-REMOVED]").replace(/<embed\b[^>]*>/gi, "[SEC-REMOVED]").replace(/<svg\b[^<]*(?:(?!<\/svg>)<[^<]*)*<\/svg>/gi, "[SEC-REMOVED]").replace(/<form\b[^<]*(?:(?!<\/form>)<[^<]*)*<\/form>/gi, "[SEC-REMOVED]").replace(/<base\b[^<]*(?:(?!<\/base>)<[^<]*)*<\/base>/gi, "[SEC-REMOVED]").replace(/<link\b[^<]*(?:(?!<\/link>)<[^<]*)*<\/link>/gi, "[SEC-REMOVED]").replace(/<meta\b[^<]*(?:(?!<\/meta>)<[^<]*)*<\/meta>/gi, "[SEC-REMOVED]").replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, "[SEC-REMOVED]");
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const ctor = value.constructor?.name;
+    if (ctor === "Object" || ctor === void 0) {
+      const sanitized = {};
+      for (const [k, v] of Object.entries(value)) {
+        if (k === "__proto__" || k === "constructor" || k === "prototype") continue;
+        sanitized[k] = sanitizeValue(v);
+      }
+      return sanitized;
+    }
+    return value;
   }
-}), "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
+  if (Array.isArray(value)) {
+    return value.map((v) => sanitizeValue(v));
+  }
+  return value;
+}
+__name(sanitizeValue, "sanitizeValue");
+function validateKey(key) {
+  return /^[a-zA-Z0-9_.-]+$/.test(key) && key.length <= 256 && key.length > 0;
+}
+__name(validateKey, "validateKey");
+function recordConsent(consents, userId, purpose, granted) {
+  const record = {
+    id: _safeRandomUUID(),
+    purpose,
+    granted,
+    timestamp: Date.now()
+  };
+  const user = consents.get(userId) || [];
+  user.push(record);
+  consents.set(userId, user);
+  return record;
+}
+__name(recordConsent, "recordConsent");
+function hasConsent(consents, userId, purpose) {
+  const userConsents = consents.get(userId);
+  if (!userConsents) return false;
+  for (let i = userConsents.length - 1; i >= 0; i--) {
+    const record = userConsents[i];
+    if (record && record.purpose === purpose) {
+      return record.granted;
     }
-  );
-  Object.freeze(globalThis.useObserver);
+  }
+  return false;
+}
+__name(hasConsent, "hasConsent");
+function revokeConsent(consents, userId, purpose) {
+  return recordConsent(consents, userId, purpose, false);
+}
+__name(revokeConsent, "revokeConsent");
+function getConsents(consents, userId) {
+  return consents.get(userId) || [];
+}
+__name(getConsents, "getConsents");
+function exportUserData(consents, userId) {
+  return {
+    userId,
+    exportedAt: Date.now(),
+    consents: consents.get(userId) || []
+  };
 }
+__name(exportUserData, "exportUserData");
+function deleteUserData(consents, userId) {
+  const count = consents.get(userId)?.length || 0;
+  consents.delete(userId);
+  return { success: true, deletedConsents: count };
+}
+__name(deleteUserData, "deleteUserData");
+var security = {
+  // Re-exports for convenience
+  safeRandomUUID: _safeRandomUUID,
+  safeRegexTest: _safeRegexTest,
+  // RBAC
+  addAccessRule,
+  hasPermission,
+  // Audit logging
+  isAuditActive,
+  setAuditLogger,
+  logAudit,
+  // Input sanitization
+  sanitizeValue,
+  validateKey,
+  // Consent management
+  recordConsent,
+  hasConsent,
+  revokeConsent,
+  getConsents,
+  exportUserData,
+  deleteUserData
+};
 
 // index.ts
 init_message();
@@ -2711,439 +4380,67 @@ var log = /* @__PURE__ */ __name((module, action, path, value, previousValue) =>
     );
     if (value !== void 0) {
       message_default(`  \u2192 value:${value}`);
-    }
-    if (previousValue !== void 0) {
-      message_default(`  \u2190 previous:${previousValue}`);
-    }
-  }
-  if (config.customHandler) {
-    config.customHandler(entry);
-  }
-}, "log");
-var getModuleColor = /* @__PURE__ */ __name((module) => {
-  const colors = {
-    state: "#4CAF50",
-    store: "#2196F3",
-    session: "#FF9800",
-    cache: "#9C27B0",
-    idb: "#F44336"
-  };
-  return colors[module] || "#888888";
-}, "getModuleColor");
-var getHistory = /* @__PURE__ */ __name(() => {
-  return [...logHistory];
-}, "getHistory");
-var clearHistory = /* @__PURE__ */ __name(() => {
-  logHistory.length = 0;
-}, "clearHistory");
-var getStats = /* @__PURE__ */ __name(() => {
-  const stats2 = {
-    total: logHistory.length,
-    state: 0,
-    store: 0,
-    session: 0,
-    cache: 0,
-    idb: 0,
-    set: 0,
-    get: 0,
-    delete: 0,
-    clear: 0
-  };
-  for (const entry of logHistory) {
-    if (entry) {
-      const module = entry.module;
-      const action = entry.action;
-      if (module && typeof stats2[module] === "number") stats2[module]++;
-      if (action && typeof stats2[action] === "number") stats2[action]++;
-    }
-  }
-  return stats2;
-}, "getStats");
-var exportLogs = /* @__PURE__ */ __name(() => {
-  return JSON.stringify(logHistory, null, 2);
-}, "exportLogs");
-var logger = {
-  configure,
-  enable,
-  disable,
-  isEnabled,
-  log,
-  getHistory,
-  clearHistory,
-  getStats,
-  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 (previousValue !== void 0) {
+      message_default(`  \u2190 previous:${previousValue}`);
+    }
   }
-  if (a.logical !== b.logical) {
-    return a.logical < b.logical ? -1 : 1;
+  if (config.customHandler) {
+    config.customHandler(entry);
   }
-  if (a.node !== b.node) {
-    return a.node < b.node ? -1 : 1;
+}, "log");
+var getModuleColor = /* @__PURE__ */ __name((module) => {
+  const colors = {
+    state: "#4CAF50",
+    store: "#2196F3",
+    session: "#FF9800",
+    cache: "#9C27B0",
+    idb: "#F44336"
+  };
+  return colors[module] || "#888888";
+}, "getModuleColor");
+var getHistory = /* @__PURE__ */ __name(() => {
+  return [...logHistory];
+}, "getHistory");
+var clearHistory = /* @__PURE__ */ __name(() => {
+  logHistory.length = 0;
+}, "clearHistory");
+var getStats = /* @__PURE__ */ __name(() => {
+  const stats = {
+    total: logHistory.length,
+    state: 0,
+    store: 0,
+    session: 0,
+    cache: 0,
+    idb: 0,
+    set: 0,
+    get: 0,
+    delete: 0,
+    clear: 0
+  };
+  for (const entry of logHistory) {
+    if (entry) {
+      const module = entry.module;
+      const action = entry.action;
+      if (module && typeof stats[module] === "number") stats[module]++;
+      if (action && typeof stats[action] === "number") stats[action]++;
+    }
   }
-  return 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
+  return stats;
+}, "getStats");
+var exportLogs = /* @__PURE__ */ __name(() => {
+  return JSON.stringify(logHistory, null, 2);
+}, "exportLogs");
+var logger = {
+  configure,
+  enable,
+  disable,
+  isEnabled,
+  log,
+  getHistory,
+  clearHistory,
+  getStats,
+  exportLogs
 };
 
 // core/fractional.ts
@@ -3307,214 +4604,53 @@ function reindex(items) {
     if (prev === null) {
       newItem.key = before(items[0].key);
     } else if (next === null) {
-      newItem.key = after(prev);
-    } else {
-      newItem.key = between(prev, next);
-    }
-    result.push(newItem);
-    prev = newItem.key;
-  }
-  return result;
-}
-__name(reindex, "reindex");
-var fractional = {
-  generateBetween,
-  firstKey,
-  after,
-  before,
-  between,
-  reorder,
-  reindex
-};
-
-// index.ts
-init_internal();
-init_platform();
-
-// core/global.ts
-init_cjs_shims();
-init_platform();
-init_internal();
-
-// package.json
-var package_default = {
-  version: "4.9.35"};
-
-// core/global.ts
-init_env();
-init_store();
-init_idb();
-init_sqlite();
-init_message();
-
-// functions/typed/index.ts
-init_cjs_shims();
-function typed() {
-  return exports.state;
-}
-__name(typed, "typed");
-
-// functions/history/index.ts
-init_cjs_shims();
-init_internal();
-init_env();
-init_message();
-function _clone(value) {
-  if (value === null || typeof value !== "object") return value;
-  try {
-    return deepRaw(value, /* @__PURE__ */ new WeakSet());
-  } catch (err) {
-    if (exports.DEV) console.warn("[memorio history] deep clone failed:", err);
-    return value;
-  }
-}
-__name(_clone, "_clone");
-var snapshot = /* @__PURE__ */ __name(() => {
-  return deepRaw(exports.state, /* @__PURE__ */ new WeakSet());
-}, "snapshot");
-var diff = /* @__PURE__ */ __name((snap) => {
-  const changes = [];
-  const _walk = /* @__PURE__ */ __name((oldObj, newObj, prefix) => {
-    const oldKeys = oldObj ? Object.keys(oldObj) : [];
-    const newKeys = newObj ? Object.keys(newObj) : [];
-    for (const key of newKeys) {
-      const newPath = prefix ? `${prefix}.${key}` : key;
-      const oldVal = oldObj ? oldObj[key] : void 0;
-      const newVal = newObj[key];
-      if (oldVal !== newVal) {
-        const oldType = typeof oldVal;
-        const newType = typeof newVal;
-        if (oldType !== newType || oldVal === void 0) {
-          changes.push({ path: newPath, oldValue: oldVal, newValue: newVal });
-        } else if (oldVal && typeof oldVal === "object") {
-          _walk(oldVal, newVal, newPath);
-        } else if (oldVal !== newVal) {
-          changes.push({ path: newPath, oldValue: oldVal, newValue: newVal });
-        }
-      }
-    }
-    for (const key of oldKeys) {
-      if (!(key in (newObj || {}))) {
-        const newPath = prefix ? `${prefix}.${key}` : key;
-        changes.push({ path: newPath, oldValue: oldObj[key], newValue: void 0 });
-      }
-    }
-  }, "_walk");
-  _walk(snap, deepRaw(exports.state), "");
-  return changes;
-}, "diff");
-var enableHistory = /* @__PURE__ */ __name((enabled = true) => {
-  exports.internal.historyEnabled = enabled;
-  message_default(`[memorio history] Tracking ${enabled ? "enabled" : "disabled"}`);
-}, "enableHistory");
-var trace = /* @__PURE__ */ __name(() => {
-  return [...exports.internal.mutations];
-}, "trace");
-var canUndo = /* @__PURE__ */ __name(() => {
-  return exports.internal.canUndo();
-}, "canUndo");
-var canRedo = /* @__PURE__ */ __name(() => {
-  return exports.internal.canRedo();
-}, "canRedo");
-var undo = /* @__PURE__ */ __name(() => {
-  if (!exports.internal.historyEnabled) {
-    message_default("[memorio history] History is not enabled");
-    return void 0;
-  }
-  const record = exports.internal.popUndo();
-  if (!record) return void 0;
-  _applyInverse(record);
-  message_default(`[memorio history] Undid: ${record.action} ${record.path}`);
-  return record;
-}, "undo");
-var redo = /* @__PURE__ */ __name(() => {
-  if (!exports.internal.historyEnabled) {
-    message_default("[memorio history] History is not enabled");
-    return void 0;
-  }
-  const record = exports.internal.popRedo();
-  if (!record) return void 0;
-  _applyForward(record);
-  message_default(`[memorio history] Redid: ${record.action} ${record.path}`);
-  return record;
-}, "redo");
-function _applyInverse(record) {
-  const wasEnabled = exports.internal.historyEnabled;
-  exports.internal.historyEnabled = false;
-  try {
-    if (record.action === "set") {
-      if (record.previousValue === void 0) {
-        _deletePath(record.path);
-      } else {
-        _setPath(record.path, record.previousValue);
-      }
-    } else if (record.action === "delete") {
-      if (record.previousValue !== void 0) {
-        _setPath(record.path, record.previousValue);
-      }
-    }
-  } finally {
-    exports.internal.historyEnabled = wasEnabled;
-  }
-}
-__name(_applyInverse, "_applyInverse");
-function _applyForward(record) {
-  const wasEnabled = exports.internal.historyEnabled;
-  exports.internal.historyEnabled = false;
-  try {
-    if (record.action === "set") {
-      _setPath(record.path, record.newValue);
-    } else if (record.action === "delete") {
-      _deletePath(record.path);
-    }
-  } finally {
-    exports.internal.historyEnabled = wasEnabled;
-  }
-}
-__name(_applyForward, "_applyForward");
-function _setPath(path, value) {
-  const parts = path.split(".");
-  let current = exports.state;
-  for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i];
-    if (current[part] === void 0) {
-      current[part] = {};
+      newItem.key = after(prev);
+    } else {
+      newItem.key = between(prev, next);
     }
-    current = current[part];
+    result.push(newItem);
+    prev = newItem.key;
   }
-  current[parts[parts.length - 1]] = value;
+  return result;
 }
-__name(_setPath, "_setPath");
-function _deletePath(path) {
-  const parts = path.split(".");
-  if (parts.length === 1) {
-    exports.state.remove(parts[0]);
-    return;
-  }
-  let current = exports.state;
-  for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i];
-    if (current[part] === void 0) return;
-    current = current[part];
-  }
-  delete current[parts[parts.length - 1]];
+__name(reindex, "reindex");
+var fractional = {
+  generateBetween,
+  firstKey,
+  after,
+  before,
+  between,
+  reorder,
+  reindex
+};
+
+// index.ts
+init_internal();
+init_platform();
+
+// core/global.ts
+init_cjs_shims();
+init_platform();
+init_internal();
+
+// package.json
+var package_default = {
+  version: "5.1.0"};
+
+// core/global.ts
+init_env();
+init_store();
+init_idb();
+init_sqlite();
+init_encryption();
+init_message();
+
+// functions/typed/index.ts
+init_cjs_shims();
+function typed() {
+  return exports.state;
 }
-__name(_deletePath, "_deletePath");
-var rollback = /* @__PURE__ */ __name((snap) => {
-  exports.state.removeAll();
-  for (const key of Object.keys(snap)) {
-    exports.state[key] = _clone(snap[key]);
-  }
-  exports.internal.clearHistory();
-  message_default("[memorio history] State rolled back to snapshot");
-}, "rollback");
-var clearHistory2 = /* @__PURE__ */ __name(() => {
-  exports.internal.clearHistory();
-  message_default("[memorio history] History cleared");
-}, "clearHistory");
-var clearRedo = /* @__PURE__ */ __name(() => {
-  exports.internal.clearRedo();
-}, "clearRedo");
+__name(typed, "typed");
 
 // functions/memory/index.ts
 init_cjs_shims();
@@ -4207,83 +5343,167 @@ var memory = {
   }
 };
 
-// functions/inspect/index.ts
+// functions/history/index.ts
 init_cjs_shims();
+init_internal();
 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];
+init_message();
+function _clone(value) {
+  if (value === null || typeof value !== "object") return value;
+  try {
+    return deepRaw(value, /* @__PURE__ */ new WeakSet());
+  } catch (err) {
+    if (exports.DEV) console.warn("[memorio history] deep clone failed:", err);
+    return value;
   }
-  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) {
+}
+__name(_clone, "_clone");
+var snapshot = /* @__PURE__ */ __name(() => {
+  return deepRaw(exports.state, /* @__PURE__ */ new WeakSet());
+}, "snapshot");
+var diff = /* @__PURE__ */ __name((snap) => {
+  const changes = [];
+  const _walk = /* @__PURE__ */ __name((oldObj, newObj, prefix) => {
+    const oldKeys = oldObj ? Object.keys(oldObj) : [];
+    const newKeys = newObj ? Object.keys(newObj) : [];
+    for (const key of newKeys) {
       const newPath = prefix ? `${prefix}.${key}` : key;
-      const 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);
+      const oldVal = oldObj ? oldObj[key] : void 0;
+      const newVal = newObj[key];
+      if (oldVal !== newVal) {
+        const oldType = typeof oldVal;
+        const newType = typeof newVal;
+        if (oldType !== newType || oldVal === void 0) {
+          changes.push({ path: newPath, oldValue: oldVal, newValue: newVal });
+        } else if (oldVal && typeof oldVal === "object") {
+          _walk(oldVal, newVal, newPath);
+        } else if (oldVal !== newVal) {
+          changes.push({ path: newPath, oldValue: oldVal, newValue: newVal });
+        }
+      }
+    }
+    for (const key of oldKeys) {
+      if (!(key in (newObj || {}))) {
+        const newPath = prefix ? `${prefix}.${key}` : key;
+        changes.push({ path: newPath, oldValue: oldObj[key], newValue: void 0 });
       }
     }
   }, "_walk");
-  _walk(deepRaw(exports.state), "");
-  return result;
-}, "stateSchema");
-function _getValue(path) {
-  if (!path || typeof path !== "string") return [false, void 0];
-  const parts = path.replace(/^state\./, "").split(".");
+  _walk(snap, deepRaw(exports.state), "");
+  return changes;
+}, "diff");
+var enableHistory = /* @__PURE__ */ __name((enabled = true) => {
+  exports.internal.historyEnabled = enabled;
+  message_default(`[memorio history] Tracking ${enabled ? "enabled" : "disabled"}`);
+}, "enableHistory");
+var trace = /* @__PURE__ */ __name(() => {
+  return [...exports.internal.mutations];
+}, "trace");
+var canUndo = /* @__PURE__ */ __name(() => {
+  return exports.internal.canUndo();
+}, "canUndo");
+var canRedo = /* @__PURE__ */ __name(() => {
+  return exports.internal.canRedo();
+}, "canRedo");
+var undo = /* @__PURE__ */ __name(() => {
+  if (!exports.internal.historyEnabled) {
+    message_default("[memorio history] History is not enabled");
+    return void 0;
+  }
+  const record = exports.internal.popUndo();
+  if (!record) return void 0;
+  _applyInverse2(record);
+  message_default(`[memorio history] Undid: ${record.action} ${record.path}`);
+  return record;
+}, "undo");
+var redo = /* @__PURE__ */ __name(() => {
+  if (!exports.internal.historyEnabled) {
+    message_default("[memorio history] History is not enabled");
+    return void 0;
+  }
+  const record = exports.internal.popRedo();
+  if (!record) return void 0;
+  _applyForward(record);
+  message_default(`[memorio history] Redid: ${record.action} ${record.path}`);
+  return record;
+}, "redo");
+function _applyInverse2(record) {
+  const wasEnabled = exports.internal.historyEnabled;
+  exports.internal.historyEnabled = false;
+  try {
+    if (record.action === "set") {
+      if (record.previousValue === void 0) {
+        _deletePath2(record.path);
+      } else {
+        _setPath2(record.path, record.previousValue);
+      }
+    } else if (record.action === "delete") {
+      if (record.previousValue !== void 0) {
+        _setPath2(record.path, record.previousValue);
+      }
+    }
+  } finally {
+    exports.internal.historyEnabled = wasEnabled;
+  }
+}
+__name(_applyInverse2, "_applyInverse");
+function _applyForward(record) {
+  const wasEnabled = exports.internal.historyEnabled;
+  exports.internal.historyEnabled = false;
+  try {
+    if (record.action === "set") {
+      _setPath2(record.path, record.newValue);
+    } else if (record.action === "delete") {
+      _deletePath2(record.path);
+    }
+  } finally {
+    exports.internal.historyEnabled = wasEnabled;
+  }
+}
+__name(_applyForward, "_applyForward");
+function _setPath2(path, value) {
+  const parts = path.split(".");
   let current = exports.state;
-  for (const part of parts) {
-    if (current === null || current === void 0) {
-      return [false, void 0];
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === void 0) {
+      current[part] = {};
     }
     current = current[part];
   }
-  return [current !== void 0, current];
+  current[parts[parts.length - 1]] = value;
 }
-__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(_setPath2, "_setPath");
+function _deletePath2(path) {
+  const parts = path.split(".");
+  if (parts.length === 1) {
+    exports.state.remove(parts[0]);
+    return;
+  }
+  let current = exports.state;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === void 0) return;
+    current = current[part];
   }
+  delete current[parts[parts.length - 1]];
 }
-__name(_clone2, "_clone");
+__name(_deletePath2, "_deletePath");
+var rollback = /* @__PURE__ */ __name((snap) => {
+  exports.state.removeAll();
+  for (const key of Object.keys(snap)) {
+    exports.state[key] = _clone(snap[key]);
+  }
+  exports.internal.clearHistory();
+  message_default("[memorio history] State rolled back to snapshot");
+}, "rollback");
+var clearHistory2 = /* @__PURE__ */ __name(() => {
+  exports.internal.clearHistory();
+  message_default("[memorio history] History cleared");
+}, "clearHistory");
+var clearRedo = /* @__PURE__ */ __name(() => {
+  exports.internal.clearRedo();
+}, "clearRedo");
 
 // core/global.ts
 if (!("memorio" in globalThis)) {
@@ -4318,6 +5538,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?.());
   }
@@ -4331,16 +5571,18 @@ if (!("memorio" in globalThis)) {
     }
   );
   memorio.memory = memory;
+  memorio.encryption = exports.encryption;
   initializePlatform();
   memorio.isBrowser = isBrowser;
   memorio.isNode = isNode;
   memorio.isDeno = isDeno;
+  memorio.isBun = isBun;
   memorio.isEdge = isEdge;
   memorio.getCapabilities = getCapabilities;
   memorio.createContext = createContext;
   memorio.listContexts = listContexts;
   memorio.deleteContext = deleteContext;
-  memorio.isolate = (name) => createContext(name);
+  memorio.isolate = (name, opts) => createContext(name, opts);
   Object.defineProperty(memorio, "setContext", { writable: false, enumerable: false, value: /* @__PURE__ */ __name((id) => setCurrentContext(id), "value") });
   Object.defineProperty(memorio, "getContext", { writable: false, enumerable: false, value: /* @__PURE__ */ __name(() => exports.internal.currentContext, "value") });
   memorio.registerSchema = schema.register;
@@ -4348,6 +5590,9 @@ if (!("memorio" in globalThis)) {
   memorio.unregisterSchema = schema.unregister;
   memorio.listSchemas = schema.list;
   memorio.typed = typed;
+  memorio.computed = computed;
+  memorio.broadcast = broadcast;
+  memorio.security = security;
   memorio.snapshot = snapshot;
   memorio.diff = diff;
   memorio.undo = undo;
@@ -4359,10 +5604,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() {
@@ -4374,189 +5626,98 @@ if (!("memorio" in globalThis)) {
       idb: exports.idb,
       sqlite: exports.sqlite,
       observer,
-      useObserver
+      useObserver,
+      encryption: exports.encryption,
+      computed,
+      broadcast,
+      security
     };
     for (const key of Object.keys(globalDefinitions)) {
       if (!(key 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.broadcast = broadcast;
 exports.cache = cache;
+exports.canMerge = canMerge;
 exports.canRedo = canRedo;
 exports.canUndo = canUndo;
 exports.clearHistory = clearHistory2;
 exports.clearRedo = clearRedo;
+exports.commitTransaction = commitTransaction;
+exports.computed = computed;
 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.isBun = isBun;
 exports.isDeno = isDeno;
 exports.isEdge = isEdge;
 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.security = security;
 exports.setContext = setContext;
 exports.snapshot = snapshot;
+exports.toPatch = toPatch;
 exports.trace = trace;
+exports.transaction = transaction;
 exports.typed = typed;
 exports.undo = undo;
 exports.unregisterSchema = unregisterSchema;