memorio 5.0.0 → 5.1.0

package/global.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"() {
   }
@@ -205,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;
@@ -219,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";
@@ -234,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";
@@ -287,6 +536,9 @@ function hasSqlJs() {
   }
   return typeof anyGlobal.window !== "undefined";
 }
+function hasBunSqlite() {
+  return _isBun();
+}
 function hasDispatchEvent() {
   return typeof globalThis.dispatchEvent === "function";
 }
@@ -299,6 +551,7 @@ function getCapabilities() {
     hasLocalStorage: getLocalStorage() !== null,
     hasIndexedDB: hasIndexedDB(),
     hasSqlJs: hasSqlJs(),
+    hasBunSqlite: hasBunSqlite(),
     hasDispatchEvent: hasDispatchEvent(),
     hasNavigator: typeof navigator !== "undefined",
     hasProcess: typeof process !== "undefined",
@@ -358,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: {},
@@ -368,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;
@@ -385,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;
@@ -405,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() {
@@ -422,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");
@@ -432,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();
@@ -457,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_`;
@@ -493,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");
@@ -520,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}`);
               }
@@ -554,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;
@@ -569,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.
@@ -1163,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() {
@@ -1223,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 () => {
@@ -1254,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);
@@ -1277,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;
@@ -1285,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"));
   }
@@ -1307,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) {
@@ -1320,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;
   }
@@ -1355,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");
@@ -1561,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;
+      }
     };
   }
 });
@@ -1645,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: {},
@@ -1678,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 });
@@ -1706,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.");
       }
     }
   }
@@ -2725,6 +3193,7 @@ init_esm_shims();
 init_platform();
 init_internal();
 init_message();
