memorio 5.0.0 → 5.1.1

package/index.cjs

@@ -8,6 +8,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // node_modules/tsup/assets/cjs_shims.js
 var init_cjs_shims = __esm({
@@ -208,6 +212,241 @@ var init_message = __esm({
   }
 });
 
+// functions/encryption/index.ts
+function _hasWebCrypto() {
+  const g3 = globalThis;
+  return typeof g3.crypto !== "undefined" && typeof g3.crypto.subtle !== "undefined" && typeof g3.crypto.subtle.encrypt === "function";
+}
+function _b64encode(buf) {
+  const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
+  if (typeof btoa === "function") {
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+    return btoa(binary);
+  }
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  return "";
+}
+function _b64decode(b64) {
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(b64, "base64"));
+  }
+  if (typeof atob === "function") {
+    const binary = atob(b64);
+    const out = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+    return out;
+  }
+  throw new Error("memorio encryption: no base64 decoder available");
+}
+function _isEncrypted(value) {
+  return typeof value === "object" && value !== null && value.__memorio_encrypted === true && typeof value.alg === "string";
+}
+var AES_GCM, PBKDF2_ITERATIONS; exports.encryption = void 0;
+var init_encryption = __esm({
+  "functions/encryption/index.ts"() {
+    init_cjs_shims();
+    init_env();
+    init_message();
+    __name(_hasWebCrypto, "_hasWebCrypto");
+    __name(_b64encode, "_b64encode");
+    __name(_b64decode, "_b64decode");
+    __name(_isEncrypted, "_isEncrypted");
+    AES_GCM = { name: "AES-GCM", length: 256 };
+    PBKDF2_ITERATIONS = 6e5;
+    exports.encryption = {
+      ///
+      // Capability detection
+      ///
+      isAvailable() {
+        return _hasWebCrypto();
+      },
+      ///
+      // Derive a CryptoKey from a password using PBKDF2.
+      //
+      // @param password The password string.
+      // @param salt     Salt (string or Uint8Array). Defaults to a static value.
+      // @param alg      'AES-GCM' (default) or 'AES-CBC'.
+      // @returns        A Promise<CryptoKey>.
+      ///
+      async deriveKey(password, salt, alg = "AES-GCM", iterations = PBKDF2_ITERATIONS) {
+        if (!_hasWebCrypto()) {
+          throw new Error("memorio encryption: Web Crypto API is not available in this environment");
+        }
+        const enc = new TextEncoder();
+        const saltBytes = typeof salt === "string" ? enc.encode(salt) : salt ?? enc.encode("memorio:salt");
+        const keyMaterial = await globalThis.crypto.subtle.importKey(
+          "raw",
+          enc.encode(password),
+          { name: "PBKDF2" },
+          false,
+          ["deriveKey"]
+        );
+        return globalThis.crypto.subtle.deriveKey(
+          { name: "PBKDF2", salt: saltBytes, iterations, hash: "SHA-256" },
+          keyMaterial,
+          { name: alg, length: 256 },
+          false,
+          ["encrypt", "decrypt"]
+        );
+      },
+      ///
+      // Generate a fresh random CryptoKey (AES-GCM, 256-bit).
+      ///
+      async generateKey(alg = "AES-GCM") {
+        if (!_hasWebCrypto()) {
+          throw new Error("memorio encryption: Web Crypto API is not available in this environment");
+        }
+        return globalThis.crypto.subtle.generateKey(
+          { name: alg, length: 256 },
+          true,
+          ["encrypt", "decrypt"]
+        );
+      },
+      ///
+      // Generate a random salt for PBKDF2 key derivation.
+      ///
+      generateSalt(bytes = 16) {
+        const arr = new Uint8Array(bytes);
+        globalThis.crypto?.getRandomValues?.(arr);
+        return _b64encode(arr);
+      },
+      ///
+      // Export a CryptoKey to portable base64 strings so it can be stored
+      // (e.g. in an httpOnly cookie) and re-imported later with importKey().
+      //
+      // @param cryptoKey A raw CryptoKey (not a password string).
+      // @returns         { key: string, iv: string } base64-encoded.
+      ///
+      async exportKey(cryptoKey) {
+        if (!_hasWebCrypto()) {
+          throw new Error("memorio encryption: Web Crypto API is not available in this environment");
+        }
+        const exported = await globalThis.crypto.subtle.exportKey("raw", cryptoKey);
+        return {
+          key: _b64encode(exported),
+          iv: ""
+        };
+      },
+      ///
+      // Import a CryptoKey from base64 strings produced by exportKey().
+      //
+      // @param keyData Base64-encoded raw key bytes.
+      // @param _ivData Ignored (kept for API compatibility with exportKey return).
+      // @returns       A Promise<CryptoKey>.
+      ///
+      async importKey(keyData, _ivData) {
+        if (!_hasWebCrypto()) {
+          throw new Error("memorio encryption: Web Crypto API is not available in this environment");
+        }
+        const keyBytes = _b64decode(keyData);
+        if (keyBytes.length !== 32) {
+          throw new Error(`memorio encryption: AES-256 key must be exactly 32 bytes, got ${keyBytes.length}`);
+        }
+        return globalThis.crypto.subtle.importKey(
+          "raw",
+          keyBytes,
+          AES_GCM,
+          true,
+          ["encrypt", "decrypt"]
+        );
+      },
+      ///
+      // Encrypt a JavaScript value.
+      //
+      // @param value The value to encrypt (any JSON-serializable object).
+      // @param key   A CryptoKey or a password string (password is derived via PBKDF2).
+      // @param keyId Optional label, stored in the envelope for key rotation.
+      // @returns     An EncryptedEnvelope object.
+      ///
+      async encrypt(value, key, keyId) {
+        const cryptoKey = typeof key === "string" ? await this.deriveKey(key, void 0, "AES-GCM") : key;
+        const data = new TextEncoder().encode(JSON.stringify(value));
+        const iv = new Uint8Array(12);
+        globalThis.crypto.getRandomValues(iv);
+        const ciphertext = await globalThis.crypto.subtle.encrypt(
+          { name: "AES-GCM", iv },
+          cryptoKey,
+          data
+        );
+        const envelope = {
+          __memorio_encrypted: true,
+          v: 1,
+          alg: "AES-GCM",
+          iv: _b64encode(iv),
+          data: _b64encode(ciphertext)
+        };
+        if (keyId) envelope.keyId = keyId;
+        if (exports.DEV) message_default(`encryption: encrypted value (alg=${envelope.alg})`);
+        return envelope;
+      },
+      ///
+      // Decrypt an EncryptedEnvelope.
+      //
+      // @param envelope The envelope object returned by encrypt().
+      // @param key      A CryptoKey or a password string.
+      // @returns        The original value (parsed from JSON).
+      ///
+      async decrypt(envelope, key) {
+        if (!_isEncrypted(envelope)) {
+          throw new Error("memorio encryption: value is not a valid encrypted envelope");
+        }
+        const cryptoKey = typeof key === "string" ? await this.deriveKey(key, void 0, "AES-GCM") : key;
+        const iv = _b64decode(envelope.iv);
+        const data = _b64decode(envelope.data);
+        const decrypted = await globalThis.crypto.subtle.decrypt(
+          { name: "AES-GCM", iv },
+          cryptoKey,
+          data
+        );
+        return JSON.parse(new TextDecoder().decode(new Uint8Array(decrypted)));
+      },
+      ///
+      // Convenience: encrypt with a password (derives the key internally).
+      // Returns a JSON string you can store anywhere.
+      ///
+      async encryptWithPassword(value, password, salt, keyId) {
+        const env = await this.encrypt(value, password, keyId);
+        return JSON.stringify(env);
+      },
+      ///
+      // Convenience: decrypt a JSON envelope string with a password.
+      ///
+      async decryptWithPassword(envelopeJson, password, _salt) {
+        const envelope = JSON.parse(envelopeJson);
+        return this.decrypt(envelope, password);
+      },
+      ///
+      // Type guard: check whether a value is an encrypted envelope.
+      ///
+      isEncrypted(value) {
+        return _isEncrypted(value);
+      },
+      ///
+      // Configure a default encryption key for auto-encrypt mode.
+      // When set on `store` or `session`, all writes are encrypted and all
+      // reads attempt decryption automatically.
+      ///
+      config(opts) {
+        if (opts.key !== void 0) this._defaultKey = opts.key;
+        if (opts.keyId !== void 0) this._defaultKeyId = opts.keyId;
+        return this;
+      },
+      ///
+      // Internal: resolve the configured default key.
+      ///
+      get _key() {
+        return this._defaultKey ?? null;
+      },
+      get _keyId() {
+        return this._defaultKeyId;
+      }
+    };
+  }
+});
+
 // core/platform.ts
 function generateSessionId() {
   const anyGlobal = globalThis;
@@ -222,6 +461,9 @@ function generateSessionId() {
   return `session_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
 }
 function detectPlatform() {
+  if (_isBun()) {
+    return "bun";
+  }
   const globalAny = globalThis;
   if (globalAny.Deno && globalAny.Deno.version) {
     return "deno";
@@ -237,6 +479,13 @@ function detectPlatform() {
   }
   return "unknown";
 }
+function _isBun() {
+  const globalAny = globalThis;
+  return typeof globalAny.Bun !== "undefined" && typeof globalAny.Bun.version === "string";
+}
+function isBun() {
+  return _isBun();
+}
 function isBrowser() {
   const platform = detectPlatform();
   return platform === "browser";
@@ -290,6 +539,9 @@ function hasSqlJs() {
   }
   return typeof anyGlobal.window !== "undefined";
 }
+function hasBunSqlite() {
+  return _isBun();
+}
 function hasDispatchEvent() {
   return typeof globalThis.dispatchEvent === "function";
 }
@@ -302,6 +554,7 @@ function getCapabilities() {
     hasLocalStorage: getLocalStorage() !== null,
     hasIndexedDB: hasIndexedDB(),
     hasSqlJs: hasSqlJs(),
+    hasBunSqlite: hasBunSqlite(),
     hasDispatchEvent: hasDispatchEvent(),
     hasNavigator: typeof navigator !== "undefined",
     hasProcess: typeof process !== "undefined",
@@ -361,8 +614,9 @@ function initializePlatform() {
     };
   }
 }
-function createContext(name) {
+function createContext(name, opts) {
   const contextId = name || `context_${generateSessionId()}`;
+  const encKey = opts?.encryptionKey;
   setCurrentContext(contextId);
   const contextStorage = {
     state: {},
@@ -371,10 +625,31 @@ function createContext(name) {
     cache: /* @__PURE__ */ new Map()
   };
   _contexts.set(contextId, contextStorage);
+  function _isEncrypted2(value) {
+    return exports.encryption.isEncrypted(value);
+  }
+  __name(_isEncrypted2, "_isEncrypted");
   return {
     id: contextId,
     state: contextStorage.state,
-    store: {
+    store: encKey ? {
+      get: /* @__PURE__ */ __name(async (key) => {
+        const data = contextStorage.store.get(key);
+        if (!data) return null;
+        const parsed = JSON.parse(data);
+        if (_isEncrypted2(parsed)) return exports.encryption.decrypt(parsed, encKey);
+        return parsed;
+      }, "get"),
+      set: /* @__PURE__ */ __name(async (key, value) => {
+        const env = await exports.encryption.encrypt(value, encKey);
+        contextStorage.store.set(key, JSON.stringify(env));
+      }, "set"),
+      remove: /* @__PURE__ */ __name((key) => contextStorage.store.delete(key), "remove"),
+      removeAll: /* @__PURE__ */ __name(() => contextStorage.store.clear(), "removeAll"),
+      clearAll: /* @__PURE__ */ __name(() => contextStorage.store.clear(), "clearAll"),
+      size: /* @__PURE__ */ __name(() => contextStorage.store.size, "size"),
+      isPersistent: false
+    } : {
       get: /* @__PURE__ */ __name((key) => {
         const data = contextStorage.store.get(key);
         return data ? JSON.parse(data) : null;
@@ -388,7 +663,24 @@ function createContext(name) {
       size: /* @__PURE__ */ __name(() => contextStorage.store.size, "size"),
       isPersistent: false
     },
-    session: {
+    session: encKey ? {
+      get: /* @__PURE__ */ __name(async (key) => {
+        const data = contextStorage.session.get(key);
+        if (!data) return null;
+        const parsed = JSON.parse(data);
+        if (_isEncrypted2(parsed)) return exports.encryption.decrypt(parsed, encKey);
+        return parsed;
+      }, "get"),
+      set: /* @__PURE__ */ __name(async (key, value) => {
+        const env = await exports.encryption.encrypt(value, encKey);
+        contextStorage.session.set(key, JSON.stringify(env));
+      }, "set"),
+      remove: /* @__PURE__ */ __name((key) => contextStorage.session.delete(key), "remove"),
+      removeAll: /* @__PURE__ */ __name(() => contextStorage.session.clear(), "removeAll"),
+      clearAll: /* @__PURE__ */ __name(() => contextStorage.session.clear(), "clearAll"),
+      size: /* @__PURE__ */ __name(() => contextStorage.session.size, "size"),
+      isPersistent: false
+    } : {
       get: /* @__PURE__ */ __name((key) => {
         const data = contextStorage.session.get(key);
         return data ? JSON.parse(data) : null;
@@ -408,7 +700,8 @@ function createContext(name) {
       remove: /* @__PURE__ */ __name((key) => contextStorage.cache.delete(key), "remove"),
       removeAll: /* @__PURE__ */ __name(() => contextStorage.cache.clear(), "removeAll"),
       clear: /* @__PURE__ */ __name(() => contextStorage.cache.clear(), "clear")
-    }
+    },
+    encryptionKey: encKey
   };
 }
 function listContexts() {
@@ -425,8 +718,11 @@ var init_platform = __esm({
   "core/platform.ts"() {
     init_cjs_shims();
     init_internal();
+    init_encryption();
     __name(generateSessionId, "generateSessionId");
     __name(detectPlatform, "detectPlatform");
+    __name(_isBun, "_isBun");
+    __name(isBun, "isBun");
     __name(isBrowser, "isBrowser");
     __name(isNode, "isNode");
     __name(isDeno, "isDeno");
@@ -435,6 +731,7 @@ var init_platform = __esm({
     __name(getLocalStorage, "getLocalStorage");
     __name(hasIndexedDB, "hasIndexedDB");
     __name(hasSqlJs, "hasSqlJs");
+    __name(hasBunSqlite, "hasBunSqlite");
     __name(hasDispatchEvent, "hasDispatchEvent");
     __name(getCapabilities, "getCapabilities");
     _eventListenerStorage = /* @__PURE__ */ new Map();
@@ -460,6 +757,9 @@ function _getFallbackStorage() {
   }
   return _fallbackStorageByContext.get(key);
 }
+function _isEncryptedEnvelope(value) {
+  return exports.encryption.isEncrypted(value);
+}
 function _getPrefix() {
   const contextName = exports.internal.currentContext || "";
   return contextName ? `${contextName}-` : `memorio_store_`;
@@ -496,17 +796,23 @@ function _remove(prefixedName) {
   }
   return false;
 }
-var _localStorage, _fallbackStorageByContext, _hasStorage, STORE_INSTANCE_KEY; exports.store = void 0;
+var _localStorage, _fallbackStorageByContext, _hasStorage, _encryptionKey, _onError, _maxObjectSize, _maxTotalSize, STORE_INSTANCE_KEY; exports.store = void 0;
 var init_store = __esm({
   "functions/store/index.ts"() {
     init_cjs_shims();
     init_platform();
     init_internal();
     init_message();
+    init_encryption();
     _localStorage = getLocalStorage();
     _fallbackStorageByContext = /* @__PURE__ */ new Map();
     __name(_getFallbackStorage, "_getFallbackStorage");
     _hasStorage = _localStorage !== null;
+    _encryptionKey = null;
+    _onError = null;
+    _maxObjectSize = 0;
+    _maxTotalSize = 0;
+    __name(_isEncryptedEnvelope, "_isEncryptedEnvelope");
     __name(_getPrefix, "_getPrefix");
     __name(_prefixKey, "_prefixKey");
     __name(_read, "_read");
@@ -523,16 +829,24 @@ var init_store = __esm({
           /**
            * Gets a value from storage.
            * @param name The key to retrieve.
-           * @returns The parsed value or null if not found.
+           * @param opts Optional { decrypt: key } to decrypt an encrypted envelope.
+           *              When no key is passed, encrypted envelopes are returned as-is.
+           *              If a default key was configured via store.config(), it is used automatically.
+           * @returns The parsed value, a Promise<parsed value> when decrypting, or null if not found.
            */
           get: {
-            value: /* @__PURE__ */ __name((name) => {
+            value: /* @__PURE__ */ __name((name, opts) => {
               if (!name) {
                 console.warn("[memorio store] store.get() called with empty or null key - returning null");
                 return null;
               }
               try {
-                return _read(_prefixKey(name));
+                const raw = _read(_prefixKey(name));
+                const key = opts?.decrypt ?? _encryptionKey;
+                if (key && _isEncryptedEnvelope(raw)) {
+                  return exports.encryption.decrypt(raw, key);
+                }
+                return raw;
               } catch (err) {
                 exports.message(`Error parsing store item '${name}': ${err}`);
               }
@@ -557,10 +871,13 @@ var init_store = __esm({
            * Sets a value in storage.
            * @param name The key to set.
            * @param value The value to store (objects, arrays, primitives).
-           * @returns true if written, false if the key was rejected.
+           * @param opts Optional { encrypt: key } to encrypt the value before storage.
+           *              If a default key was configured via store.config(), it is used automatically.
+           *              When encryption is used, returns a Promise<boolean>.
+           * @returns true if written, false if rejected or error.
            */
           set: {
-            value: /* @__PURE__ */ __name((name, value) => {
+            value: /* @__PURE__ */ __name((name, value, opts) => {
               if (!name) {
                 console.warn("[memorio store] store.set() called with empty or null key - write aborted");
                 return false;
@@ -572,15 +889,66 @@ var init_store = __esm({
                 exports.message("Storing functions is not secure and is blocked for safety.");
                 return false;
               }
+              if (_maxObjectSize > 0 || _maxTotalSize > 0) {
+                let serializedSize = 0;
+                try {
+                  serializedSize = new TextEncoder().encode(JSON.stringify(value)).length;
+                } catch {
+                  serializedSize = 0;
+                }
+                if (_maxObjectSize > 0 && serializedSize > _maxObjectSize) {
+                  const err = new Error(`Object size (${serializedSize} bytes) exceeds maxObjectSize (${_maxObjectSize} bytes)`);
+                  _onError?.(err, { operation: "set" });
+                  return false;
+                }
+                if (_maxTotalSize > 0) {
+                  const currentTotal = exports.store.size() * 1024;
+                  const existingItemSize = _hasStorage ? _localStorage.getItem(prefixedName)?.length ?? 0 : _getFallbackStorage().get(prefixedName)?.length ?? 0;
+                  const projected = currentTotal * 1024 - existingItemSize + serializedSize;
+                  if (projected > _maxTotalSize) {
+                    const err = new Error(`Total store size (${projected} bytes) exceeds maxTotalSize (${_maxTotalSize} bytes)`);
+                    _onError?.(err, { operation: "set" });
+                    return false;
+                  }
+                }
+              }
+              const key = opts?.encrypt ?? _encryptionKey;
+              if (key) {
+                return exports.encryption.encrypt(value, key).then((env) => {
+                  _write(prefixedName, env);
+                  return true;
+                }).catch((err) => {
+                  exports.message(`Error encrypting store item '${name}': ${err}`);
+                  _onError?.(err, { operation: "set" });
+                  return false;
+                });
+              }
               try {
                 _write(prefixedName, value);
               } catch (err) {
                 exports.message(`Error setting store item '${name}': ${err}`);
+                _onError?.(err, { operation: "set" });
                 return false;
               }
               return true;
             }, "value")
           },
+          /**
+           * Configure store-wide behavior.
+           * @param opts Optional { encryptionKey } to enable automatic encryption
+           *              for all set/get operations. When set, values are encrypted
+           *              on write and decrypted on read (if the value is an envelope).
+           * @returns The store instance for chaining.
+           */
+          config: {
+            value: /* @__PURE__ */ __name((opts) => {
+              if (opts.encryptionKey !== void 0) _encryptionKey = opts.encryptionKey;
+              if (opts.onError !== void 0) _onError = opts.onError;
+              if (opts.maxObjectSize !== void 0) _maxObjectSize = opts.maxObjectSize;
+              if (opts.maxTotalSize !== void 0) _maxTotalSize = opts.maxTotalSize;
+              return exports.store;
+            }, "value")
+          },
           /**
            * Removes a value from storage.
            * @param name The key to remove.
@@ -1166,6 +1534,91 @@ var init_idb = __esm({
   }
 });
 
+// functions/sqlite/tools/bun-sqlite-adapter.ts
+var bun_sqlite_adapter_exports = {};
+__export(bun_sqlite_adapter_exports, {
+  BunSqlJsDatabase: () => BunSqlJsDatabase,
+  createBunSqlJs: () => createBunSqlJs
+});
+async function _loadDatabase() {
+  if (!_DatabaseClass) {
+    const mod = await import('bun:sqlite');
+    _DatabaseClass = mod.Database;
+  }
+  return _DatabaseClass;
+}
+async function createBunSqlJs() {
+  await _loadDatabase();
+  return {
+    Database: BunSqlJsDatabase,
+    version: "bun:sqlite"
+  };
+}
+var _DatabaseClass, BunSqlJsDatabase;
+var init_bun_sqlite_adapter = __esm({
+  "functions/sqlite/tools/bun-sqlite-adapter.ts"() {
+    init_cjs_shims();
+    _DatabaseClass = null;
+    __name(_loadDatabase, "_loadDatabase");
+    BunSqlJsDatabase = class {
+      static {
+        __name(this, "BunSqlJsDatabase");
+      }
+      _db;
+      _lastRunChanges = 0;
+      constructor(data) {
+        this._lastRunChanges = 0;
+        if (typeof data === "string") {
+          this._db = new _DatabaseClass(data);
+        } else {
+          this._db = new _DatabaseClass(":memory:");
+        }
+      }
+      run(sql, params = []) {
+        const info = this._db.run(sql, ...params);
+        this._lastRunChanges = info?.changes ?? 0;
+        return info;
+      }
+      getRowsModified() {
+        return this._lastRunChanges;
+      }
+      prepare(sql, params = []) {
+        const rows = params.length > 0 ? this._db.query(sql).all(...params) : this._db.query(sql).all();
+        return {
+          _rows: rows,
+          _idx: -1,
+          step() {
+            this._idx++;
+            return this._idx < this._rows.length;
+          },
+          getAsObject() {
+            return this._rows[this._idx] || {};
+          },
+          get() {
+            return this._rows[this._idx] ? Object.values(this._rows[this._idx]) : [];
+          },
+          free() {
+            this._rows = null;
+          }
+        };
+      }
+      export() {
+        throw new Error("Bun:sqlite does not support in-memory export - use store/session for persistence, or use the sql.js backend for export/import operations");
+      }
+      close() {
+        try {
+          this._db.close();
+        } catch {
+        }
+      }
+      get version() {
+        return "bun:sqlite";
+      }
+    };
+    __name(createBunSqlJs, "createBunSqlJs");
+  }
+});
+
 // functions/sqlite/tools/db.support.ts
 var db_support_exports2 = {};
 function _inDocument() {
@@ -1226,11 +1679,18 @@ var init_db_support2 = __esm({
       return g3.initSqlJs || g3;
     }, "_loadSqlJsFromCdn");
     exports.sqlite.db.support = () => {
-      return hasSqlJs();
+      return hasSqlJs() || hasBunSqlite();
     };
     exports.sqlite.db.getSQL = async () => {
       if (_SQL) return _SQL;
       if (_loading) return _loading;
+      if (hasBunSqlite()) {
+        const { createBunSqlJs: createBunSqlJs2 } = await Promise.resolve().then(() => (init_bun_sqlite_adapter(), bun_sqlite_adapter_exports));
+        _SQL = await createBunSqlJs2();
+        globalThis.sqliteVersion = _SQL.version;
+        message_default("Memorio SQLite: bun:sqlite engine loaded");
+        return _SQL;
+      }
       const g3 = globalThis;
       const cfg = g3.sqliteConfig || {};
       const p = (async () => {
@@ -1257,7 +1717,7 @@ var init_db_support2 = __esm({
         } catch (_) {
         }
         try {
-          exports.sqlite._warning = "Memorio SQLite: sql.js could not be loaded. Install sql.js (npm i sql.js) and pass a loader via sqlite.config({ loader: () => <your sql.js import>() }).";
+          exports.sqlite._warning = "Memorio SQLite: sql.js could not be loaded. Install sql.js (npm i sql.js) and pass a loader via sqlite.config({ loader: () => import(<your sql.js import>()) }).";
         } catch (_) {
         }
         console.warn("Memorio SQLite: failed to load sql.js", err);
@@ -1280,7 +1740,7 @@ function _ns() {
 function _key(name) {
   return `memorio:sqlite:db:${_ns()}:${name}`;
 }
-function _b64encode(buf) {
+function _b64encode2(buf) {
   const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
   let binary = "";
   const len = bytes.byteLength;
@@ -1288,7 +1748,7 @@ function _b64encode(buf) {
   if (typeof btoa === "function") return btoa(binary);
   return typeof Buffer !== "undefined" ? Buffer.from(bytes).toString("base64") : "";
 }
-function _b64decode(b64) {
+function _b64decode2(b64) {
   if (typeof Buffer !== "undefined") {
     return new Uint8Array(Buffer.from(b64, "base64"));
   }
@@ -1310,7 +1770,7 @@ function saveSnapshot(name) {
     }
     try {
       const blob = db.export();
-      exports.store.set(_key(name), _b64encode(blob));
+      exports.store.set(_key(name), _b64encode2(blob));
       message_default(`Memorio SQLite: persisted '${name}' to store`);
       resolve(true);
     } catch (err) {
@@ -1323,7 +1783,7 @@ function loadSnapshot(name) {
   const b64 = exports.store.get(_key(name));
   if (!b64) return null;
   try {
-    return _b64decode(b64);
+    return _b64decode2(b64);
   } catch {
     return null;
   }
@@ -1358,8 +1818,8 @@ var init_persist = __esm({
     _exportTimers = {};
     __name(_ns, "_ns");
     __name(_key, "_key");
-    __name(_b64encode, "_b64encode");
-    __name(_b64decode, "_b64decode");
+    __name(_b64encode2, "_b64encode");
+    __name(_b64decode2, "_b64decode");
     __name(saveSnapshot, "saveSnapshot");
     __name(loadSnapshot, "loadSnapshot");
     __name(removeSnapshot, "removeSnapshot");
@@ -1564,7 +2024,14 @@ var init_db_export = __esm({
     init_sqlite();
     exports.sqlite.db.export = async (name = "memorio") => {
       const db = exports.sqlite.db.get(name);
-      return db.export();
+      try {
+        return db.export();
+      } catch (err) {
+        if (db && db.version === "bun:sqlite") {
+          throw new Error(`memorio sqlite: export is not supported under Bun's native sqlite. Use \`store\` or \`session\` for persistence instead. If you need a binary dump, run this code under the browser/sql.js backend.`);
+        }
+        throw err;
+      }
     };
   }
 });
