memorio 4.9.35 → 5.1.0

package/index.js

@@ -7,6 +7,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 });
+};
 var init_esm_shims = __esm({
   "node_modules/tsup/assets/esm_shims.js"() {
   }
@@ -17,8 +21,11 @@ var DEV, PROD;
 var init_env = __esm({
   "core/env.ts"() {
     init_esm_shims();
-    DEV = typeof process !== "undefined" ? false : true;
+    DEV = false ;
     PROD = !DEV;
+    if (typeof globalThis !== "undefined") {
+      globalThis["__DEV__"] = DEV;
+    }
   }
 });
 
@@ -202,6 +209,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, encryption;
+var init_encryption = __esm({
+  "functions/encryption/index.ts"() {
+    init_esm_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;
+    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 (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;
@@ -216,6 +458,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";
@@ -231,6 +476,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";
@@ -284,6 +536,9 @@ function hasSqlJs() {
   }
   return typeof anyGlobal.window !== "undefined";
 }
+function hasBunSqlite() {
+  return _isBun();
+}
 function hasDispatchEvent() {
   return typeof globalThis.dispatchEvent === "function";
 }
@@ -296,6 +551,7 @@ function getCapabilities() {
     hasLocalStorage: getLocalStorage() !== null,
     hasIndexedDB: hasIndexedDB(),
     hasSqlJs: hasSqlJs(),
+    hasBunSqlite: hasBunSqlite(),
     hasDispatchEvent: hasDispatchEvent(),
     hasNavigator: typeof navigator !== "undefined",
     hasProcess: typeof process !== "undefined",
@@ -355,8 +611,9 @@ function initializePlatform() {
     };
   }
 }
-function createContext(name) {
+function createContext(name, opts) {
   const contextId = name || `context_${generateSessionId()}`;
+  const encKey = opts?.encryptionKey;
   setCurrentContext(contextId);
   const contextStorage = {
     state: {},
@@ -365,10 +622,31 @@ function createContext(name) {
     cache: /* @__PURE__ */ new Map()
   };
   _contexts.set(contextId, contextStorage);
+  function _isEncrypted2(value) {
+    return 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 encryption.decrypt(parsed, encKey);
+        return parsed;
+      }, "get"),
+      set: /* @__PURE__ */ __name(async (key, value) => {
+        const env = await 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;
@@ -382,7 +660,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 encryption.decrypt(parsed, encKey);
+        return parsed;
+      }, "get"),
+      set: /* @__PURE__ */ __name(async (key, value) => {
+        const env = await 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;
@@ -402,7 +697,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() {
@@ -419,8 +715,11 @@ var init_platform = __esm({
   "core/platform.ts"() {
     init_esm_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");
@@ -429,6 +728,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();
@@ -454,6 +754,9 @@ function _getFallbackStorage() {
   }
   return _fallbackStorageByContext.get(key);
 }
+function _isEncryptedEnvelope(value) {
+  return encryption.isEncrypted(value);
+}
 function _getPrefix() {
   const contextName = internal_default.currentContext || "";
   return contextName ? `${contextName}-` : `memorio_store_`;
@@ -490,17 +793,23 @@ function _remove(prefixedName) {
   }
   return false;
 }
-var _localStorage, _fallbackStorageByContext, _hasStorage, STORE_INSTANCE_KEY, store;
+var _localStorage, _fallbackStorageByContext, _hasStorage, _encryptionKey, _onError, _maxObjectSize, _maxTotalSize, STORE_INSTANCE_KEY, store;
 var init_store = __esm({
   "functions/store/index.ts"() {
     init_esm_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");
@@ -517,16 +826,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 encryption.decrypt(raw, key);
+                }
+                return raw;
               } catch (err) {
                 message(`Error parsing store item '${name}': ${err}`);
               }
@@ -551,10 +868,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;
@@ -566,15 +886,66 @@ var init_store = __esm({
                 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 = 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 encryption.encrypt(value, key).then((env) => {
+                  _write(prefixedName, env);
+                  return true;
+                }).catch((err) => {
+                  message(`Error encrypting store item '${name}': ${err}`);
+                  _onError?.(err, { operation: "set" });
+                  return false;
+                });
+              }
               try {
                 _write(prefixedName, value);
               } catch (err) {
                 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 store;
+            }, "value")
+          },
           /**
            * Removes a value from storage.
            * @param name The key to remove.
@@ -945,8 +1316,8 @@ var init_table_size = __esm({
         if (!db.objectStoreNames.contains(table)) return resolve(0);
         let size = 0;
         let count = 0;
-        const transaction = db.transaction([table], "readonly");
-        const store2 = transaction.objectStore(table);
+        const transaction2 = db.transaction([table], "readonly");
+        const store2 = transaction2.objectStore(table);
         const request = store2.openCursor();
         request.onsuccess = async (event) => {
           const cursor = event.target.result;
@@ -990,8 +1361,8 @@ var init_data_delete = __esm({
             db.close();
             return reject(new Error(`Table ${table} not found`));
           }
-          const transaction = db.transaction(table, "readwrite");
-          const objectStore = transaction.objectStore(table);
+          const transaction2 = db.transaction(table, "readwrite");
+          const objectStore = transaction2.objectStore(table);
           const deleteRequest = objectStore.delete(key);
           deleteRequest.onsuccess = () => {
             db.close();
@@ -1015,8 +1386,8 @@ var init_data_delete = __esm({
             db.close();
             return reject(new Error(`Table ${table} not found`));
           }
-          const transaction = db.transaction(table, "readwrite");
-          const store2 = transaction.objectStore(table);
+          const transaction2 = db.transaction(table, "readwrite");
+          const store2 = transaction2.objectStore(table);
           const clearRequest = store2.clear();
           clearRequest.onsuccess = () => {
             db.close();
@@ -1050,8 +1421,8 @@ var init_data_set = __esm({
             db.close();
             return reject(new Error(`Table ${table} does not exist in ${storeName}`));
           }
-          const transaction = db.transaction(table, "readwrite");
-          const objectStore = transaction.objectStore(table);
+          const transaction2 = db.transaction(table, "readwrite");
+          const objectStore = transaction2.objectStore(table);
           const putRequest = objectStore.put(value);
           putRequest.onsuccess = () => {
             db.close();
@@ -1087,8 +1458,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();
@@ -1160,6 +1531,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_esm_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() {
@@ -1220,11 +1676,18 @@ var init_db_support2 = __esm({
       return g3.initSqlJs || g3;
     }, "_loadSqlJsFromCdn");
     sqlite.db.support = () => {
-      return hasSqlJs();
+      return hasSqlJs() || hasBunSqlite();
     };
     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 () => {
@@ -1251,7 +1714,7 @@ var init_db_support2 = __esm({
         } catch (_) {
         }
         try {
-          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>() }).";
+          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);
@@ -1274,7 +1737,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;
@@ -1282,7 +1745,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"));
   }
@@ -1304,7 +1767,7 @@ function saveSnapshot(name) {
     }
     try {
       const blob = db.export();
-      store.set(_key(name), _b64encode(blob));
+      store.set(_key(name), _b64encode2(blob));
       message_default(`Memorio SQLite: persisted '${name}' to store`);
       resolve(true);
     } catch (err) {
@@ -1317,7 +1780,7 @@ function loadSnapshot(name) {
   const b64 = store.get(_key(name));
   if (!b64) return null;
   try {
-    return _b64decode(b64);
+    return _b64decode2(b64);
   } catch {
     return null;
   }
@@ -1352,8 +1815,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");
@@ -1558,7 +2021,14 @@ var init_db_export = __esm({
     init_sqlite();
     sqlite.db.export = async (name = "memorio") => {
       const db = 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;
+      }
     };
   }
 });
@@ -1642,13 +2112,14 @@ var init_data_get2 = __esm({
 });
 
 // functions/sqlite/index.ts
-var _hasSqlJs, sqlite;
+var _hasSqlJs, _hasBunSqlite, sqlite;
 var init_sqlite = __esm({
   "functions/sqlite/index.ts"() {
     init_esm_shims();
     init_platform();
     init_env();
     _hasSqlJs = hasSqlJs();
+    _hasBunSqlite = hasBunSqlite();
     sqlite = {
       db: {},
       query: {},
@@ -1675,7 +2146,7 @@ var init_sqlite = __esm({
         return g3.sqliteReady;
       }, "get")
     });
-    if (_hasSqlJs) {
+    if (_hasSqlJs || _hasBunSqlite) {
       (async () => {
         Object.defineProperty(sqlite, "db", { value: {}, writable: false, configurable: true, enumerable: true });
         Object.defineProperty(sqlite, "query", { value: {}, writable: false, configurable: true, enumerable: true });
@@ -1703,11 +2174,11 @@ var init_sqlite = __esm({
       })();
     } else {
       sqlite._disabled = true;
-      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.';
+      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 (DEV) {
         globalThis.sqliteDisabled = true;
         globalThis.sqliteWarning = 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.");
       }
     }
   }
@@ -1750,9 +2221,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);
@@ -1888,101 +2375,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_esm_shims();
+init_internal();
+
+// core/hlc.ts
+init_esm_shims();
+var NODE_ID_KEY = "__memorio_hlc_node";
+function getNodeId() {
+  if (typeof globalThis === "undefined") return "node";
+  try {
+    if (typeof sessionStorage !== "undefined" && sessionStorage) {
+      let id = sessionStorage.getItem(NODE_ID_KEY);
+      if (!id) {
+        id = generateNodeId();
+        sessionStorage.setItem(NODE_ID_KEY, id);
+      }
+      return id;
+    }
+  } catch {
   }
-  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 (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 path2 = tree.length > 0 ? "state." + tree.concat(prop).join(".") : "state." + prop;
-          internal_default.lastAccessedPath = path2;
-          if (internal_default.tracking) {
-            internal_default.trackedPaths.add(path2);
-          }
-        }
-        if (prop === "_lastPath") {
-          return internal_default.lastAccessedPath;
-        }
-        if (prop === "remove") {
-          return (key) => {
-            delete target[key];
-            return true;
-          };
-        }
-        if (prop === "removeAll") {
-          return () => {
-            try {
-              for (const key in target) {
-                if (typeof target[key] !== "function" && !["list", "remove", "removeAll", "lock", "unlock"].includes(key)) {
-                  delete target[key];
-                }
-              }
-            } catch (error) {
-              console.error(error);
-            }
-            return;
-          };
-        }
-        if (Object.isFrozen(target[prop])) return target[prop];
-        if (prop === "lock" || prop === "unlock") {
-          const value = Reflect.get(target, prop);
-          if (value) return value;
-        }
-        try {
-          const value = Reflect.get(target, prop);
-          if (value && typeof value === "object" && ["Array", "Object"].includes(value.constructor.name)) {
-            let wrapper = wrapperCache.get(value);
-            if (!wrapper) {
-              wrapper = buildProxy(value, callback, tree.concat(prop));
-              wrapperCache.set(value, wrapper);
-            }
-            return wrapper;
-          }
-          return value;
-        } catch (error) {
-          console.error("Error: ", error);
+  return globalThis.__memorioHlcNodeId;
+}
+__name(getNodeId, "getNodeId");
+function generateNodeId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID().slice(0, 8);
+  }
+  return Math.random().toString(36).slice(2, 10);
+}
+__name(generateNodeId, "generateNodeId");
+var HLC_KEY = "__memorio_hlc_local";
+var local = globalThis[HLC_KEY] || {
+  physical: 0,
+  logical: 0,
+  node: getNodeId()
+};
+if (!globalThis[HLC_KEY]) {
+  globalThis[HLC_KEY] = local;
+}
+function tick(_incoming) {
+  const now2 = Date.now();
+  const base = local.physical;
+  let physical;
+  let logical;
+  if (now2 > base) {
+    physical = now2;
+    logical = 0;
+  } else if (now2 < base) {
+    physical = base;
+    logical = local.logical + 1;
+  } else {
+    physical = base;
+    logical = local.logical + 1;
+  }
+  local.physical = physical;
+  local.logical = logical;
+  return { physical, logical, node: local.node };
+}
+__name(tick, "tick");
+function receive(remote) {
+  const now2 = Date.now();
+  if (remote.physical > local.physical) {
+    local.physical = remote.physical > now2 ? remote.physical : now2;
+    local.logical = 1;
+  } else if (remote.physical === local.physical) {
+    local.logical = Math.max(local.logical, remote.logical) + 1;
+  }
+  local.node = getNodeId();
+  return { ...local };
+}
+__name(receive, "receive");
+function compare(a, b) {
+  if (a.physical !== b.physical) {
+    return a.physical < b.physical ? -1 : 1;
+  }
+  if (a.logical !== b.logical) {
+    return a.logical < b.logical ? -1 : 1;
+  }
+  if (a.node !== b.node) {
+    return a.node < b.node ? -1 : 1;
+  }
+  return 0;
+}
+__name(compare, "compare");
+function happenedBefore(a, b) {
+  return compare(a, b) < 0;
+}
+__name(happenedBefore, "happenedBefore");
+function serialize(hlc2) {
+  return `hlc:${hlc2.physical}:${hlc2.logical}:${hlc2.node}`;
+}
+__name(serialize, "serialize");
+function parse(serialized) {
+  if (!serialized.startsWith("hlc:")) return null;
+  const parts = serialized.split(":");
+  if (parts.length !== 4) return null;
+  const physical = parseInt(parts[1], 10);
+  const logical = parseInt(parts[2], 10);
+  const node = parts[3];
+  if (isNaN(physical) || isNaN(logical)) return null;
+  return { physical, logical, node };
+}
+__name(parse, "parse");
+var hlc = {
+  tick,
+  receive,
+  compare,
+  happenedBefore,
+  serialize,
+  parse,
+  getNodeId
+};
+
+// core/mutation/id.ts
+init_esm_shims();
+function generateMutationId() {
+  const now2 = hlc.tick();
+  return "m_" + encodeHLC(now2);
+}
+__name(generateMutationId, "generateMutationId");
+function generateTransactionId() {
+  const now2 = hlc.tick();
+  return "tx_" + encodeHLC(now2);
+}
+__name(generateTransactionId, "generateTransactionId");
+function generateCommitId() {
+  const now2 = hlc.tick();
+  return "c_" + encodeHLC(now2);
+}
+__name(generateCommitId, "generateCommitId");
+function encodeHLC(hlcValue) {
+  const timePart = hlcValue.physical.toString(36);
+  const logicalPart = hlcValue.logical.toString(36).padStart(2, "0");
+  const nodePart = hlcValue.node.slice(0, 4);
+  return `${timePart}${logicalPart}${nodePart}`;
+}
+__name(encodeHLC, "encodeHLC");
+
+// core/mutation/patch.ts
+init_esm_shims();
+function mutationToPatch(mutation) {
+  if (mutation.before === mutation.after) return null;
+  const op = mutationToPatchOp(mutation.operation, mutation.before, mutation.after);
+  if (!op) return null;
+  const patch = { op, path: mutation.path };
+  if (op === "add" || op === "replace") {
+    patch.value = mutation.after;
+  }
+  if (op === "replace") {
+    patch.oldValue = mutation.before;
+  }
+  if (op === "remove") {
+    patch.oldValue = mutation.before;
+  }
+  return patch;
+}
+__name(mutationToPatch, "mutationToPatch");
+function mutationToPatchOp(operation, _before, _after) {
+  switch (operation) {
+    case "set":
+      if (_before === void 0) return "add";
+      return "replace";
+    case "delete":
+      return "remove";
+    case "insert":
+      return "add";
+    case "remove":
+      return "remove";
+    case "replace":
+      return "replace";
+    case "length":
+      return "replace";
+    default:
+      return null;
+  }
+}
+__name(mutationToPatchOp, "mutationToPatchOp");
+function diffToPatch(path2, before2, after2) {
+  if (before2 === after2) return null;
+  if (after2 === void 0) {
+    return { op: "remove", path: path2, oldValue: before2 };
+  }
+  if (before2 === void 0) {
+    return { op: "add", path: path2, value: after2 };
+  }
+  return { op: "replace", path: path2, value: after2, oldValue: before2 };
+}
+__name(diffToPatch, "diffToPatch");
+function canMerge(patch1, patch2) {
+  return patch1.path === patch2.path && patch1.op === patch2.op;
+}
+__name(canMerge, "canMerge");
+function mergePatches(patch1, patch2) {
+  const op = patch1.op === "remove" && patch2.op === "remove" ? "remove" : "replace";
+  return {
+    op,
+    path: patch1.path,
+    value: patch2.value ?? patch1.value,
+    oldValue: patch1.oldValue
+  };
+}
+__name(mergePatches, "mergePatches");
+
+// core/mutation/transaction.ts
+init_esm_shims();
+init_internal();
+var TX_REGISTRY_KEY = "__memorio_transaction_registry__";
+var registry = globalThis[TX_REGISTRY_KEY] || /* @__PURE__ */ new Map();
+if (!globalThis[TX_REGISTRY_KEY]) {
+  globalThis[TX_REGISTRY_KEY] = registry;
+}
+var TX_STACK_KEY = "__memorio_transaction_stack__";
+var txStack = globalThis[TX_STACK_KEY] || [];
+if (!globalThis[TX_STACK_KEY]) {
+  globalThis[TX_STACK_KEY] = txStack;
+}
+function getActiveTxId() {
+  return txStack.length > 0 ? txStack[txStack.length - 1] : null;
+}
+__name(getActiveTxId, "getActiveTxId");
+function setActiveTx(id) {
+  if (id === null) {
+    txStack.pop();
+  } else {
+    txStack.push(id);
+  }
+}
+__name(setActiveTx, "setActiveTx");
+function beginTransaction(source, message2, metadata) {
+  const id = generateTransactionId();
+  const ctx = {
+    id,
+    startedAt: hlc.serialize(hlc.tick()),
+    source,
+    message: message2,
+    metadata,
+    mutations: [],
+    active: true
+  };
+  registry.set(id, ctx);
+  setActiveTx(id);
+  return ctx;
+}
+__name(beginTransaction, "beginTransaction");
+function tagForTransaction() {
+  const txId = getActiveTxId();
+  if (!txId) return void 0;
+  const ctx = registry.get(txId);
+  if (ctx && ctx.active) {
+    return txId;
+  }
+  return void 0;
+}
+__name(tagForTransaction, "tagForTransaction");
+function commitTransaction() {
+  const txId = getActiveTxId();
+  if (!txId) return null;
+  const ctx = registry.get(txId);
+  if (!ctx || !ctx.active) return null;
+  ctx.active = false;
+  ctx.committedAt = hlc.serialize(hlc.tick());
+  const tx = {
+    id: ctx.id,
+    mutations: ctx.mutations,
+    startedAt: ctx.startedAt,
+    committedAt: ctx.committedAt,
+    source: ctx.source,
+    message: ctx.message,
+    metadata: ctx.metadata
+  };
+  setActiveTx(null);
+  return tx;
+}
+__name(commitTransaction, "commitTransaction");
+function _setPath(path2, value) {
+  const parts = path2.replace(/^state\./, "").split(".");
+  let current = globalThis.state;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === void 0) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+__name(_setPath, "_setPath");
+function _deletePath(path2) {
+  const parts = path2.replace(/^state\./, "").split(".");
+  let current = globalThis.state;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === void 0) return;
+    current = current[part];
+  }
+  if (current.remove) {
+    current.remove(parts[parts.length - 1]);
+  } else {
+    delete current[parts[parts.length - 1]];
+  }
+}
+__name(_deletePath, "_deletePath");
+function _applyInverse(record) {
+  const wasEnabled = internal_default.historyEnabled;
+  const wasRecording = internal_default._recording;
+  internal_default.historyEnabled = false;
+  internal_default._recording = false;
+  try {
+    if (record.action === "set" || record.operation === "set") {
+      if (record.previousValue === void 0) {
+        _deletePath(record.path);
+      } else {
+        _setPath(record.path, record.previousValue);
+      }
+    } else if (record.action === "delete" || record.operation === "delete") {
+      if (record.previousValue !== void 0) {
+        _setPath(record.path, record.previousValue);
+      }
+    }
+  } finally {
+    internal_default.historyEnabled = wasEnabled;
+    internal_default._recording = wasRecording;
+  }
+}
+__name(_applyInverse, "_applyInverse");
+function abortTransaction() {
+  const txId = getActiveTxId();
+  if (!txId) return null;
+  const ctx = registry.get(txId);
+  if (!ctx || !ctx.active) return null;
+  for (let i = ctx.mutations.length - 1; i >= 0; i--) {
+    const undoStack = internal_default.undoStack;
+    const idx = undoStack.findIndex((r) => r.id === ctx.mutations[i]);
+    if (idx >= 0) {
+      const record = undoStack[idx];
+      internal_default.undoStack.splice(idx, 1);
+      _applyInverse(record);
+    }
+  }
+  ctx.active = false;
+  ctx.committedAt = hlc.serialize(hlc.tick());
+  const tx = {
+    id: ctx.id,
+    mutations: ctx.mutations,
+    startedAt: ctx.startedAt,
+    committedAt: ctx.committedAt,
+    source: ctx.source,
+    message: ctx.message,
+    metadata: ctx.metadata
+  };
+  registry.delete(txId);
+  setActiveTx(null);
+  return tx;
+}
+__name(abortTransaction, "abortTransaction");
+function listTransactions() {
+  const result = [];
+  for (const ctx of registry.values()) {
+    result.push({
+      id: ctx.id,
+      mutations: ctx.mutations,
+      startedAt: ctx.startedAt,
+      committedAt: ctx.committedAt,
+      source: ctx.source,
+      message: ctx.message,
+      metadata: ctx.metadata
+    });
+  }
+  return result;
+}
+__name(listTransactions, "listTransactions");
+function currentTransaction() {
+  const txId = getActiveTxId();
+  if (!txId) return null;
+  const ctx = registry.get(txId);
+  if (!ctx || !ctx.active) return null;
+  return {
+    id: ctx.id,
+    mutations: ctx.mutations,
+    startedAt: ctx.startedAt,
+    source: ctx.source,
+    message: ctx.message,
+    metadata: ctx.metadata
+  };
+}
+__name(currentTransaction, "currentTransaction");
+function registerMutationInTransaction(mutationId) {
+  const txId = getActiveTxId();
+  if (!txId) return;
+  const ctx = registry.get(txId);
+  if (ctx && ctx.active) {
+    ctx.mutations.push(mutationId);
+  }
+}
+__name(registerMutationInTransaction, "registerMutationInTransaction");
+
+// core/mutation/engine.ts
+function currentTimestamp() {
+  return hlc.serialize(hlc.tick());
+}
+__name(currentTimestamp, "currentTimestamp");
+function createMutation(path2, operation, before2, after2, options) {
+  const now2 = hlc.tick();
+  const mutation = {
+    id: generateMutationId(),
+    path: path2,
+    operation,
+    after: after2,
+    before: before2,
+    timestamp: now2.physical,
+    hlc: hlc.serialize(now2),
+    context: options?.context || internal_default.currentContext || void 0,
+    source: options?.source,
+    transactionId: options?.transactionId || (operation !== "length" ? tagForTransaction() : void 0),
+    // Legacy fields for backward compatibility
+    action: operation === "set" ? "set" : "delete",
+    newValue: after2,
+    previousValue: before2
+  };
+  if (mutation.transactionId) {
+    registerMutationInTransaction(mutation.id);
+  }
+  return mutation;
+}
+__name(createMutation, "createMutation");
+function recordMutation(mutation) {
+  if (!internal_default.historyEnabled) return;
+  internal_default.recordMutation(mutation);
+}
+__name(recordMutation, "recordMutation");
+function toPatch(mutation) {
+  return mutationToPatch(mutation);
+}
+__name(toPatch, "toPatch");
+function mutate(path2, value, options) {
+  const normalizedPath = path2.startsWith("state.") ? path2 : "state." + path2;
+  const keyPath = normalizedPath.replace(/^state\./, "");
+  let current;
+  try {
+    const parts2 = keyPath.split(".");
+    let obj = globalThis.state;
+    for (const part of parts2) {
+      obj = obj?.[part];
+    }
+    current = obj;
+  } catch {
+    current = void 0;
+  }
+  const operation = value === void 0 ? "delete" : "set";
+  const mutation = createMutation(
+    normalizedPath,
+    operation,
+    current,
+    value === void 0 ? void 0 : value,
+    options
+  );
+  const wasRecording = internal_default._recording;
+  internal_default._recording = false;
+  const parts = keyPath.split(".");
+  let target = globalThis.state;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (target[parts[i]] === void 0) {
+      target[parts[i]] = {};
+    }
+    target = target[parts[i]];
+  }
+  if (operation === "delete") {
+    delete target[parts[parts.length - 1]];
+  } else {
+    target[parts[parts.length - 1]] = value;
+  }
+  internal_default._recording = wasRecording;
+  recordMutation(mutation);
+  return mutation;
+}
+__name(mutate, "mutate");
+function activeTransactionId() {
+  return internal_default.currentTransactionId || null;
+}
+__name(activeTransactionId, "activeTransactionId");
+
+// functions/state/index.ts
+var TARGET = /* @__PURE__ */ Symbol("memorio.target");
+var wrapperCache = /* @__PURE__ */ new WeakMap();
+var arrayRootDedup = /* @__PURE__ */ new Set();
+var deepRaw = /* @__PURE__ */ __name((val, seen = null) => {
+  if (val === null || typeof val !== "object") return val;
+  if (!seen) seen = /* @__PURE__ */ new WeakSet();
+  if (val[TARGET] !== void 0) return deepRaw(val[TARGET], seen);
+  if (seen) {
+    if (seen.has(val)) return val;
+    seen.add(val);
+  }
+  const ctor = val.constructor?.name;
+  if (ctor !== "Object" && ctor !== "Array") return val;
+  const copy = Array.isArray(val) ? [] : {};
+  for (const k of Reflect.ownKeys(val)) {
+    if (!Object.prototype.propertyIsEnumerable.call(val, k)) continue;
+    copy[k] = deepRaw(val[k], seen);
+  }
+  return copy;
+}, "deepRaw");
+var objPath = /* @__PURE__ */ __name((prop, object, separator = ".") => {
+  return object.concat(prop).join(separator);
+}, "objPath");
+var buildProxy = /* @__PURE__ */ __name((obj, callback, tree = []) => {
+  const event = /* @__PURE__ */ __name((name) => {
+    try {
+      dispatch.set(name, { detail: { name } });
+    } catch (err) {
+      if (DEV) console.warn("[memorio state] event dispatch failed:", err);
+    }
+    return;
+  }, "event");
+  return new Proxy(
+    obj,
+    {
+      get(target, prop) {
+        if (prop === "__path") {
+          return tree.length > 0 ? "state." + tree.join(".") : "state";
+        }
+        if (prop === TARGET) {
+          return target;
+        }
+        if (target[TARGET] !== void 0) {
+          return target;
+        }
+        if (prop === "list") {
+          message_default('Some state could be hidden when you use "state.list". Use "state" to see the complete list ');
+          return deepRaw(target, /* @__PURE__ */ new WeakSet());
+        }
+        if (typeof prop === "string") {
+          const path2 = tree.length > 0 ? "state." + tree.concat(prop).join(".") : "state." + prop;
+          internal_default.lastAccessedPath = path2;
+          if (internal_default.tracking) {
+            internal_default.trackedPaths.add(path2);
+          }
+        }
+        if (prop === "_lastPath") {
+          return internal_default.lastAccessedPath;
+        }
+        if (prop === "remove") {
+          return (key) => {
+            delete target[key];
+            return true;
+          };
+        }
+        if (prop === "removeAll") {
+          return () => {
+            try {
+              for (const key of Reflect.ownKeys(target)) {
+                if (typeof target[key] !== "function" && !["list", "remove", "removeAll", "lock", "unlock", "persist"].includes(key)) {
+                  delete target[key];
+                }
+              }
+            } catch (error) {
+              console.error(error);
+            }
+            return;
+          };
+        }
+        if (Object.isFrozen(target[prop])) return target[prop];
+        if (prop === "lock" || prop === "unlock") {
+          const value = Reflect.get(target, prop);
+          if (value) return value;
+        }
+        try {
+          const value = Reflect.get(target, prop);
+          if (value && typeof value === "object" && ["Array", "Object"].includes(value.constructor.name)) {
+            let wrapper = wrapperCache.get(value);
+            if (!wrapper) {
+              wrapper = buildProxy(value, callback, tree.concat(prop));
+              wrapperCache.set(value, wrapper);
+            }
+            return wrapper;
+          }
+          return value;
+        } catch (error) {
+          console.error("Error: ", error);
           return void 0;
         }
       },
@@ -2029,6 +3004,16 @@ var buildProxy = /* @__PURE__ */ __name((obj, callback, tree = []) => {
             }
           );
           event("state." + path2);
+          if (Array.isArray(target) && tree.length > 0) {
+            const rootName = "state." + tree.join(".");
+            if (!arrayRootDedup.has(rootName)) {
+              arrayRootDedup.add(rootName);
+              event(rootName);
+              if (typeof globalThis.queueMicrotask === "function") {
+                globalThis.queueMicrotask(() => arrayRootDedup.clear());
+              }
+            }
+          }
           Reflect.set(target, key, rawValue);
           internal_default.bumpStateVersion();
           if (target[key] && typeof target[key] === "object") {
@@ -2085,6 +3070,17 @@ var buildProxy = /* @__PURE__ */ __name((obj, callback, tree = []) => {
           const path2 = objPath(prop, tree);
           const previousValue = Reflect.get(target, prop);
           callback({ action: "delete", path: path2, target, previousValue });
+          event("state." + path2);
+          if (Array.isArray(target) && tree.length > 0) {
+            const rootName = "state." + tree.join(".");
+            if (!arrayRootDedup.has(rootName)) {
+              arrayRootDedup.add(rootName);
+              event(rootName);
+              if (typeof globalThis.queueMicrotask === "function") {
+                globalThis.queueMicrotask(() => arrayRootDedup.clear());
+              }
+            }
+          }
           return Reflect.deleteProperty(target, prop);
         } catch (error) {
           console.error("Error in deleteProperty trap:", error);
@@ -2106,57 +3102,83 @@ if (globalThis[STATE_INSTANCE_KEY]) {
   state2 = globalThis[STATE_INSTANCE_KEY];
 } else {
   state2 = buildProxy({}, (mutation) => {
-    if (internal_default.historyEnabled) {
-      internal_default.recordMutation({
-        path: mutation.path,
-        action: mutation.action,
-        newValue: mutation.newValue,
-        previousValue: mutation.previousValue,
-        timestamp: Date.now()
-      });
+    if (internal_default.historyEnabled && internal_default._recording !== false) {
+      const operation = mutation.action === "delete" ? "delete" : "set";
+      const record = createMutation(
+        mutation.path,
+        operation,
+        mutation.previousValue,
+        mutation.newValue,
+        {
+          context: mutation.context,
+          source: mutation.source
+        }
+      );
+      internal_default.recordMutation(record);
     }
   });
-  state2.lock = () => {
-    internal_default.locked = true;
-    message_default("State is now locked. All modifications are blocked.");
-  };
-  state2.unlock = () => {
-    internal_default.locked = false;
-    message_default("State is now unlocked. Modifications are allowed.");
-  };
-  state2.persist = (path2) => {
-    if (typeof path2 !== "string" || !path2.length) {
-      if (DEV) console.warn('[memorio state] state.persist() requires a non-empty path string (e.g. "state.user")');
-      return () => {
-      };
-    }
-    const normalized = path2.startsWith("state.") ? path2 : "state." + path2;
-    const key = normalized.replace(/^state\./, "");
-    const segments = key.split(".");
-    const initial = store.get(key);
-    if (initial !== void 0 && initial !== null) {
-      let acc = state2;
-      for (let i = 0; i < segments.length; 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 = state2[TARGET];
+  try {
+    Object.defineProperty(_rawTarget, "lock", {
+      value: /* @__PURE__ */ __name(() => {
+        internal_default.locked = true;
+        message_default("State is now locked. All modifications are blocked.");
+      }, "value"),
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+    Object.defineProperty(_rawTarget, "unlock", {
+      value: /* @__PURE__ */ __name(() => {
+        internal_default.locked = false;
+        message_default("State is now unlocked. Modifications are allowed.");
+      }, "value"),
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  } catch (e) {
+    if (DEV) console.warn("[memorio state] lock/unlock defineProperty failed:", e);
+  }
+  try {
+    Object.defineProperty(_rawTarget, "persist", {
+      value: /* @__PURE__ */ __name((path2) => {
+        if (typeof path2 !== "string" || !path2.length) {
+          if (DEV) console.warn('[memorio state] state.persist() requires a non-empty path string (e.g. "state.user")');
+          return () => {
+          };
         }
-      }
-    }
-    const handler = /* @__PURE__ */ __name(() => {
-      let current = state2;
-      for (const seg of segments) {
-        current = current === void 0 || current === null ? void 0 : current[seg];
-      }
-      store.set(key, deepRaw(current));
-    }, "handler");
-    const off = dispatch.listen(normalized, handler);
-    return typeof off === "function" ? off : () => {
-    };
-  };
+        const normalized = path2.startsWith("state.") ? path2 : "state." + path2;
+        const key = normalized.replace(/^state\./, "");
+        const segments = key.split(".");
+        const initial = store.get(key);
+        if (initial !== void 0 && initial !== null) {
+          let acc = state2;
+          for (let i = 0; i < segments.length - 1; i++) {
+            const seg = segments[i];
+            if (acc[seg] === void 0 || acc[seg] === null) acc[seg] = {};
+            acc = acc[seg];
+          }
+          if (acc) acc[segments[segments.length - 1]] = deepRaw(initial);
+        }
+        const handler = /* @__PURE__ */ __name(() => {
+          let current = state2;
+          for (const seg of segments) {
+            current = current === void 0 || current === null ? void 0 : current[seg];
+          }
+          store.set(key, deepRaw(current));
+        }, "handler");
+        const off = dispatch.listen(normalized, handler);
+        return typeof off === "function" ? off : () => {
+        };
+      }, "value"),
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  } catch (e) {
+    if (DEV) console.warn("[memorio state] persist defineProperty failed:", e);
+  }
   globalThis[STATE_INSTANCE_KEY] = state2;
 }
 
@@ -2168,6 +3190,7 @@ init_esm_shims();
 init_platform();
 init_internal();
 init_message();
+init_encryption();
 var _sessionStorage = getSessionStorage();
 var _fallbackStorageByContext2 = /* @__PURE__ */ new Map();
 function _getFallbackStorage2() {
@@ -2180,6 +3203,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 encryption.isEncrypted(value);
+}
+__name(_isEncryptedEnvelope2, "_isEncryptedEnvelope");
 function _getPrefix2() {
   const contextName = internal_default.currentContext || "";
   return contextName ? `${contextName}-` : `memorio_session_`;
@@ -2233,16 +3264,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 encryption.decrypt(raw, key);
+            }
+            return raw;
           } catch (err) {
             message(`Error parsing session item '${name}':${err}`);
           }
@@ -2253,10 +3290,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;
@@ -2268,15 +3306,63 @@ if (globalThis[SESSION_INSTANCE_KEY]) {
             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 = 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 encryption.encrypt(value, key).then((env) => {
+              _write2(prefixedName, env);
+              return true;
+            }).catch((err) => {
+              message(`Error encrypting session item '${name}': ${err}`);
+              _onError2?.(err, { operation: "set" });
+              return false;
+            });
+          }
           try {
             _write2(prefixedName, value);
           } catch (err) {
             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 session;
+        }, "value")
+      },
       /**
        * Removes a value from storage.
        * @param name The key to remove.
@@ -2508,12 +3594,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;
@@ -2576,7 +3667,6 @@ Object.defineProperties(
 init_esm_shims();
 init_message();
 init_internal();
-init_env();
 var useObserver = /* @__PURE__ */ __name(((func, deps = []) => {
   if (!deps || typeof func !== "function") {
     return () => {
@@ -2620,37 +3710,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: path2, off }) => {
+        off();
+        message_default(`useObserver: Stopped monitoring "${path2}"`);
+      });
+    };
+  } catch (err) {
+    message_default(`useObserver Error: ${err}`);
+    return () => {
+    };
+  }
+}), "useObserver");
+
+// index.ts
+init_encryption();
+
+// functions/computed/index.ts
+init_esm_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 (DEV) console.error("[memorio computed] subscriber error:", err);
+    }
+  }
+  dispatch.set("memorio:computed:" + key, { detail: { key, value: newValue } });
+}
+__name(_invalidate, "_invalidate");
+function _readStatePath(path2) {
+  const entry = computedMap.get(path2);
+  if (entry) {
+    return entry.lastValue;
+  }
+  const normalized = path2.startsWith("state.") ? path2 : `state.${path2}`;
+  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((path2) => {
+    if (!path2 || typeof path2 !== "string") return void 0;
+    newDeps.add(path2);
+    return _readStatePath(path2);
+  }, "trackerGet");
+  try {
+    return entry.selector(trackerGet);
+  } catch (err) {
+    if (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((path2) => {
+      newDeps2.add(path2);
+      return _readStatePath(path2);
+    }, "wrappedGet");
+    let newValue;
+    try {
+      newValue = selector(wrappedGet);
+    } catch (err) {
+      if (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 (DEV) console.error("[memorio computed] subscriber error:", err);
+      }
+    }
+    return newValue;
+  }
+  const newDeps = /* @__PURE__ */ new Set();
+  const get = /* @__PURE__ */ __name((path2) => {
+    newDeps.add(path2);
+    return _readStatePath(path2);
+  }, "get");
+  let lastValue;
+  try {
+    lastValue = selector(get);
+  } catch (err) {
+    if (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 (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_esm_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 (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(path2) {
+  const s = globalThis.state;
+  if (!s) return void 0;
+  try {
+    const segments = path2.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 (DEV) message_default(`memorio broadcast: installed (channel="${name}", targets="${_targets}")`);
+    }
+    if (_hasStorageEvents()) {
+      _storageListener = _onStorageEvent;
+      window.addEventListener("storage", _storageListener);
+      _installed = true;
+      if (!_hasBroadcastChannel() && 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_esm_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 (DEV) console.warn(`[memorio security] Potentially dangerous regex blocked: ${pattern}`);
+    return false;
+  }
+  if (pattern.length > 500) {
+    if (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 (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: path2, off }) => {
-        off();
-        message_default(`useObserver: Stopped monitoring "${path2}"`);
-      });
-    };
-  } 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 (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();
@@ -2708,439 +4377,67 @@ var log = /* @__PURE__ */ __name((module, action, path2, 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_esm_shims();
-init_internal();
-init_env();
-var _state = globalThis.__memorio_state_instance__;
-var _store = globalThis.__memorio_store_instance__;
-var _session = globalThis.__memorio_session_instance__;
-var _cache = globalThis.__memorio_cache_instance__;
-function isDebugEnabled2() {
-  return DEV && internal_default.debug === true;
-}
-__name(isDebugEnabled2, "isDebugEnabled");
-function extractStoreData() {
-  if (!_store) return {};
-  const result = {};
-  const store2 = _store;
-  if (typeof store2.list === "function") {
-    try {
-      return store2.list();
-    } catch {
-    }
-  }
-  if (typeof store2.get === "function") {
-    for (const key of Object.keys(store2)) {
-      if (!["get", "set", "remove", "delete", "removeAll", "clearAll", "size", "isPersistent", "list"].includes(key)) {
-        try {
-          const val = store2.get(key);
-          if (val !== null && val !== void 0) {
-            result[key] = val;
-          }
-        } catch {
-        }
-      }
-    }
-  }
-  return result;
-}
-__name(extractStoreData, "extractStoreData");
-function extractSessionData() {
-  if (!_session) return {};
-  const result = {};
-  const session2 = _session;
-  if (typeof session2.list === "function") {
-    try {
-      return session2.list();
-    } catch {
-    }
-  }
-  if (typeof session2.get === "function") {
-    for (const key of Object.keys(session2)) {
-      if (!["get", "set", "remove", "delete", "removeAll", "clearAll", "size", "isPersistent", "list"].includes(key)) {
-        try {
-          const val = session2.get(key);
-          if (val !== null && val !== void 0) {
-            result[key] = val;
-          }
-        } catch {
-        }
-      }
-    }
-  }
-  return result;
-}
-__name(extractSessionData, "extractSessionData");
-var inspect = /* @__PURE__ */ __name(() => {
-  if (!isDebugEnabled2()) return;
-  if (_state) {
-    const stateList = _state.list;
-    let stateData;
-    if (typeof stateList === "function") {
-      stateData = stateList();
-    } else if (typeof stateList === "object" && stateList !== null) {
-      stateData = stateList;
-    } else {
-      stateData = _state;
-    }
-    console.table(stateData);
-  }
-  if (_store) {
-    console.table(extractStoreData());
-  }
-  if (_session) {
-    console.table(extractSessionData());
-  }
-  if (_cache) {
-    const cacheList = _cache.list;
-    let cacheData2;
-    if (typeof cacheList === "function") {
-      cacheData2 = cacheList();
-    } else if (typeof cacheList === "object" && cacheList !== null) {
-      cacheData2 = cacheList;
-    } else {
-      cacheData2 = _cache;
-    }
-    console.table(cacheData2);
-  }
-}, "inspect");
-var stats = /* @__PURE__ */ __name(() => {
-  const getKeys = /* @__PURE__ */ __name((obj) => {
-    if (!obj) return 0;
-    if (typeof obj.list === "function") {
-      try {
-        const list = obj.list();
-        return Object.keys(list).length;
-      } catch {
-      }
-    }
-    return Object.keys(obj).length;
-  }, "getKeys");
-  return {
-    stateKeys: getKeys(_state),
-    storeKeys: getKeys(_store),
-    sessionKeys: getKeys(_session),
-    cacheKeys: getKeys(_cache),
-    idbDatabases: 0,
-    sqliteDbCount: 0,
-    lastUpdate: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}, "stats");
-var clear = /* @__PURE__ */ __name((moduleName) => {
-  const targets = { state: _state, store: _store, session: _session, cache: _cache };
-  const target = targets[moduleName];
-  if (target && typeof target.clear === "function") {
-    target.clear();
-  } else if (target && typeof target.removeAll === "function") {
-    target.removeAll();
-  } else {
-    console.debug(`Module ${moduleName} not found or does not support clear()/removeAll()`);
-  }
-}, "clear");
-var clearAll = /* @__PURE__ */ __name(() => {
-  clear("state");
-  clear("store");
-  clear("session");
-  clear("cache");
-}, "clearAll");
-var exportData = /* @__PURE__ */ __name(() => {
-  const getStateData = /* @__PURE__ */ __name(() => {
-    if (!_state) return void 0;
-    try {
-      if (typeof _state.list === "function") {
-        return _state.list();
-      }
-      return _state;
-    } catch {
-      return void 0;
-    }
-  }, "getStateData");
-  const getStoreData = /* @__PURE__ */ __name(() => {
-    return extractStoreData();
-  }, "getStoreData");
-  const getSessionData = /* @__PURE__ */ __name(() => {
-    return extractSessionData();
-  }, "getSessionData");
-  const getCacheData = /* @__PURE__ */ __name(() => {
-    if (!_cache) return void 0;
-    try {
-      if (typeof _cache.list === "function") {
-        return _cache.list();
-      }
-      return _cache;
-    } catch {
-      return void 0;
-    }
-  }, "getCacheData");
-  const data = {
-    state: getStateData(),
-    store: getStoreData(),
-    session: getSessionData(),
-    cache: getCacheData(),
-    exportedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  return JSON.stringify(data, null, 2);
-}, "exportData");
-var importData = /* @__PURE__ */ __name((jsonString) => {
-  try {
-    const data = JSON.parse(jsonString);
-    if (data.state) {
-      Object.entries(data.state).forEach(([key, value]) => {
-        if (_state && key !== "list" && key !== "remove" && key !== "removeAll") {
-          ;
-          _state[key] = value;
-        }
-      });
-    }
-    if (data.store && _store && typeof _store.set === "function") {
-      Object.entries(data.store).forEach(([key, value]) => {
-        ;
-        _store.set(key, value);
-      });
-    }
-    if (data.session && _session && typeof _session.set === "function") {
-      Object.entries(data.session).forEach(([key, value]) => {
-        ;
-        _session.set(key, value);
-      });
-    }
-    if (data.cache && _cache) {
-      Object.entries(data.cache).forEach(([key, value]) => {
-        if (_cache && key !== "get" && key !== "set" && key !== "remove" && key !== "clear") {
-          ;
-          _cache[key] = value;
-        }
-      });
-    }
-  } catch (error) {
-    console.debug("Import failed:", error);
-  }
-}, "importData");
-var watch = /* @__PURE__ */ __name((moduleName, path2) => {
-  const targets = { state: _state, store: _store, session: _session, cache: _cache };
-  const target = targets[moduleName];
-  if (!target) {
-    console.debug(`Module ${moduleName} not found`);
-    return;
-  }
-  const initialValue = target[path2];
-  console.debug(`Watching ${moduleName}.${path2} (initial: ${JSON.stringify(initialValue)})`);
-  if (moduleName === "state" && globalThis.memorio?.dispatch) {
-    const handler = /* @__PURE__ */ __name((e) => {
-      const detail = e.detail;
-      if (detail?.name?.includes(path2)) {
-        console.debug(`Change: ${moduleName}.${path2} =`, e.detail.value);
-      }
-    }, "handler");
-    target.addEventListener?.("memorio-change", handler);
-  }
-}, "watch");
-var help = /* @__PURE__ */ __name(() => {
-  console.debug(`
-Memorio DevTools Help
-
-Available commands:
-  memorio.devtools.inspect()          - Inspect all state modules
-  memorio.devtools.stats()            - Show statistics
-  memorio.devtools.clear('module')    - Clear specific module
-  memorio.devtools.clearAll()         - Clear all modules
-  memorio.devtools.exportData()       - Export all data as JSON
-  memorio.devtools.importData(json)   - Import data from JSON
-  memorio.devtools.watch(module, path) - Watch a path for changes
-  memorio.devtools.help()             - Show this help
-
-Shortcuts (dev only):
-  state    - global state proxy
-  store    - localStorage wrapper
-  session  - sessionStorage wrapper
-  cache    - in-memory cache
-  `);
-}, "help");
-var devtools = {
-  inspect,
-  stats,
-  clear,
-  clearAll,
-  exportData,
-  importData,
-  watch,
-  help
-};
-
-// core/hlc.ts
-init_esm_shims();
-var NODE_ID_KEY = "__memorio_hlc_node";
-function getNodeId() {
-  if (typeof globalThis === "undefined") return "node";
-  try {
-    if (typeof sessionStorage !== "undefined" && sessionStorage) {
-      let id = sessionStorage.getItem(NODE_ID_KEY);
-      if (!id) {
-        id = generateNodeId();
-        sessionStorage.setItem(NODE_ID_KEY, id);
-      }
-      return id;
-    }
-  } catch {
-  }
-  if (!globalThis.__memorioHlcNodeId) {
-    globalThis.__memorioHlcNodeId = generateNodeId();
-  }
-  return globalThis.__memorioHlcNodeId;
-}
-__name(getNodeId, "getNodeId");
-function generateNodeId() {
-  if (typeof crypto !== "undefined" && crypto.randomUUID) {
-    return crypto.randomUUID().slice(0, 8);
-  }
-  return Math.random().toString(36).slice(2, 10);
-}
-__name(generateNodeId, "generateNodeId");
-var HLC_KEY = "__memorio_hlc_local";
-var local = globalThis[HLC_KEY] || {
-  physical: 0,
-  logical: 0,
-  node: getNodeId()
-};
-if (!globalThis[HLC_KEY]) {
-  globalThis[HLC_KEY] = local;
-}
-function tick(_incoming) {
-  const now2 = Date.now();
-  const base = local.physical;
-  let physical;
-  let logical;
-  if (now2 > base) {
-    physical = now2;
-    logical = 0;
-  } else if (now2 < base) {
-    physical = base;
-    logical = local.logical + 1;
-  } else {
-    physical = base;
-    logical = local.logical + 1;
-  }
-  local.physical = physical;
-  local.logical = logical;
-  return { physical, logical, node: local.node };
-}
-__name(tick, "tick");
-function receive(remote) {
-  const now2 = Date.now();
-  if (remote.physical > local.physical) {
-    local.physical = remote.physical > now2 ? remote.physical : now2;
-    local.logical = 1;
-  } else if (remote.physical === local.physical) {
-    local.logical = Math.max(local.logical, remote.logical) + 1;
-  }
-  local.node = getNodeId();
-  return { ...local };
-}
-__name(receive, "receive");
-function compare(a, b) {
-  if (a.physical !== b.physical) {
-    return a.physical < b.physical ? -1 : 1;
+    }
+    if (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
@@ -3304,214 +4601,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_esm_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_esm_shims();
-function typed() {
-  return state2;
-}
-__name(typed, "typed");
-
-// functions/history/index.ts
-init_esm_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 (DEV) console.warn("[memorio history] deep clone failed:", err);
-    return value;
-  }
-}
-__name(_clone, "_clone");
-var snapshot = /* @__PURE__ */ __name(() => {
-  return deepRaw(state2, /* @__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(state2), "");
-  return changes;
-}, "diff");
-var enableHistory = /* @__PURE__ */ __name((enabled = true) => {
-  internal_default.historyEnabled = enabled;
-  message_default(`[memorio history] Tracking ${enabled ? "enabled" : "disabled"}`);
-}, "enableHistory");
-var trace = /* @__PURE__ */ __name(() => {
-  return [...internal_default.mutations];
-}, "trace");
-var canUndo = /* @__PURE__ */ __name(() => {
-  return internal_default.canUndo();
-}, "canUndo");
-var canRedo = /* @__PURE__ */ __name(() => {
-  return internal_default.canRedo();
-}, "canRedo");
-var undo = /* @__PURE__ */ __name(() => {
-  if (!internal_default.historyEnabled) {
-    message_default("[memorio history] History is not enabled");
-    return void 0;
-  }
-  const record = internal_default.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 (!internal_default.historyEnabled) {
-    message_default("[memorio history] History is not enabled");
-    return void 0;
-  }
-  const record = internal_default.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 = internal_default.historyEnabled;
-  internal_default.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 {
-    internal_default.historyEnabled = wasEnabled;
-  }
-}
-__name(_applyInverse, "_applyInverse");
-function _applyForward(record) {
-  const wasEnabled = internal_default.historyEnabled;
-  internal_default.historyEnabled = false;
-  try {
-    if (record.action === "set") {
-      _setPath(record.path, record.newValue);
-    } else if (record.action === "delete") {
-      _deletePath(record.path);
-    }
-  } finally {
-    internal_default.historyEnabled = wasEnabled;
-  }
-}
-__name(_applyForward, "_applyForward");
-function _setPath(path2, value) {
-  const parts = path2.split(".");
-  let current = state2;
-  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(path2) {
-  const parts = path2.split(".");
-  if (parts.length === 1) {
-    state2.remove(parts[0]);
-    return;
-  }
-  let current = state2;
-  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_esm_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_esm_shims();
+function typed() {
+  return state2;
 }
-__name(_deletePath, "_deletePath");
-var rollback = /* @__PURE__ */ __name((snap) => {
-  state2.removeAll();
-  for (const key of Object.keys(snap)) {
-    state2[key] = _clone(snap[key]);
-  }
-  internal_default.clearHistory();
-  message_default("[memorio history] State rolled back to snapshot");
-}, "rollback");
-var clearHistory2 = /* @__PURE__ */ __name(() => {
-  internal_default.clearHistory();
-  message_default("[memorio history] History cleared");
-}, "clearHistory");
-var clearRedo = /* @__PURE__ */ __name(() => {
-  internal_default.clearRedo();
-}, "clearRedo");
+__name(typed, "typed");
 
 // functions/memory/index.ts
 init_esm_shims();
@@ -4204,83 +5340,167 @@ var memory = {
   }
 };
 
-// functions/inspect/index.ts
+// functions/history/index.ts
 init_esm_shims();
+init_internal();
 init_env();
-var stateKeys = /* @__PURE__ */ __name(() => {
-  const raw = deepRaw(state2);
-  return Object.keys(raw).filter(
-    (k) => !["list", "remove", "removeAll", "lock", "unlock"].includes(k)
-  );
-}, "stateKeys");
-var pathExists = /* @__PURE__ */ __name((path2) => {
-  if (!path2 || typeof path2 !== "string") return false;
-  const parts = path2.replace(/^state\./, "").split(".");
-  let current = state2;
-  for (const part of parts) {
-    if (current === null || current === void 0) {
-      return false;
-    }
-    current = current[part];
+init_message();
+function _clone(value) {
+  if (value === null || typeof value !== "object") return value;
+  try {
+    return deepRaw(value, /* @__PURE__ */ new WeakSet());
+  } catch (err) {
+    if (DEV) console.warn("[memorio history] deep clone failed:", err);
+    return value;
   }
-  return current !== void 0;
-}, "pathExists");
-var stateType = /* @__PURE__ */ __name((path2) => {
-  const [exists, value] = _getValue(path2);
-  if (!exists || value === void 0) return "undefined";
-  return Array.isArray(value) ? "array" : typeof value;
-}, "stateType");
-var stateGet = /* @__PURE__ */ __name((path2) => {
-  const [exists, value] = _getValue(path2);
-  if (!exists || value === void 0) return void 0;
-  return _clone2(value);
-}, "stateGet");
-var stateSchema = /* @__PURE__ */ __name(() => {
-  const result = [];
-  const _walk = /* @__PURE__ */ __name((obj, prefix) => {
-    if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
-      return;
-    }
-    const keys = Object.keys(obj).filter(
-      (k) => !["list", "remove", "removeAll", "lock", "unlock"].includes(k)
-    );
-    for (const key of keys) {
+}
+__name(_clone, "_clone");
+var snapshot = /* @__PURE__ */ __name(() => {
+  return deepRaw(state2, /* @__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(state2), "");
-  return result;
-}, "stateSchema");
-function _getValue(path2) {
-  if (!path2 || typeof path2 !== "string") return [false, void 0];
-  const parts = path2.replace(/^state\./, "").split(".");
+  _walk(snap, deepRaw(state2), "");
+  return changes;
+}, "diff");
+var enableHistory = /* @__PURE__ */ __name((enabled = true) => {
+  internal_default.historyEnabled = enabled;
+  message_default(`[memorio history] Tracking ${enabled ? "enabled" : "disabled"}`);
+}, "enableHistory");
+var trace = /* @__PURE__ */ __name(() => {
+  return [...internal_default.mutations];
+}, "trace");
+var canUndo = /* @__PURE__ */ __name(() => {
+  return internal_default.canUndo();
+}, "canUndo");
+var canRedo = /* @__PURE__ */ __name(() => {
+  return internal_default.canRedo();
+}, "canRedo");
+var undo = /* @__PURE__ */ __name(() => {
+  if (!internal_default.historyEnabled) {
+    message_default("[memorio history] History is not enabled");
+    return void 0;
+  }
+  const record = internal_default.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 (!internal_default.historyEnabled) {
+    message_default("[memorio history] History is not enabled");
+    return void 0;
+  }
+  const record = internal_default.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 = internal_default.historyEnabled;
+  internal_default.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 {
+    internal_default.historyEnabled = wasEnabled;
+  }
+}
+__name(_applyInverse2, "_applyInverse");
+function _applyForward(record) {
+  const wasEnabled = internal_default.historyEnabled;
+  internal_default.historyEnabled = false;
+  try {
+    if (record.action === "set") {
+      _setPath2(record.path, record.newValue);
+    } else if (record.action === "delete") {
+      _deletePath2(record.path);
+    }
+  } finally {
+    internal_default.historyEnabled = wasEnabled;
+  }
+}
+__name(_applyForward, "_applyForward");
+function _setPath2(path2, value) {
+  const parts = path2.split(".");
   let current = state2;
-  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 (DEV) console.warn("[memorio inspect] deep clone failed:", err);
-    return value;
+__name(_setPath2, "_setPath");
+function _deletePath2(path2) {
+  const parts = path2.split(".");
+  if (parts.length === 1) {
+    state2.remove(parts[0]);
+    return;
+  }
+  let current = state2;
+  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) => {
+  state2.removeAll();
+  for (const key of Object.keys(snap)) {
+    state2[key] = _clone(snap[key]);
+  }
+  internal_default.clearHistory();
+  message_default("[memorio history] State rolled back to snapshot");
+}, "rollback");
+var clearHistory2 = /* @__PURE__ */ __name(() => {
+  internal_default.clearHistory();
+  message_default("[memorio history] History cleared");
+}, "clearHistory");
+var clearRedo = /* @__PURE__ */ __name(() => {
+  internal_default.clearRedo();
+}, "clearRedo");
 
 // core/global.ts
 if (!("memorio" in globalThis)) {
@@ -4315,6 +5535,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?.());
   }
@@ -4328,16 +5568,18 @@ if (!("memorio" in globalThis)) {
     }
   );
   memorio.memory = memory;
+  memorio.encryption = 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(() => internal_default.currentContext, "value") });
   memorio.registerSchema = schema.register;
@@ -4345,6 +5587,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;
@@ -4356,10 +5601,17 @@ if (!("memorio" in globalThis)) {
   memorio.enableHistory = enableHistory;
   memorio.clearHistory = clearHistory2;
   memorio.clearRedo = clearRedo;
+  memorio.mutate = mutate;
+  memorio.createMutation = createMutation;
+  memorio.recordMutation = recordMutation;
+  memorio.toPatch = toPatch;
+  memorio.transaction = beginTransaction;
+  memorio.commitTransaction = commitTransaction;
+  memorio.abortTransaction = abortTransaction;
+  memorio.currentTransaction = currentTransaction;
   Object.defineProperty(memorio, "dispatch", { value: dispatch, writable: true, enumerable: false, configurable: true });
-  const isDev = DEV;
   memorio.env = {
-    isDev,
+    isDev: DEV,
     isProd: PROD
   };
   memorio.global = function() {
@@ -4371,153 +5623,39 @@ if (!("memorio" in globalThis)) {
       idb,
       sqlite,
       observer,
-      useObserver
+      useObserver,
+      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 (DEV) {
-    Object.defineProperty(
-      memorio,
-      "debug",
-      {
-        get: /* @__PURE__ */ __name(() => internal_default.debug, "get"),
-        set: /* @__PURE__ */ __name((v) => {
-          internal_default.debug = v;
-        }, "set"),
-        enumerable: false
-      }
-    );
-    const caps = getCapabilities();
-    Object.defineProperty(memorio, "_platform", { writable: false, enumerable: false, value: caps.platform });
-    Object.defineProperty(memorio, "_capabilities", { writable: false, enumerable: false, value: caps });
-    Object.defineProperty(memorio, "_sessionId", { writable: false, enumerable: false, value: generateSessionId() });
-    memorio.logger = logger;
-    if (!("$state" in globalThis)) Object.defineProperty(globalThis, "$state", { get: /* @__PURE__ */ __name(() => globalThis.state, "get"), configurable: true });
-    if (!("$store" in globalThis)) Object.defineProperty(globalThis, "$store", { get: /* @__PURE__ */ __name(() => globalThis.store, "get"), configurable: true });
-    if (!("$session" in globalThis)) Object.defineProperty(globalThis, "$session", { get: /* @__PURE__ */ __name(() => globalThis.session, "get"), configurable: true });
-    if (!("$cache" in globalThis)) Object.defineProperty(globalThis, "$cache", { get: /* @__PURE__ */ __name(() => globalThis.cache, "get"), configurable: true });
-    memorio.devtools = devtools;
-    memorio.inspect = stateKeys;
-    memorio.stateKeys = stateKeys;
-    memorio.pathExists = pathExists;
-    memorio.stateType = stateType;
-    memorio.stateGet = stateGet;
-    memorio.stateSchema = stateSchema;
-    memorio.help = function() {
-      console.debug(`
-\u{1F9E0} Memorio ${package_default.version} - Help
-
-Core Modules (runtime):
-  state     - Reactive state management (DEV global)
-  store     - Persistent storage (localStorage/Map)
-  session   - Session storage (sessionStorage/Map)
-  cache     - In-memory cache
-  idb       - IndexedDB (browser only)
-  sqlite    - SQLite in browser (sql.js, optional)
-
-Platform Detection:
-  memorio.isBrowser()    - Browser environment
-  memorio.isNode()       - Node.js environment
-  memorio.isDeno()       - Deno environment
-  memorio.isEdge()       - Edge/Worker environment
-  memorio.getCapabilities() - Full capabilities object
-
-Context Management:
-  memorio.isolate(name)   - Create isolated context
-  memorio.listContexts()  - List all contexts
-  memorio.deleteContext(id) - Delete a context
-
-Schema Validation (runtime):
-  memorio.registerSchema()  - Register a validator for a state path
-  memorio.validate()         - Manually validate a value
-  memorio.unregisterSchema() - Remove a registered schema
-  memorio.listSchemas()      - List all registered schema paths
-  memorio.typed<T>()         - Type-safe view of global state (compile-time only)
-
-History & Time Travel (runtime):
-  memorio.snapshot()         - Capture a deep snapshot of state
-  memorio.diff(snap)         - Diff snapshot against current state
-  memorio.undo() / redo()    - Undo / redo the last mutation
-  memorio.canUndo() / canRedo() - Check availability
-  memorio.rollback(snap)     - Restore state from a snapshot
-  memorio.trace()            - List all recorded mutations
-  memorio.enableHistory()    - Enable/disable mutation tracking
-  memorio.clearHistory()     - Clear undo/redo stacks and trace log
-
-DevTools (development-only):
-  memorio.devtools.inspect()   - Inspect all modules
-  memorio.devtools.stats()     - Show statistics
-  memorio.devtools.watch()     - Watch a path
-  memorio.devtools.exportData() - Export as JSON
-  memorio.devtools.importData() - Import from JSON
-  memorio.devtools.clear()     - Clear specific module
-  memorio.devtools.clearAll()  - Clear all modules
-
-Introspection (development-only):
-  memorio.stateKeys()        - List top-level state keys
-  memorio.pathExists(path)   - Check if a state path exists
-  memorio.stateType(path)    - Get runtime type of a state value
-  memorio.stateGet(path)     - Get a deep-cloned value at a path
-  memorio.stateSchema()      - Get a schema report of all state paths
-
-Debug:
-  memorio.debug = true       - Enable debug output (DEV only)
-
-Memory System (runtime):
-  memorio.memory.remember(key, value, opts) - Store a memory with type, confidence, scope, TTL, tags
-  memorio.memory.recall(key, opts)          - Retrieve a memory with filtering
-  memorio.memory.update(key, value, opts)   - Update an existing memory
-  memorio.memory.forget(key)                 - Delete a specific memory
-  memorio.memory.context(opts)              - Get ranked relevant memories (semantic context for AI)
-  memorio.memory.stats()                     - Memory usage statistics
-  memorio.memory.forgetExpired()              - Remove all expired entries
-  memorio.memory.clear()                      - Wipe all memories
-  memorio.memory.configure({ sync })          - Optional cloud-sync provider + namespace
-  memorio.memory.journal.pending()            - Local op journal (SQLite/store)
-
-Scopes:
-  hot      - In-memory reactive state (volatile, fastest)
-  session  - sessionStorage (persists across page reloads, cleared on tab close)
-  local    - localStorage (persistent, survives browser restart)
-  durable  - IndexedDB (large datasets, async)
-  sql      - SQLite / sql.js (browser, optional, full SQL)
-
-TTL options:
-  ttl: number (milliseconds) or null (never expires)
-
-Memory types:
-  fact, preference, decision, task, context
-
-  Console shortcuts (DEV only):
-  state, store, session, cache, idb, sqlite - direct access to modules
-  $state, $store, $session, $cache - aliases for the above
-  `);
-    };
-  }
 }
 
 // index.ts
-var devtools2 = DEV ? devtools : void 0;
+var transaction = beginTransaction;
+var devtools = void 0;
 var memorio2 = globalThis.memorio;
 var events = globalThis.events;
 var isolate = /* @__PURE__ */ __name((name) => createContext(name), "isolate");
-var help2 = globalThis.memorio?.help;
+var help = globalThis.memorio?.help;
 var setContext = /* @__PURE__ */ __name((id) => internal_default.currentContext = id, "setContext");
 var getContext = /* @__PURE__ */ __name(() => internal_default.currentContext, "getContext");
 var index_default = memorio2;
 
-export { DEV, PROD, cache, canRedo, canUndo, clearHistory2 as clearHistory, clearRedo, createContext, index_default as default, deleteContext, devtools2 as devtools, diff, dispatch, enableHistory, events, fractional, getCapabilities, getContext, help2 as help, hlc, idb, internal_default as internal, isBrowser, isDeno, isEdge, isNode, isolate, listContexts, listSchemas, logger, memorio2 as memorio, memory, message, observer, propertyName, redo, registerSchema, rollback, schema, session, setContext, snapshot, sqlite, state2 as state, store, trace, typed, undo, unregisterSchema, useObserver, validate };
+export { DEV, PROD, abortTransaction, activeTransactionId, beginTransaction, broadcast, cache, canMerge, canRedo, canUndo, clearHistory2 as clearHistory, clearRedo, commitTransaction, computed, createContext, createMutation, currentTimestamp, currentTransaction, index_default as default, deleteContext, devtools, diff, diffToPatch, dispatch, enableHistory, encryption, events, fractional, generateCommitId, generateMutationId, generateTransactionId, getCapabilities, getContext, help, hlc, idb, internal_default as internal, isBrowser, isBun, isDeno, isEdge, isNode, isolate, listContexts, listSchemas, listTransactions, logger, memorio2 as memorio, memory, mergePatches, message, mutate, mutationToPatch, observer, propertyName, recordMutation, redo, registerSchema, rollback, schema, security, session, setContext, snapshot, sqlite, state2 as state, store, toPatch, trace, transaction, typed, undo, unregisterSchema, useObserver, validate };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map