+init_encryption();
 var _sessionStorage = getSessionStorage();
 var _fallbackStorageByContext2 = /* @__PURE__ */ new Map();
 function _getFallbackStorage2() {
@@ -2737,6 +3206,14 @@ function _getFallbackStorage2() {
 }
 __name(_getFallbackStorage2, "_getFallbackStorage");
 var _hasStorage2 = _sessionStorage !== null;
+var _encryptionKey2 = null;
+var _onError2 = null;
+var _maxObjectSize2 = 0;
+var _maxTotalSize2 = 0;
+function _isEncryptedEnvelope2(value) {
+  return encryption.isEncrypted(value);
+}
+__name(_isEncryptedEnvelope2, "_isEncryptedEnvelope");
 function _getPrefix2() {
   const contextName = internal_default.currentContext || "";
   return contextName ? `${contextName}-` : `memorio_session_`;
@@ -2790,16 +3267,22 @@ if (globalThis[SESSION_INSTANCE_KEY]) {
       /**
        * Gets a value from storage.
        * @param name The key to retrieve.
-       * @returns The parsed value or null if not found.
+       * @param opts Optional { decrypt: key } to decrypt an encrypted envelope.
+       * @returns The parsed value, a Promise when decrypting, or null if not found.
        */
       get: {
-        value: /* @__PURE__ */ __name((name) => {
+        value: /* @__PURE__ */ __name((name, opts) => {
           if (!name) {
             console.warn("[memorio session] session.get() called with empty or null key - returning null");
             return null;
           }
           try {
-            return _read2(_prefixKey2(name));
+            const raw = _read2(_prefixKey2(name));
+            const key = opts?.decrypt ?? _encryptionKey2;
+            if (key && _isEncryptedEnvelope2(raw)) {
+              return encryption.decrypt(raw, key);
+            }
+            return raw;
           } catch (err) {
             message(`Error parsing session item '${name}':${err}`);
           }
@@ -2810,10 +3293,11 @@ if (globalThis[SESSION_INSTANCE_KEY]) {
        * Sets a value in storage.
        * @param name The key to set.
        * @param value The value to store.
-       * @returns true if written, false if the key was rejected.
+       * @param opts Optional { encrypt: key } to encrypt before storage.
+       * @returns true if written, false if rejected. Returns a Promise when encrypting.
        */
       set: {
-        value: /* @__PURE__ */ __name((name, value) => {
+        value: /* @__PURE__ */ __name((name, value, opts) => {
           if (!name) {
             console.warn("[memorio session] session.set() called with empty or null key - write aborted");
             return false;
@@ -2825,15 +3309,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.
@@ -3200,92 +3732,685 @@ var useObserver = /* @__PURE__ */ __name(((func, deps = []) => {
 }), "useObserver");
 
 // index.ts
-init_message();
+init_encryption();
 
-// functions/logger/index.ts
+// functions/computed/index.ts
 init_esm_shims();
-init_internal();
-init_message();
 init_env();
-var defaultConfig = {
-  enabled: true,
-  logToConsole: true,
-  modules: ["state", "store", "session", "cache", "idb"],
-  maxEntries: 1e3
-};
-function isDebugEnabled() {
-  return DEV && internal_default.debug === true;
+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(isDebugEnabled, "isDebugEnabled");
-var config = { ...defaultConfig };
-var logHistory = [];
-var configure = /* @__PURE__ */ __name((options) => {
-  config = { ...config, ...options };
-}, "configure");
-var enable = /* @__PURE__ */ __name(() => {
-  config.enabled = true;
-}, "enable");
-var disable = /* @__PURE__ */ __name(() => {
-  config.enabled = false;
-}, "disable");
-var isEnabled = /* @__PURE__ */ __name((module) => {
-  return config.enabled && config.modules.includes(module);
-}, "isEnabled");
-var log = /* @__PURE__ */ __name((module, action, path2, value, previousValue) => {
-  if (!isEnabled(module)) return;
-  const entry = {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    module,
-    action,
-    path: path2,
-    value,
-    previousValue
-  };
-  logHistory.push(entry);
-  if (logHistory.length > config.maxEntries) {
-    logHistory.shift();
+__name(_invalidate, "_invalidate");
+function _readStatePath(path2) {
+  const entry = computedMap.get(path2);
+  if (entry) {
+    return entry.lastValue;
   }
-  if (config.logToConsole && isDebugEnabled()) {
-    const prefix = `[Memorio:${module.toUpperCase()}]`;
-    const color = getModuleColor(module);
-    message_default(
-      `%c${prefix}%c ${action} ${path2},
-      color: ${color}; font-weight: bold,
-      color: inherit`
-    );
-    if (value !== void 0) {
-      message_default(`  \u2192 value:${value}`);
+  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;
+      }
     }
-    if (previousValue !== void 0) {
-      message_default(`  \u2190 previous:${previousValue}`);
+  }
+  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);
     }
   }
-  if (config.customHandler) {
-    config.customHandler(entry);
+  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;
   }
-}, "log");
-var getModuleColor = /* @__PURE__ */ __name((module) => {
-  const colors = {
-    state: "#4CAF50",
-    store: "#2196F3",
-    session: "#FF9800",
-    cache: "#9C27B0",
-    idb: "#F44336"
+  const entry = {
+    selector,
+    lastValue,
+    deps: newDeps,
+    equality: opts?.equality || DEFAULT_EQUALITY,
+    subscribers: /* @__PURE__ */ new Set(),
+    _dispatchUnsubscribers: []
   };
-  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,
+  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 {
+    }
+    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;
+  }
+  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;
+    }
+  }
+  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();
+
+// functions/logger/index.ts
+init_esm_shims();
+init_internal();
+init_message();
+init_env();
+var defaultConfig = {
+  enabled: true,
+  logToConsole: true,
+  modules: ["state", "store", "session", "cache", "idb"],
+  maxEntries: 1e3
+};
+function isDebugEnabled() {
+  return DEV && internal_default.debug === true;
+}
+__name(isDebugEnabled, "isDebugEnabled");
+var config = { ...defaultConfig };
+var logHistory = [];
+var configure = /* @__PURE__ */ __name((options) => {
+  config = { ...config, ...options };
+}, "configure");
+var enable = /* @__PURE__ */ __name(() => {
+  config.enabled = true;
+}, "enable");
+var disable = /* @__PURE__ */ __name(() => {
+  config.enabled = false;
+}, "disable");
+var isEnabled = /* @__PURE__ */ __name((module) => {
+  return config.enabled && config.modules.includes(module);
+}, "isEnabled");
+var log = /* @__PURE__ */ __name((module, action, path2, value, previousValue) => {
+  if (!isEnabled(module)) return;
+  const entry = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    module,
+    action,
+    path: path2,
+    value,
+    previousValue
+  };
+  logHistory.push(entry);
+  if (logHistory.length > config.maxEntries) {
+    logHistory.shift();
+  }
+  if (config.logToConsole && isDebugEnabled()) {
+    const prefix = `[Memorio:${module.toUpperCase()}]`;
+    const color = getModuleColor(module);
+    message_default(
+      `%c${prefix}%c ${action} ${path2},
+      color: ${color}; font-weight: bold,
+      color: inherit`
+    );
+    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 stats = {
+    total: logHistory.length,
+    state: 0,
+    store: 0,
+    session: 0,
     cache: 0,
     idb: 0,
     set: 0,
@@ -3465,228 +4590,67 @@ function reorder(items, fromIndex, toIndex) {
   if (fromIndex === toIndex) return items.map((i) => i.key);
   const reordered = [...items];
   const [removed] = reordered.splice(fromIndex, 1);
-  reordered.splice(toIndex, 0, removed);
-  return reordered.map((i) => i.key);
-}
-__name(reorder, "reorder");
-function reindex(items) {
-  if (items.length === 0) return items;
-  const result = [];
-  let prev = null;
-  for (let i = 0; i < items.length; i++) {
-    const next = i < items.length - 1 ? items[i + 1].key : null;
-    const newItem = { ...items[i] };
-    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: "5.0.0"};
-
-// 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;
-  _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;
-  }
+  reordered.splice(toIndex, 0, removed);
+  return reordered.map((i) => i.key);
 }
-__name(_applyForward, "_applyForward");
-function _setPath2(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] = {};
+__name(reorder, "reorder");
+function reindex(items) {
+  if (items.length === 0) return items;
+  const result = [];
+  let prev = null;
+  for (let i = 0; i < items.length; i++) {
+    const next = i < items.length - 1 ? items[i + 1].key : null;
+    const newItem = { ...items[i] };
+    if (prev === null) {
+      newItem.key = before(items[0].key);
+    } else if (next === null) {
+      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(_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(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(_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");
+__name(typed, "typed");
 
 // functions/memory/index.ts
 init_esm_shims();
@@ -4379,6 +5343,168 @@ var memory = {
   }
 };
 
+// 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;
+  _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 (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(_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(_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)) {
   Object.defineProperty(
@@ -4445,16 +5571,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;
@@ -4462,6 +5590,9 @@ if (!("memorio" in globalThis)) {
   memorio.unregisterSchema = schema.unregister;
   memorio.listSchemas = schema.list;
   memorio.typed = typed;
+  memorio.computed = computed;
+  memorio.broadcast = broadcast;
+  memorio.security = security;
   memorio.snapshot = snapshot;
   memorio.diff = diff;
   memorio.undo = undo;
@@ -4495,7 +5626,11 @@ if (!("memorio" in globalThis)) {
       idb,
       sqlite,
       observer,
-      useObserver
+      useObserver,
+      encryption,
+      computed,
+      broadcast,
+      security
     };
     for (const key of Object.keys(globalDefinitions)) {
       if (!(key in globalThis)) {
@@ -4527,6 +5662,6 @@ var index_default = memorio2;
 // global.ts
 memorio2.global();
 
-export { DEV, PROD, abortTransaction, activeTransactionId, beginTransaction, cache, canMerge, canRedo, canUndo, clearHistory2 as clearHistory, clearRedo, commitTransaction, createContext, createMutation, currentTimestamp, currentTransaction, index_default as default, deleteContext, devtools, diff, diffToPatch, dispatch, enableHistory, events, fractional, generateCommitId, generateMutationId, generateTransactionId, getCapabilities, getContext, help, hlc, idb, internal_default as internal, isBrowser, isDeno, isEdge, isNode, isolate, listContexts, listSchemas, listTransactions, logger, memorio2 as memorio, memory, mergePatches, message, mutate, mutationToPatch, observer, propertyName, recordMutation, redo, registerSchema, rollback, schema, session, setContext, snapshot, sqlite, state2 as state, store, toPatch, trace, transaction, typed, undo, unregisterSchema, useObserver, validate };
+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=global.js.map
 //# sourceMappingURL=global.js.map