@@ -1648,13 +2115,14 @@ var init_data_get2 = __esm({
 });
 
 // functions/sqlite/index.ts
-var _hasSqlJs; exports.sqlite = void 0;
+var _hasSqlJs, _hasBunSqlite; exports.sqlite = void 0;
 var init_sqlite = __esm({
   "functions/sqlite/index.ts"() {
     init_cjs_shims();
     init_platform();
     init_env();
     _hasSqlJs = hasSqlJs();
+    _hasBunSqlite = hasBunSqlite();
     exports.sqlite = {
       db: {},
       query: {},
@@ -1681,7 +2149,7 @@ var init_sqlite = __esm({
         return g3.sqliteReady;
       }, "get")
     });
-    if (_hasSqlJs) {
+    if (_hasSqlJs || _hasBunSqlite) {
       (async () => {
         Object.defineProperty(exports.sqlite, "db", { value: {}, writable: false, configurable: true, enumerable: true });
         Object.defineProperty(exports.sqlite, "query", { value: {}, writable: false, configurable: true, enumerable: true });
@@ -1709,11 +2177,11 @@ var init_sqlite = __esm({
       })();
     } else {
       exports.sqlite._disabled = true;
-      exports.sqlite._warning = 'SQLite (sql.js) is not available in this environment. It requires a browser with WebAssembly support. Install the optional "sql.js" package to enable it.';
+      exports.sqlite._warning = 'SQLite is not available in this environment. It requires a browser with WebAssembly (sql.js) or the Bun runtime (bun:sqlite). Install the optional "sql.js" package to enable it in browsers.';
       if (exports.DEV) {
         globalThis.sqliteDisabled = true;
         globalThis.sqliteWarning = exports.sqlite._warning;
-        console.warn("Memorio SQLite: sql.js is not available in this environment (requires browser + WebAssembly). Use store or session for persistence.");
+        console.warn("Memorio SQLite: no engine available in this environment (requires browser + WebAssembly, or Bun runtime with bun:sqlite). Use store or session for persistence.");
       }
     }
   }
@@ -2725,6 +3193,7 @@ init_cjs_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 exports.encryption.isEncrypted(value);
+}
+__name(_isEncryptedEnvelope2, "_isEncryptedEnvelope");
 function _getPrefix2() {
   const contextName = exports.internal.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 exports.encryption.decrypt(raw, key);
+            }
+            return raw;
           } catch (err) {
             exports.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]) {
             exports.message("It's not secure to session functions.");
             return false;
           }
+          if (_maxObjectSize2 > 0 || _maxTotalSize2 > 0) {
+            let serializedSize = 0;
+            try {
+              serializedSize = new TextEncoder().encode(JSON.stringify(value)).length;
+            } catch {
+              serializedSize = 0;
+            }
+            if (_maxObjectSize2 > 0 && serializedSize > _maxObjectSize2) {
+              const err = new Error(`Object size (${serializedSize} bytes) exceeds maxObjectSize (${_maxObjectSize2} bytes)`);
+              _onError2?.(err, { operation: "set" });
+              return false;
+            }
+            if (_maxTotalSize2 > 0) {
+              const currentTotal = exports.session.size() * 1024;
+              const existingItemSize = _sessionStorage ? _sessionStorage.getItem(prefixedName)?.length ?? 0 : _getFallbackStorage2().get(prefixedName)?.length ?? 0;
+              const projected = currentTotal - existingItemSize + serializedSize;
+              if (projected > _maxTotalSize2) {
+                const err = new Error(`Total session size (${projected} bytes) exceeds maxTotalSize (${_maxTotalSize2} bytes)`);
+                _onError2?.(err, { operation: "set" });
+                return false;
+              }
+            }
+          }
+          const key = opts?.encrypt ?? _encryptionKey2;
+          if (key) {
+            return exports.encryption.encrypt(value, key).then((env) => {
+              _write2(prefixedName, env);
+              return true;
+            }).catch((err) => {
+              exports.message(`Error encrypting session item '${name}': ${err}`);
+              _onError2?.(err, { operation: "set" });
+              return false;
+            });
+          }
           try {
             _write2(prefixedName, value);
           } catch (err) {
             exports.message(`Error setting session item '${name}': ${err}`);
+            _onError2?.(err, { operation: "set" });
             return false;
           }
           return true;
         }, "value")
       },
+      /**
+       * Configure session-wide behavior.
+       * @param opts { encryptionKey, onError, maxObjectSize, maxTotalSize }
+       */
+      config: {
+        value: /* @__PURE__ */ __name((opts) => {
+          if (opts.encryptionKey !== void 0) _encryptionKey2 = opts.encryptionKey;
+          if (opts.onError !== void 0) _onError2 = opts.onError;
+          if (opts.maxObjectSize !== void 0) _maxObjectSize2 = opts.maxObjectSize;
+          if (opts.maxTotalSize !== void 0) _maxTotalSize2 = opts.maxTotalSize;
+          return exports.session;
+        }, "value")
+      },
       /**
        * Removes a value from storage.
        * @param name The key to remove.
@@ -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_cjs_shims();
-init_internal();
-init_message();
 init_env();
-var defaultConfig = {
-  enabled: true,
-  logToConsole: true,
-  modules: ["state", "store", "session", "cache", "idb"],
-  maxEntries: 1e3
-};
-function isDebugEnabled() {
-  return exports.DEV && exports.internal.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 (exports.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, path, value, previousValue) => {
-  if (!isEnabled(module)) return;
-  const entry = {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    module,
-    action,
-    path,
-    value,
-    previousValue
-  };
-  logHistory.push(entry);
-  if (logHistory.length > config.maxEntries) {
-    logHistory.shift();
+__name(_invalidate, "_invalidate");
+function _readStatePath(path) {
+  const entry = computedMap.get(path);
+  if (entry) {
+    return entry.lastValue;
   }
-  if (config.logToConsole && isDebugEnabled()) {
-    const prefix = `[Memorio:${module.toUpperCase()}]`;
-    const color = getModuleColor(module);
-    message_default(
-      `%c${prefix}%c ${action} ${path},
-      color: ${color}; font-weight: bold,
-      color: inherit`
-    );
-    if (value !== void 0) {
-      message_default(`  \u2192 value:${value}`);
+  const normalized = path.startsWith("state.") ? path : `state.${path}`;
+  const segments = normalized.replace(/^state\./, "").split(".");
+  let current = globalThis.state;
+  if (current) {
+    for (const seg of segments) {
+      if (current === null || current === void 0) break;
+      try {
+        current = current[seg];
+      } catch {
+        return void 0;
+      }
     }
-    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((path) => {
+    if (!path || typeof path !== "string") return void 0;
+    newDeps.add(path);
+    return _readStatePath(path);
+  }, "trackerGet");
+  try {
+    return entry.selector(trackerGet);
+  } catch (err) {
+    if (exports.DEV) console.error("[memorio computed] selector error:", err);
+    message_default(`[memorio computed] selector error: ${err}`);
+    return entry.lastValue;
+  }
+}
+__name(_recompute, "_recompute");
+function _setupDeps(key, entry, deps) {
+  for (const off of entry._dispatchUnsubscribers) off();
+  entry._dispatchUnsubscribers = [];
+  for (const dep of deps) {
+    if (computedMap.has(dep)) {
+      const computedEvent = "memorio:computed:" + dep;
+      const off = dispatch.listen(computedEvent, () => _invalidate(key));
+      if (off) entry._dispatchUnsubscribers.push(off);
+    } else {
+      const off = dispatch.listen(dep, () => _invalidate(key));
+      if (off) entry._dispatchUnsubscribers.push(off);
     }
   }
-  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((path) => {
+      newDeps2.add(path);
+      return _readStatePath(path);
+    }, "wrappedGet");
+    let newValue;
+    try {
+      newValue = selector(wrappedGet);
+    } catch (err) {
+      if (exports.DEV) console.error("[memorio computed] selector error:", err);
+      return entry2.lastValue;
+    }
+    if (entry2.equality(entry2.lastValue, newValue)) {
+      return entry2.lastValue;
+    }
+    entry2.lastValue = newValue;
+    _setupDeps(cacheKey, entry2, newDeps2);
+    for (const sub of entry2.subscribers) {
+      try {
+        sub(newValue);
+      } catch (err) {
+        if (exports.DEV) console.error("[memorio computed] subscriber error:", err);
+      }
+    }
+    return newValue;
+  }
+  const newDeps = /* @__PURE__ */ new Set();
+  const get = /* @__PURE__ */ __name((path) => {
+    newDeps.add(path);
+    return _readStatePath(path);
+  }, "get");
+  let lastValue;
+  try {
+    lastValue = selector(get);
+  } catch (err) {
+    if (exports.DEV) console.error("[memorio computed] selector error:", err);
+    message_default(`[memorio computed] selector error: ${err}`);
+    lastValue = null;
   }
-}, "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 (exports.DEV) console.warn(`[memorio computed] subscribe: no computed value registered for key '${key}'`);
+    return () => {
+    };
+  }
+  entry.subscribers.add(cb);
+  return () => {
+    entry.subscribers.delete(cb);
+  };
+}
+__name(_subscribe, "_subscribe");
+function _remove3(key) {
+  const normalizedKey = _normalizeKey(key);
+  if (!computedMap.has(normalizedKey)) return false;
+  const entry = computedMap.get(normalizedKey);
+  for (const off of entry._dispatchUnsubscribers) off();
+  computedMap.delete(normalizedKey);
+  return true;
+}
+__name(_remove3, "_remove");
+function _list() {
+  return Array.from(computedMap.keys());
+}
+__name(_list, "_list");
+function _clear() {
+  for (const [, entry] of computedMap) {
+    for (const off of entry._dispatchUnsubscribers) off();
+  }
+  computedMap.clear();
+}
+__name(_clear, "_clear");
+var computed = {
+  compute: _compute,
+  getValue: _getValue,
+  subscribe: _subscribe,
+  remove: _remove3,
+  list: _list,
+  clear: _clear
+};
+
+// functions/broadcast/index.ts
+init_cjs_shims();
+init_env();
+init_message();
+var _channel = null;
+var _storageListener = null;
+var _originalDispatchSet = null;
+var _installed = false;
+var _targets = "all";
+var _isLocalChange = false;
+function _hasBroadcastChannel() {
+  return typeof BroadcastChannel !== "undefined";
+}
+__name(_hasBroadcastChannel, "_hasBroadcastChannel");
+function _hasStorageEvents() {
+  return typeof window !== "undefined" && "addEventListener" in window;
+}
+__name(_hasStorageEvents, "_hasStorageEvents");
+function _shouldSync(target) {
+  if (_targets === "all") return true;
+  return _targets === target;
+}
+__name(_shouldSync, "_shouldSync");
+function _onBroadcastMessage(event) {
+  let msg;
+  try {
+    msg = event.data;
+  } catch {
+    return;
+  }
+  if (!msg || !msg.__memorio_sync) return;
+  if (!_shouldSync(msg.target)) return;
+  if (_isLocalChange) return;
+  try {
+    if (msg.target === "state" || msg.target === "all") {
+      const s = globalThis.state;
+      if (s) {
+        _isLocalChange = true;
+        try {
+          const segments = msg.path.replace(/^state\./, "").split(".");
+          let current = s;
+          for (let i = 0; i < segments.length - 1; i++) {
+            const seg = segments[i];
+            if (current[seg] === void 0 || current[seg] === null) {
+              current[seg] = {};
+            }
+            current = current[seg];
+          }
+          const lastSeg = segments[segments.length - 1];
+          if (msg.action === "set") {
+            current[lastSeg] = msg.value;
+          } else if (msg.action === "delete") {
+            delete current[lastSeg];
+          }
+        } finally {
+          queueMicrotask(() => {
+            _isLocalChange = false;
+          });
+        }
+      }
+    }
+  } catch (err) {
+    if (exports.DEV) console.error("[memorio broadcast] apply state error:", err);
+  }
+}
+__name(_onBroadcastMessage, "_onBroadcastMessage");
+function _onStorageEvent(e) {
+  if (!e.key) return;
+  const prefixes = [
+    ["memorio_store_", "store"],
+    ["memorio_session_", "session"]
+  ];
+  for (const [prefix, target] of prefixes) {
+    if (e.key.startsWith(prefix)) {
+      if (!_shouldSync(target)) continue;
+      const cleanKey = e.key.slice(prefix.length);
+      dispatch.set(`memorio:broadcast:${target}:${cleanKey}`, {
+        detail: { key: cleanKey, oldValue: e.oldValue, newValue: e.newValue }
+      });
+      break;
+    }
+  }
+}
+__name(_onStorageEvent, "_onStorageEvent");
+function _wrapDispatchSet() {
+  if (_originalDispatchSet !== null) return;
+  _originalDispatchSet = dispatch.set;
+  const original = dispatch.set;
+  dispatch.set = (name, value) => {
+    original(name, value);
+    if (name.startsWith("state.") && _shouldSync("state") && _channel) {
+      _isLocalChange = true;
+      try {
+        _channel.postMessage({
+          __memorio_sync: true,
+          target: "state",
+          action: "set",
+          path: name,
+          value: _extractStateValue(name),
+          timestamp: Date.now()
+        });
+      } finally {
+        queueMicrotask(() => {
+          _isLocalChange = false;
+        });
+      }
+    }
+  };
+}
+__name(_wrapDispatchSet, "_wrapDispatchSet");
+function _restoreDispatchSet() {
+  if (_originalDispatchSet !== null) {
+    dispatch.set = _originalDispatchSet;
+    _originalDispatchSet = null;
+  }
+}
+__name(_restoreDispatchSet, "_restoreDispatchSet");
+function _extractStateValue(path) {
+  const s = globalThis.state;
+  if (!s) return void 0;
+  try {
+    const segments = path.replace(/^state\./, "").split(".");
+    let current = s;
+    for (const seg of segments) {
+      if (current === null || current === void 0) break;
+      current = current[seg];
+    }
+    return current === void 0 ? null : current;
+  } catch {
+    return null;
+  }
+}
+__name(_extractStateValue, "_extractStateValue");
+var broadcast = {
+  install: /* @__PURE__ */ __name((channelName, opts) => {
+    if (_installed) return;
+    const name = channelName || opts?.channelName || "memorio_sync";
+    _targets = opts?.targets || "all";
+    if (_hasBroadcastChannel()) {
+      _channel = new BroadcastChannel(name);
+      _channel.addEventListener("message", _onBroadcastMessage);
+      _installed = true;
+      _wrapDispatchSet();
+      if (exports.DEV) message_default(`memorio broadcast: installed (channel="${name}", targets="${_targets}")`);
+    }
+    if (_hasStorageEvents()) {
+      _storageListener = _onStorageEvent;
+      window.addEventListener("storage", _storageListener);
+      _installed = true;
+      if (!_hasBroadcastChannel() && exports.DEV) {
+        message_default(`memorio broadcast: using storage event fallback (targets="${_targets}")`);
+      }
+    }
+    if (!_installed) {
+      console.warn("[memorio broadcast] Neither BroadcastChannel nor storage events are available in this environment.");
+    }
+  }, "install"),
+  uninstall: /* @__PURE__ */ __name(() => {
+    if (_channel) {
+      _channel.removeEventListener("message", _onBroadcastMessage);
+      _channel.close();
+      _channel = null;
+    }
+    if (_storageListener && typeof window !== "undefined") {
+      window.removeEventListener("storage", _storageListener);
+      _storageListener = null;
+    }
+    _restoreDispatchSet();
+    _installed = false;
+  }, "uninstall"),
+  isInstalled: /* @__PURE__ */ __name(() => _installed, "isInstalled"),
+  broadcast: /* @__PURE__ */ __name((msg) => {
+    if (!_channel) return;
+    _channel.postMessage({ ...msg, timestamp: Date.now() });
+  }, "broadcast")
+};
+
+// functions/security/index.ts
+init_cjs_shims();
+init_env();
+function _safeRandomUUID() {
+  const g3 = globalThis;
+  if (typeof g3.crypto !== "undefined" && typeof g3.crypto.randomUUID === "function") {
+    try {
+      return g3.crypto.randomUUID();
+    } catch {
+    }
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+__name(_safeRandomUUID, "_safeRandomUUID");
+var REGEX_TIMEOUT_MS = 100;
+function _safeRegexTest(pattern, key) {
+  if (/\(.*[+*?].*.*\)[+*?]/.test(pattern)) {
+    if (exports.DEV) console.warn(`[memorio security] Potentially dangerous regex blocked: ${pattern}`);
+    return false;
+  }
+  if (pattern.length > 500) {
+    if (exports.DEV) console.warn("[memorio security] Regex pattern exceeds max length (500)");
+    return false;
+  }
+  const startTime = Date.now();
+  try {
+    const regex = new RegExp(pattern);
+    const result = regex.test(key);
+    const elapsed = Date.now() - startTime;
+    if (elapsed > REGEX_TIMEOUT_MS) {
+      if (exports.DEV) console.warn(`[memorio security] Slow regex detected (${elapsed}ms): ${pattern}`);
+    }
+    return result;
+  } catch {
+    return false;
+  }
+}
+__name(_safeRegexTest, "_safeRegexTest");
+function addAccessRule(rules, pattern, perms) {
+  const key = pattern instanceof RegExp ? pattern.source : pattern;
+  rules.set(key, perms);
+  return rules;
+}
+__name(addAccessRule, "addAccessRule");
+function hasPermission(rules, key, action, userId) {
+  if (rules.size === 0) return true;
+  for (const [pattern, perms] of rules) {
+    let matches;
+    if (typeof pattern === "function") {
+      try {
+        matches = pattern(key, userId);
+      } catch {
+        matches = false;
+      }
+    } else {
+      matches = _safeRegexTest(pattern, key);
+    }
+    if (matches) {
+      const allowed = perms.includes(action) || perms.includes("admin");
+      if (!allowed) {
+        logAudit({
+          action,
+          key,
+          userId,
+          success: false,
+          error: "RBAC Denied: insufficient permissions"
+        });
+      }
+      return allowed;
+    }
+  }
+  logAudit({
+    action: "permission_check",
+    key,
+    userId,
+    success: false,
+    error: "RBAC Denied: no matching rule"
+  });
+  return false;
+}
+__name(hasPermission, "hasPermission");
+var _auditLogger = null;
+function isAuditActive() {
+  return _auditLogger !== null;
+}
+__name(isAuditActive, "isAuditActive");
+function setAuditLogger(logger3) {
+  _auditLogger = logger3;
+}
+__name(setAuditLogger, "setAuditLogger");
+function logAudit(entry) {
+  if (!_auditLogger) return;
+  _auditLogger({
+    timestamp: Date.now(),
+    success: true,
+    ...entry
+  });
+}
+__name(logAudit, "logAudit");
+function sanitizeValue(value) {
+  if (typeof value === "string") {
+    let decoded = value.replace(/&#[xX]?[0-9a-fA-F]+;?/g, (match) => {
+      const hexMatch = match.match(/&#x([0-9a-fA-F]+);?/i);
+      if (hexMatch && hexMatch[1]) {
+        return String.fromCharCode(parseInt(hexMatch[1], 16));
+      }
+      const decMatch = match.match(/&#([0-9]+);?/);
+      if (decMatch && decMatch[1]) {
+        return String.fromCharCode(parseInt(decMatch[1], 10));
+      }
+      return match;
+    });
+    try {
+      decoded = decodeURIComponent(decoded);
+    } catch {
+    }
+    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_cjs_shims();
+init_internal();
+init_message();
+init_env();
+var defaultConfig = {
+  enabled: true,
+  logToConsole: true,
+  modules: ["state", "store", "session", "cache", "idb"],
+  maxEntries: 1e3
+};
+function isDebugEnabled() {
+  return exports.DEV && exports.internal.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, path, value, previousValue) => {
+  if (!isEnabled(module)) return;
+  const entry = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    module,
+    action,
+    path,
+    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} ${path},
+      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_cjs_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_cjs_shims();
-function typed() {
-  return exports.state;
-}
-__name(typed, "typed");
-
-// functions/history/index.ts
-init_cjs_shims();
-init_internal();
-init_env();
-init_message();
-function _clone(value) {
-  if (value === null || typeof value !== "object") return value;
-  try {
-    return deepRaw(value, /* @__PURE__ */ new WeakSet());
-  } catch (err) {
-    if (exports.DEV) console.warn("[memorio history] deep clone failed:", err);
-    return value;
-  }
-}
-__name(_clone, "_clone");
-var snapshot = /* @__PURE__ */ __name(() => {
-  return deepRaw(exports.state, /* @__PURE__ */ new WeakSet());
-}, "snapshot");
-var diff = /* @__PURE__ */ __name((snap) => {
-  const changes = [];
-  const _walk = /* @__PURE__ */ __name((oldObj, newObj, prefix) => {
-    const oldKeys = oldObj ? Object.keys(oldObj) : [];
-    const newKeys = newObj ? Object.keys(newObj) : [];
-    for (const key of newKeys) {
-      const newPath = prefix ? `${prefix}.${key}` : key;
-      const oldVal = oldObj ? oldObj[key] : void 0;
-      const newVal = newObj[key];
-      if (oldVal !== newVal) {
-        const oldType = typeof oldVal;
-        const newType = typeof newVal;
-        if (oldType !== newType || oldVal === void 0) {
-          changes.push({ path: newPath, oldValue: oldVal, newValue: newVal });
-        } else if (oldVal && typeof oldVal === "object") {
-          _walk(oldVal, newVal, newPath);
-        } else if (oldVal !== newVal) {
-          changes.push({ path: newPath, oldValue: oldVal, newValue: newVal });
-        }
-      }
-    }
-    for (const key of oldKeys) {
-      if (!(key in (newObj || {}))) {
-        const newPath = prefix ? `${prefix}.${key}` : key;
-        changes.push({ path: newPath, oldValue: oldObj[key], newValue: void 0 });
-      }
-    }
-  }, "_walk");
-  _walk(snap, deepRaw(exports.state), "");
-  return changes;
-}, "diff");
-var enableHistory = /* @__PURE__ */ __name((enabled = true) => {
-  exports.internal.historyEnabled = enabled;
-  message_default(`[memorio history] Tracking ${enabled ? "enabled" : "disabled"}`);
-}, "enableHistory");
-var trace = /* @__PURE__ */ __name(() => {
-  return [...exports.internal.mutations];
-}, "trace");
-var canUndo = /* @__PURE__ */ __name(() => {
-  return exports.internal.canUndo();
-}, "canUndo");
-var canRedo = /* @__PURE__ */ __name(() => {
-  return exports.internal.canRedo();
-}, "canRedo");
-var undo = /* @__PURE__ */ __name(() => {
-  if (!exports.internal.historyEnabled) {
-    message_default("[memorio history] History is not enabled");
-    return void 0;
-  }
-  const record = exports.internal.popUndo();
-  if (!record) return void 0;
-  _applyInverse2(record);
-  message_default(`[memorio history] Undid: ${record.action} ${record.path}`);
-  return record;
-}, "undo");
-var redo = /* @__PURE__ */ __name(() => {
-  if (!exports.internal.historyEnabled) {
-    message_default("[memorio history] History is not enabled");
-    return void 0;
-  }
-  const record = exports.internal.popRedo();
-  if (!record) return void 0;
-  _applyForward(record);
-  message_default(`[memorio history] Redid: ${record.action} ${record.path}`);
-  return record;
-}, "redo");
-function _applyInverse2(record) {
-  const wasEnabled = exports.internal.historyEnabled;
-  exports.internal.historyEnabled = false;
-  try {
-    if (record.action === "set") {
-      if (record.previousValue === void 0) {
-        _deletePath2(record.path);
-      } else {
-        _setPath2(record.path, record.previousValue);
-      }
-    } else if (record.action === "delete") {
-      if (record.previousValue !== void 0) {
-        _setPath2(record.path, record.previousValue);
-      }
-    }
-  } finally {
-    exports.internal.historyEnabled = wasEnabled;
-  }
-}
-__name(_applyInverse2, "_applyInverse");
-function _applyForward(record) {
-  const wasEnabled = exports.internal.historyEnabled;
-  exports.internal.historyEnabled = false;
-  try {
-    if (record.action === "set") {
-      _setPath2(record.path, record.newValue);
-    } else if (record.action === "delete") {
-      _deletePath2(record.path);
-    }
-  } finally {
-    exports.internal.historyEnabled = wasEnabled;
-  }
+  reordered.splice(toIndex, 0, removed);
+  return reordered.map((i) => i.key);
 }
-__name(_applyForward, "_applyForward");
-function _setPath2(path, value) {
-  const parts = path.split(".");
-  let current = exports.state;
-  for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i];
-    if (current[part] === void 0) {
-      current[part] = {};
+__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(path) {
-  const parts = path.split(".");
-  if (parts.length === 1) {
-    exports.state.remove(parts[0]);
-    return;
-  }
-  let current = exports.state;
-  for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i];
-    if (current[part] === void 0) return;
-    current = current[part];
-  }
-  delete current[parts[parts.length - 1]];
+__name(reindex, "reindex");
+var fractional = {
+  generateBetween,
+  firstKey,
+  after,
+  before,
+  between,
+  reorder,
+  reindex
+};
+
+// index.ts
+init_internal();
+init_platform();
+
+// core/global.ts
+init_cjs_shims();
+init_platform();
+init_internal();
+
+// package.json
+var package_default = {
+  version: "5.1.1"};
+
+// core/global.ts
+init_env();
+init_store();
+init_idb();
+init_sqlite();
+init_encryption();
+init_message();
+
+// functions/typed/index.ts
+init_cjs_shims();
+function typed() {
+  return exports.state;
 }
-__name(_deletePath2, "_deletePath");
-var rollback = /* @__PURE__ */ __name((snap) => {
-  exports.state.removeAll();
-  for (const key of Object.keys(snap)) {
-    exports.state[key] = _clone(snap[key]);
-  }
-  exports.internal.clearHistory();
-  message_default("[memorio history] State rolled back to snapshot");
-}, "rollback");
-var clearHistory2 = /* @__PURE__ */ __name(() => {
-  exports.internal.clearHistory();
-  message_default("[memorio history] History cleared");
-}, "clearHistory");
-var clearRedo = /* @__PURE__ */ __name(() => {
-  exports.internal.clearRedo();
-}, "clearRedo");
+__name(typed, "typed");
 
 // functions/memory/index.ts
 init_cjs_shims();
@@ -4379,6 +5343,168 @@ var memory = {
   }
 };
 
+// functions/history/index.ts
+init_cjs_shims();
+init_internal();
+init_env();
+init_message();
+function _clone(value) {
+  if (value === null || typeof value !== "object") return value;
+  try {
+    return deepRaw(value, /* @__PURE__ */ new WeakSet());
+  } catch (err) {
+    if (exports.DEV) console.warn("[memorio history] deep clone failed:", err);
+    return value;
+  }
+}
+__name(_clone, "_clone");
+var snapshot = /* @__PURE__ */ __name(() => {
+  return deepRaw(exports.state, /* @__PURE__ */ new WeakSet());
+}, "snapshot");
+var diff = /* @__PURE__ */ __name((snap) => {
+  const changes = [];
+  const _walk = /* @__PURE__ */ __name((oldObj, newObj, prefix) => {
+    const oldKeys = oldObj ? Object.keys(oldObj) : [];
+    const newKeys = newObj ? Object.keys(newObj) : [];
+    for (const key of newKeys) {
+      const newPath = prefix ? `${prefix}.${key}` : key;
+      const oldVal = oldObj ? oldObj[key] : void 0;
+      const newVal = newObj[key];
+      if (oldVal !== newVal) {
+        const oldType = typeof oldVal;
+        const newType = typeof newVal;
+        if (oldType !== newType || oldVal === void 0) {
+          changes.push({ path: newPath, oldValue: oldVal, newValue: newVal });
+        } else if (oldVal && typeof oldVal === "object") {
+          _walk(oldVal, newVal, newPath);
+        } else if (oldVal !== newVal) {
+          changes.push({ path: newPath, oldValue: oldVal, newValue: newVal });
+        }
+      }
+    }
+    for (const key of oldKeys) {
+      if (!(key in (newObj || {}))) {
+        const newPath = prefix ? `${prefix}.${key}` : key;
+        changes.push({ path: newPath, oldValue: oldObj[key], newValue: void 0 });
+      }
+    }
+  }, "_walk");
+  _walk(snap, deepRaw(exports.state), "");
+  return changes;
+}, "diff");
+var enableHistory = /* @__PURE__ */ __name((enabled = true) => {
+  exports.internal.historyEnabled = enabled;
+  message_default(`[memorio history] Tracking ${enabled ? "enabled" : "disabled"}`);
+}, "enableHistory");
+var trace = /* @__PURE__ */ __name(() => {
+  return [...exports.internal.mutations];
+}, "trace");
+var canUndo = /* @__PURE__ */ __name(() => {
+  return exports.internal.canUndo();
+}, "canUndo");
+var canRedo = /* @__PURE__ */ __name(() => {
+  return exports.internal.canRedo();
+}, "canRedo");
+var undo = /* @__PURE__ */ __name(() => {
+  if (!exports.internal.historyEnabled) {
+    message_default("[memorio history] History is not enabled");
+    return void 0;
+  }
+  const record = exports.internal.popUndo();
+  if (!record) return void 0;
+  _applyInverse2(record);
+  message_default(`[memorio history] Undid: ${record.action} ${record.path}`);
+  return record;
+}, "undo");
+var redo = /* @__PURE__ */ __name(() => {
+  if (!exports.internal.historyEnabled) {
+    message_default("[memorio history] History is not enabled");
+    return void 0;
+  }
+  const record = exports.internal.popRedo();
+  if (!record) return void 0;
+  _applyForward(record);
+  message_default(`[memorio history] Redid: ${record.action} ${record.path}`);
+  return record;
+}, "redo");
+function _applyInverse2(record) {
+  const wasEnabled = exports.internal.historyEnabled;
+  exports.internal.historyEnabled = false;
+  try {
+    if (record.action === "set") {
+      if (record.previousValue === void 0) {
+        _deletePath2(record.path);
+      } else {
+        _setPath2(record.path, record.previousValue);
+      }
+    } else if (record.action === "delete") {
+      if (record.previousValue !== void 0) {
+        _setPath2(record.path, record.previousValue);
+      }
+    }
+  } finally {
+    exports.internal.historyEnabled = wasEnabled;
+  }
+}
+__name(_applyInverse2, "_applyInverse");
+function _applyForward(record) {
+  const wasEnabled = exports.internal.historyEnabled;
+  exports.internal.historyEnabled = false;
+  try {
+    if (record.action === "set") {
+      _setPath2(record.path, record.newValue);
+    } else if (record.action === "delete") {
+      _deletePath2(record.path);
+    }
+  } finally {
+    exports.internal.historyEnabled = wasEnabled;
+  }
+}
+__name(_applyForward, "_applyForward");
+function _setPath2(path, value) {
+  const parts = path.split(".");
+  let current = exports.state;
+  for (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(path) {
+  const parts = path.split(".");
+  if (parts.length === 1) {
+    exports.state.remove(parts[0]);
+    return;
+  }
+  let current = exports.state;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === void 0) return;
+    current = current[part];
+  }
+  delete current[parts[parts.length - 1]];
+}
+__name(_deletePath2, "_deletePath");
+var rollback = /* @__PURE__ */ __name((snap) => {
+  exports.state.removeAll();
+  for (const key of Object.keys(snap)) {
+    exports.state[key] = _clone(snap[key]);
+  }
+  exports.internal.clearHistory();
+  message_default("[memorio history] State rolled back to snapshot");
+}, "rollback");
+var clearHistory2 = /* @__PURE__ */ __name(() => {
+  exports.internal.clearHistory();
+  message_default("[memorio history] History cleared");
+}, "clearHistory");
+var clearRedo = /* @__PURE__ */ __name(() => {
+  exports.internal.clearRedo();
+}, "clearRedo");
+
 // core/global.ts
 if (!("memorio" in globalThis)) {
   Object.defineProperty(
@@ -4445,16 +5571,18 @@ if (!("memorio" in globalThis)) {
     }
   );
   memorio.memory = memory;
+  memorio.encryption = exports.encryption;
   initializePlatform();
   memorio.isBrowser = isBrowser;
   memorio.isNode = isNode;
   memorio.isDeno = isDeno;
+  memorio.isBun = isBun;
   memorio.isEdge = isEdge;
   memorio.getCapabilities = getCapabilities;
   memorio.createContext = createContext;
   memorio.listContexts = listContexts;
   memorio.deleteContext = deleteContext;
-  memorio.isolate = (name) => createContext(name);
+  memorio.isolate = (name, opts) => createContext(name, opts);
   Object.defineProperty(memorio, "setContext", { writable: false, enumerable: false, value: /* @__PURE__ */ __name((id) => setCurrentContext(id), "value") });
   Object.defineProperty(memorio, "getContext", { writable: false, enumerable: false, value: /* @__PURE__ */ __name(() => exports.internal.currentContext, "value") });
   memorio.registerSchema = schema.register;
@@ -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: exports.idb,
       sqlite: exports.sqlite,
       observer,
-      useObserver
+      useObserver,
+      encryption: exports.encryption,
+      computed,
+      broadcast,
+      security
     };
     for (const key of Object.keys(globalDefinitions)) {
       if (!(key in globalThis)) {
@@ -4527,6 +5662,7 @@ var index_default = memorio2;
 exports.abortTransaction = abortTransaction;
 exports.activeTransactionId = activeTransactionId;
 exports.beginTransaction = beginTransaction;
+exports.broadcast = broadcast;
 exports.cache = cache;
 exports.canMerge = canMerge;
 exports.canRedo = canRedo;
@@ -4534,6 +5670,7 @@ exports.canUndo = canUndo;
 exports.clearHistory = clearHistory2;
 exports.clearRedo = clearRedo;
 exports.commitTransaction = commitTransaction;
+exports.computed = computed;
 exports.createContext = createContext;
 exports.createMutation = createMutation;
 exports.currentTimestamp = currentTimestamp;
@@ -4555,6 +5692,7 @@ exports.getContext = getContext;
 exports.help = help;
 exports.hlc = hlc;
 exports.isBrowser = isBrowser;
+exports.isBun = isBun;
 exports.isDeno = isDeno;
 exports.isEdge = isEdge;
 exports.isNode = isNode;
@@ -4574,6 +5712,7 @@ exports.redo = redo;
 exports.registerSchema = registerSchema;
 exports.rollback = rollback;
 exports.schema = schema;
+exports.security = security;
 exports.setContext = setContext;
 exports.snapshot = snapshot;
 exports.toPatch = toPatch;