mindcache 2.4.1 → 3.2.0

package/dist/cloud/index.js

@@ -1,6 +1,37 @@
 'use strict';
 
-var zod = require('zod');
+var syncProtocol = require('y-protocols/sync');
+var encoding = require('lib0/encoding');
+var decoding = require('lib0/decoding');
+var Y = require('yjs');
+var yIndexeddb = require('y-indexeddb');
+var diff = require('fast-diff');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var syncProtocol__namespace = /*#__PURE__*/_interopNamespace(syncProtocol);
+var encoding__namespace = /*#__PURE__*/_interopNamespace(encoding);
+var decoding__namespace = /*#__PURE__*/_interopNamespace(decoding);
+var Y__namespace = /*#__PURE__*/_interopNamespace(Y);
+var diff__default = /*#__PURE__*/_interopDefault(diff);
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -181,7 +212,6 @@ var init_CloudAdapter = __esm({
         }
       }
       ws = null;
-      queue = [];
       mindcache = null;
       unsubscribe = null;
       reconnectAttempts = 0;
@@ -189,49 +219,29 @@ var init_CloudAdapter = __esm({
       _state = "disconnected";
       listeners = {};
       token = null;
-      /**
-       * Set auth token (short-lived, from /api/ws-token)
-       * Call this before connect() or use setTokenProvider for auto-refresh
-       */
       setToken(token) {
         this.token = token;
       }
-      /**
-       * Set a function that returns a fresh token
-       * Used for automatic token refresh on reconnect
-       */
       setTokenProvider(provider) {
         this.config.tokenProvider = provider;
       }
-      /**
-       * Get current connection state
-       */
       get state() {
         return this._state;
       }
-      /**
-       * Attach to a MindCache instance and start syncing
-       */
       attach(mc) {
         if (this.mindcache) {
           this.detach();
         }
         this.mindcache = mc;
-        const listener = () => {
-          if (mc.isRemoteUpdate()) {
-            console.log("\u2601\uFE0F CloudAdapter: Skipping remote update");
-            return;
+        mc.doc.on("update", (update, origin) => {
+          if (origin !== this && this.ws && this.ws.readyState === WebSocket.OPEN) {
+            const encoder = encoding__namespace.createEncoder();
+            syncProtocol__namespace.writeUpdate(encoder, update);
+            this.sendBinary(encoding__namespace.toUint8Array(encoder));
           }
-          console.log("\u2601\uFE0F CloudAdapter: Local change detected, syncing...");
-          this.syncLocalChanges();
-        };
-        mc.subscribeToAll(listener);
-        this.unsubscribe = () => mc.unsubscribeFromAll(listener);
+        });
         console.log("\u2601\uFE0F CloudAdapter: Attached to MindCache instance");
       }
-      /**
-       * Detach from the MindCache instance
-       */
       detach() {
         if (this.unsubscribe) {
           this.unsubscribe();
@@ -239,15 +249,6 @@ var init_CloudAdapter = __esm({
         }
         this.mindcache = null;
       }
-      /**
-       * Fetch a short-lived WebSocket token from the API using the API key.
-       * This keeps the API key secure by only using it for a single HTTPS request,
-       * then using the short-lived token for the WebSocket connection.
-       *
-       * Supports two key formats:
-       * - API keys: mc_live_xxx or mc_test_xxx → Bearer token
-       * - Delegate keys: del_xxx:sec_xxx → ApiKey format
-       */
       async fetchTokenWithApiKey() {
         if (!this.config.apiKey) {
           throw new Error("API key is required to fetch token");
@@ -273,9 +274,6 @@ var init_CloudAdapter = __esm({
         const data = await response.json();
         return data.token;
       }
-      /**
-       * Connect to the cloud service
-       */
       async connect() {
         if (this._state === "connecting" || this._state === "connected") {
           return;
@@ -297,6 +295,7 @@ var init_CloudAdapter = __esm({
             throw new Error("MindCache Cloud: No authentication method available. Provide apiKey or tokenProvider.");
           }
           this.ws = new WebSocket(url);
+          this.ws.binaryType = "arraybuffer";
           this.setupWebSocket();
         } catch (error) {
           this._state = "error";
@@ -304,9 +303,6 @@ var init_CloudAdapter = __esm({
           this.scheduleReconnect();
         }
       }
-      /**
-       * Disconnect from the cloud service
-       */
       disconnect() {
         if (this.reconnectTimeout) {
           clearTimeout(this.reconnectTimeout);
@@ -319,28 +315,12 @@ var init_CloudAdapter = __esm({
         this._state = "disconnected";
         this.emit("disconnected");
       }
-      /**
-       * Push an operation to the cloud
-       */
-      push(op) {
-        if (this.ws?.readyState === WebSocket.OPEN) {
-          this.ws.send(JSON.stringify(op));
-        } else {
-          this.queue.push(op);
-        }
-      }
-      /**
-       * Add event listener
-       */
       on(event, listener) {
         if (!this.listeners[event]) {
           this.listeners[event] = [];
         }
         this.listeners[event].push(listener);
       }
-      /**
-       * Remove event listener
-       */
       off(event, listener) {
         if (this.listeners[event]) {
           this.listeners[event] = this.listeners[event].filter((l) => l !== listener);
@@ -356,14 +336,38 @@ var init_CloudAdapter = __esm({
           return;
         }
         this.ws.onopen = () => {
+          if (this.mindcache) {
+            const encoder = encoding__namespace.createEncoder();
+            syncProtocol__namespace.writeSyncStep1(encoder, this.mindcache.doc);
+            this.sendBinary(encoding__namespace.toUint8Array(encoder));
+          }
         };
         this.ws.onmessage = (event) => {
           try {
-            const msg = JSON.parse(event.data);
-            this.handleMessage(msg);
+            if (typeof event.data === "string") {
+              const msg = JSON.parse(event.data);
+              if (msg.type === "auth_success") {
+                this._state = "connected";
+                this.reconnectAttempts = 0;
+                this.emit("connected");
+              } else if (msg.type === "auth_error" || msg.type === "error") {
+                this._state = "error";
+                this.emit("error", new Error(msg.error));
+              } else {
+                console.debug("MindCache Cloud: Received message type:", msg.type, msg);
+              }
+            } else {
+              const encoder = encoding__namespace.createEncoder();
+              const decoder = decoding__namespace.createDecoder(new Uint8Array(event.data));
+              if (this.mindcache) {
+                syncProtocol__namespace.readSyncMessage(decoder, encoder, this.mindcache.doc, this);
+                if (encoding__namespace.length(encoder) > 0) {
+                  this.sendBinary(encoding__namespace.toUint8Array(encoder));
+                }
+              }
+            }
           } catch (error) {
-            console.error("MindCache Cloud: Failed to parse message:", error);
-            console.error("Raw message:", typeof event.data === "string" ? event.data.slice(0, 200) : event.data);
+            console.error("MindCache Cloud: Failed to handle message:", error);
           }
         };
         this.ws.onclose = () => {
@@ -373,73 +377,12 @@ var init_CloudAdapter = __esm({
         };
         this.ws.onerror = () => {
           this._state = "error";
-          const url = `${this.config.baseUrl}/sync/${this.config.instanceId}`;
-          console.error(`MindCache Cloud: WebSocket error connecting to ${url}`);
-          console.error("Check that the instance ID and API key are correct, and that the server is reachable.");
-          this.emit("error", new Error(`WebSocket connection failed to ${url}`));
+          this.emit("error", new Error("WebSocket connection failed"));
         };
       }
-      handleMessage(msg) {
-        switch (msg.type) {
-          case "auth_success":
-            this._state = "connected";
-            this.reconnectAttempts = 0;
-            this.emit("connected");
-            this.flushQueue();
-            break;
-          case "auth_error":
-            this._state = "error";
-            this.emit("error", new Error(msg.error));
-            this.disconnect();
-            break;
-          case "sync":
-            if (this.mindcache && msg.data) {
-              Object.entries(msg.data).forEach(([key, entry]) => {
-                const { value, attributes } = entry;
-                this.mindcache._setFromRemote(key, value, attributes);
-              });
-              this.emit("synced");
-            }
-            break;
-          case "set":
-            if (this.mindcache) {
-              this.mindcache._setFromRemote(msg.key, msg.value, msg.attributes);
-            }
-            break;
-          case "key_updated":
-            if (this.mindcache) {
-              this.mindcache._setFromRemote(msg.key, msg.value, msg.attributes);
-            }
-            break;
-          case "delete":
-            if (this.mindcache) {
-              this.mindcache._deleteFromRemote(msg.key);
-            }
-            break;
-          case "key_deleted":
-            if (this.mindcache) {
-              this.mindcache._deleteFromRemote(msg.key);
-            }
-            break;
-          case "clear":
-            if (this.mindcache) {
-              this.mindcache._clearFromRemote();
-            }
-            break;
-          case "cleared":
-            if (this.mindcache) {
-              this.mindcache._clearFromRemote();
-            }
-            break;
-          case "error":
-            this.emit("error", new Error(msg.error));
-            break;
-        }
-      }
-      flushQueue() {
-        while (this.queue.length > 0 && this.ws?.readyState === WebSocket.OPEN) {
-          const op = this.queue.shift();
-          this.ws.send(JSON.stringify(op));
+      sendBinary(data) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+          this.ws.send(data);
         }
       }
       scheduleReconnect() {
@@ -456,23 +399,6 @@ var init_CloudAdapter = __esm({
           this.connect();
         }, delay);
       }
-      syncLocalChanges() {
-        if (!this.mindcache) {
-          return;
-        }
-        const entries = this.mindcache.serialize();
-        console.log("\u2601\uFE0F CloudAdapter: Syncing local changes:", Object.keys(entries));
-        Object.entries(entries).forEach(([key, entry]) => {
-          console.log("\u2601\uFE0F CloudAdapter: Pushing key:", key, "=", entry.value);
-          this.push({
-            type: "set",
-            key,
-            value: entry.value,
-            attributes: entry.attributes,
-            timestamp: Date.now()
-          });
-        });
-      }
     };
   }
 });
@@ -494,16 +420,18 @@ var DEFAULT_KEY_ATTRIBUTES = {
 
 // src/core/MindCache.ts
 var MindCache = class {
-  stm = {};
+  // Public doc for adapter access
+  doc;
+  rootMap;
+  // Key -> EntryMap({value, attributes})
+  // Cache listeners
   listeners = {};
   globalListeners = [];
+  // Metadata
+  version = "3.1.0";
   // Internal flag to prevent sync loops when receiving remote updates
+  // (Less critical with Yjs but kept for API compat)
   _isRemoteUpdate = false;
-  /**
-   * Normalize system tags: migrate old tags to new ones
-   * - 'prompt' → 'SystemPrompt'
-   * - 'readonly' → remove 'LLMWrite' (or add if not readonly)
-   */
   normalizeSystemTags(tags) {
     const normalized = [];
     let hasSystemPrompt = false;
@@ -535,29 +463,9 @@ var MindCache = class {
       normalized.push("readonly");
     } else if (hasLLMWrite) {
       normalized.push("LLMWrite");
-    } else {
-      normalized.push("LLMWrite");
     }
     return normalized;
   }
-  /**
-   * Check if key should be visible in system prompt
-   */
-  hasSystemPrompt(tags) {
-    return tags.includes("SystemPrompt") || tags.includes("prompt");
-  }
-  /**
-   * Check if key can be read by LLM (has LLMRead or SystemPrompt)
-   */
-  hasLLMRead(tags) {
-    return tags.includes("LLMRead") || tags.includes("SystemPrompt") || tags.includes("prompt");
-  }
-  /**
-   * Check if key can be written by LLM (has LLMWrite and not readonly)
-   */
-  hasLLMWrite(tags) {
-    return tags.includes("LLMWrite") && !tags.includes("readonly");
-  }
   // Cloud sync state
   _cloudAdapter = null;
   _connectionState = "disconnected";
@@ -567,25 +475,57 @@ var MindCache = class {
   // Access level for system operations
   _accessLevel = "user";
   _initPromise = null;
+  // Y-IndexedDB provider
+  _idbProvider = null;
+  // Undo Managers Cache
+  _undoManagers = /* @__PURE__ */ new Map();
+  // Global Undo Manager (watches entire rootMap)
+  _globalUndoManager = null;
+  // History tracking
+  _history = [];
+  _historyOptions = { maxEntries: 100, snapshotInterval: 10 };
+  _historyEnabled = false;
   constructor(options) {
+    this.doc = new Y__namespace.Doc();
+    this.rootMap = this.doc.getMap("mindcache");
+    this.rootMap.observe((event) => {
+      event.keysChanged.forEach((key) => {
+        const entryMap = this.rootMap.get(key);
+        if (entryMap) {
+          const value = entryMap.get("value");
+          if (this.listeners[key]) {
+            this.listeners[key].forEach((l) => l(value));
+          }
+        } else {
+          if (this.listeners[key]) {
+            this.listeners[key].forEach((l) => l(void 0));
+          }
+        }
+      });
+    });
+    this.rootMap.observeDeep((_events) => {
+      this.notifyGlobalListeners();
+    });
+    this.initGlobalUndoManager();
     if (options?.accessLevel) {
       this._accessLevel = options.accessLevel;
     }
-    if (options?.cloud && options?.indexedDB) {
-      throw new Error(
-        "MindCache: Cannot use both cloud and indexedDB together. Choose one persistence method to avoid data conflicts. Use cloud for real-time sync, or indexedDB for local-only persistence."
-      );
-    }
     const initPromises = [];
     if (options?.cloud) {
       this._cloudConfig = options.cloud;
       this._isLoaded = false;
       this._connectionState = "disconnected";
       initPromises.push(this._initCloud());
+      if (typeof window !== "undefined") {
+        const dbName = `mindcache_cloud_${options.cloud.instanceId}`;
+        initPromises.push(this._initYIndexedDB(dbName));
+      }
+      this.enableHistory(options.history);
     }
-    if (options?.indexedDB) {
+    if (options?.indexedDB && !options?.cloud) {
       this._isLoaded = false;
-      initPromises.push(this._initIndexedDB(options.indexedDB));
+      initPromises.push(this._initYIndexedDB(options.indexedDB.dbName || "mindcache_yjs_db"));
+      this.enableHistory(options.history);
     }
     if (initPromises.length > 0) {
       this._initPromise = Promise.all(initPromises).then(() => {
@@ -595,15 +535,147 @@ var MindCache = class {
       });
     }
   }
+  // Helper: Get or Create UndoManager for a key
+  getUndoManager(key) {
+    const entryMap = this.rootMap.get(key);
+    if (!entryMap) {
+      return void 0;
+    }
+    if (!this._undoManagers.has(key)) {
+      const um = new Y__namespace.UndoManager(entryMap, {
+        captureTimeout: 500
+      });
+      this._undoManagers.set(key, um);
+    }
+    return this._undoManagers.get(key);
+  }
   /**
-   * Get the current access level
+   * Undo changes for a specific key
    */
-  get accessLevel() {
-    return this._accessLevel;
+  undo(key) {
+    const um = this.getUndoManager(key);
+    if (um) {
+      um.undo();
+    }
+  }
+  /**
+   * Redo changes for a specific key
+   */
+  redo(key) {
+    const um = this.getUndoManager(key);
+    if (um) {
+      um.redo();
+    }
+  }
+  getHistory(key) {
+    const um = this.getUndoManager(key);
+    if (!um) {
+      return [];
+    }
+    return um.undoStack;
+  }
+  // Initialize global undo manager (watches entire rootMap)
+  initGlobalUndoManager() {
+    if (!this._globalUndoManager) {
+      this._globalUndoManager = new Y__namespace.UndoManager(this.rootMap, {
+        captureTimeout: 500
+      });
+    }
+  }
+  /**
+   * Undo all recent local changes (across all keys)
+   * Only undoes YOUR changes, not changes from other users in cloud mode
+   */
+  undoAll() {
+    this.initGlobalUndoManager();
+    this._globalUndoManager?.undo();
+  }
+  /**
+   * Redo previously undone local changes
+   */
+  redoAll() {
+    this.initGlobalUndoManager();
+    this._globalUndoManager?.redo();
+  }
+  /**
+   * Check if there are changes to undo globally
+   */
+  canUndoAll() {
+    this.initGlobalUndoManager();
+    return (this._globalUndoManager?.undoStack.length ?? 0) > 0;
+  }
+  /**
+   * Check if there are changes to redo globally
+   */
+  canRedoAll() {
+    this.initGlobalUndoManager();
+    return (this._globalUndoManager?.redoStack.length ?? 0) > 0;
+  }
+  // Enable history tracking (called for IndexedDB and Cloud modes)
+  enableHistory(options) {
+    if (this._historyEnabled) {
+      return;
+    }
+    this._historyEnabled = true;
+    if (options) {
+      this._historyOptions = { ...this._historyOptions, ...options };
+    }
+    this.rootMap.observeDeep((events) => {
+      const keysAffected = /* @__PURE__ */ new Set();
+      events.forEach((event) => {
+        if (event.target === this.rootMap) {
+          const mapEvent = event;
+          mapEvent.keysChanged.forEach((key) => keysAffected.add(key));
+        } else if (event.target.parent === this.rootMap) {
+          for (const [key, val] of this.rootMap) {
+            if (val === event.target) {
+              keysAffected.add(key);
+              break;
+            }
+          }
+        }
+      });
+      if (keysAffected.size > 0) {
+        const entry = {
+          id: this.generateId(),
+          timestamp: Date.now(),
+          keysAffected: Array.from(keysAffected)
+        };
+        this._history.push(entry);
+        const max = this._historyOptions.maxEntries || 100;
+        if (this._history.length > max) {
+          this._history = this._history.slice(-max);
+        }
+      }
+    });
+  }
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+  }
+  /**
+   * Get global history of all changes (available in IndexedDB and Cloud modes)
+   */
+  getGlobalHistory() {
+    return [...this._history];
   }
   /**
-   * Check if this instance has system-level access
+   * Check if history tracking is enabled
    */
+  get historyEnabled() {
+    return this._historyEnabled;
+  }
+  /**
+   * Restore to a specific version (time travel)
+   * Note: Full implementation requires storing update binaries, which is not yet implemented.
+   * @returns false - not yet fully implemented
+   */
+  restoreToVersion(_versionId) {
+    console.warn("restoreToVersion: Full implementation requires storing update binaries. Not yet implemented.");
+    return false;
+  }
+  get accessLevel() {
+    return this._accessLevel;
+  }
   get hasSystemAccess() {
     return this._accessLevel === "system";
   }
@@ -611,110 +683,94 @@ var MindCache = class {
     if (!this._cloudConfig) {
       return;
     }
-    try {
-      const CloudAdapter2 = await this._getCloudAdapterClass();
-      if (!this._cloudConfig.baseUrl) {
-        throw new Error("MindCache Cloud: baseUrl is required. Please provide the cloud API URL in your configuration.");
+    const CloudAdapter2 = await this._getCloudAdapterClass();
+    if (!this._cloudConfig.baseUrl) ;
+    const baseUrl = (this._cloudConfig.baseUrl || "https://api.mindcache.dev").replace("https://", "wss://").replace("http://", "ws://");
+    const adapter = new CloudAdapter2({
+      instanceId: this._cloudConfig.instanceId,
+      projectId: this._cloudConfig.projectId || "default",
+      baseUrl,
+      apiKey: this._cloudConfig.apiKey
+    });
+    if (this._cloudConfig.tokenProvider) {
+      adapter.setTokenProvider(this._cloudConfig.tokenProvider);
+    } else if (this._cloudConfig.tokenEndpoint) {
+      const tokenEndpoint = this._cloudConfig.tokenEndpoint;
+      const instanceId = this._cloudConfig.instanceId;
+      let resolvedBaseUrl;
+      if (tokenEndpoint.startsWith("http://") || tokenEndpoint.startsWith("https://")) {
+        resolvedBaseUrl = tokenEndpoint;
+      } else if (typeof window !== "undefined" && window.location?.origin) {
+        resolvedBaseUrl = `${window.location.origin}${tokenEndpoint.startsWith("/") ? "" : "/"}${tokenEndpoint}`;
+      } else {
+        resolvedBaseUrl = tokenEndpoint;
       }
-      const baseUrl = this._cloudConfig.baseUrl.replace("https://", "wss://").replace("http://", "ws://");
-      const adapter = new CloudAdapter2({
-        instanceId: this._cloudConfig.instanceId,
-        projectId: this._cloudConfig.projectId || "default",
-        baseUrl,
-        apiKey: this._cloudConfig.apiKey
-      });
-      if (this._cloudConfig.tokenEndpoint) {
-        const tokenEndpoint = this._cloudConfig.tokenEndpoint;
-        const instanceId = this._cloudConfig.instanceId;
-        let resolvedBaseUrl;
-        if (tokenEndpoint.startsWith("http://") || tokenEndpoint.startsWith("https://")) {
-          resolvedBaseUrl = tokenEndpoint;
-        } else if (typeof window !== "undefined" && window.location?.origin) {
-          resolvedBaseUrl = `${window.location.origin}${tokenEndpoint.startsWith("/") ? "" : "/"}${tokenEndpoint}`;
-        } else {
-          console.warn("MindCache: Cannot resolve tokenEndpoint to absolute URL - window.location not available");
-          resolvedBaseUrl = tokenEndpoint;
+      adapter.setTokenProvider(async () => {
+        const url = resolvedBaseUrl.includes("?") ? `${resolvedBaseUrl}&instanceId=${instanceId}` : `${resolvedBaseUrl}?instanceId=${instanceId}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+          throw new Error("Failed to get token");
         }
-        adapter.setTokenProvider(async () => {
-          const url = resolvedBaseUrl.includes("?") ? `${resolvedBaseUrl}&instanceId=${instanceId}` : `${resolvedBaseUrl}?instanceId=${instanceId}`;
-          const response = await fetch(url);
-          if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: "Failed to get token" }));
-            throw new Error(error.error || "Failed to get token");
-          }
-          const data = await response.json();
-          return data.token;
-        });
-      }
-      adapter.on("connected", () => {
-        this._connectionState = "connected";
-        this.notifyGlobalListeners();
-      });
-      adapter.on("disconnected", () => {
-        this._connectionState = "disconnected";
-        this.notifyGlobalListeners();
-      });
-      adapter.on("error", () => {
-        this._connectionState = "error";
-        this.notifyGlobalListeners();
-      });
-      adapter.on("synced", () => {
-        this._isLoaded = true;
-        this.notifyGlobalListeners();
+        const data = await response.json();
+        return data.token;
       });
-      adapter.attach(this);
-      this._cloudAdapter = adapter;
-      this._connectionState = "connecting";
-      adapter.connect();
-    } catch (error) {
-      console.error("MindCache: Failed to initialize cloud connection:", error);
+    }
+    adapter.on("connected", () => {
+      this._connectionState = "connected";
+      this.notifyGlobalListeners();
+    });
+    adapter.on("disconnected", () => {
+      this._connectionState = "disconnected";
+      this.notifyGlobalListeners();
+    });
+    adapter.on("error", () => {
       this._connectionState = "error";
+      this.notifyGlobalListeners();
+    });
+    adapter.on("synced", () => {
       this._isLoaded = true;
-    }
+      this.notifyGlobalListeners();
+    });
+    adapter.attach(this);
+    this._cloudAdapter = adapter;
+    this._connectionState = "connecting";
+    adapter.connect();
   }
-  async _initIndexedDB(config) {
-    try {
-      const IndexedDBAdapter2 = await this._getIndexedDBAdapterClass();
-      const adapter = new IndexedDBAdapter2(config);
-      await adapter.attach(this);
-    } catch (error) {
-      console.error("MindCache: Failed to initialize IndexedDB:", error);
+  async _initYIndexedDB(dbName) {
+    if (typeof window === "undefined") {
+      return;
     }
+    this._idbProvider = new yIndexeddb.IndexeddbPersistence(dbName, this.doc);
+    return new Promise((resolve) => {
+      if (!this._idbProvider) {
+        return resolve();
+      }
+      this._idbProvider.on("synced", () => {
+        this._isLoaded = true;
+        resolve();
+      });
+    });
+  }
+  // Legacy IndexedDB method stub
+  async _initIndexedDB(_config) {
   }
   async _getIndexedDBAdapterClass() {
     const { IndexedDBAdapter: IndexedDBAdapter2 } = await Promise.resolve().then(() => (init_IndexedDBAdapter(), IndexedDBAdapter_exports));
     return IndexedDBAdapter2;
   }
-  /**
-   * Get the current cloud connection state
-   */
   get connectionState() {
     return this._connectionState;
   }
-  /**
-   * Check if data is loaded (true for local, true after sync for cloud)
-   */
   get isLoaded() {
     return this._isLoaded;
   }
-  /**
-   * Protected method to load CloudAdapter class.
-   * Can be overridden/mocked for testing.
-   */
   async _getCloudAdapterClass() {
     const { CloudAdapter: CloudAdapter2 } = await Promise.resolve().then(() => (init_CloudAdapter(), CloudAdapter_exports));
     return CloudAdapter2;
   }
-  /**
-   * Check if this instance is connected to cloud
-   */
   get isCloud() {
     return this._cloudConfig !== null;
   }
-  /**
-   * Wait for initial sync to complete (or resolve immediately if already synced/local).
-   * Useful for scripts or linear execution flows.
-   */
   async waitForSync() {
     if (this._isLoaded) {
       return;
@@ -726,20 +782,17 @@ var MindCache = class {
       return;
     }
     return new Promise((resolve) => {
-      if (!this._cloudAdapter) {
-        resolve();
-        return;
+      if (this._isLoaded) {
+        return resolve();
       }
-      const handler = () => {
-        this._cloudAdapter?.off("synced", handler);
-        resolve();
-      };
-      this._cloudAdapter.on("synced", handler);
+      const interval = setInterval(() => {
+        if (this._isLoaded) {
+          clearInterval(interval);
+          resolve();
+        }
+      }, 100);
     });
   }
-  /**
-   * Disconnect from cloud (if connected)
-   */
   disconnect() {
     if (this._cloudAdapter) {
       this._cloudAdapter.disconnect();
@@ -747,8 +800,49 @@ var MindCache = class {
       this._cloudAdapter = null;
       this._connectionState = "disconnected";
     }
+    if (this._idbProvider) {
+      this._idbProvider.destroy();
+      this._idbProvider = null;
+    }
+  }
+  // Legacy bridge
+  isRemoteUpdate() {
+    return false;
+  }
+  // Serialize state
+  serialize() {
+    const json = {};
+    for (const [key, val] of this.rootMap) {
+      const entryMap = val;
+      const attrs = entryMap.get("attributes");
+      let value = entryMap.get("value");
+      if (attrs?.type === "document" && value instanceof Y__namespace.Text) {
+        value = value.toString();
+      }
+      json[key] = {
+        value,
+        attributes: attrs
+      };
+    }
+    return json;
+  }
+  // Deserialize state (for IndexedDBAdapter compatibility)
+  deserialize(data) {
+    this.doc.transact(() => {
+      for (const [key, entry] of Object.entries(data)) {
+        if (key.startsWith("$")) {
+          continue;
+        }
+        let entryMap = this.rootMap.get(key);
+        if (!entryMap) {
+          entryMap = new Y__namespace.Map();
+          this.rootMap.set(key, entryMap);
+        }
+        entryMap.set("value", entry.value);
+        entryMap.set("attributes", entry.attributes);
+      }
+    });
   }
-  // Helper method to encode file to base64
   encodeFileToBase64(file) {
     return new Promise((resolve, reject) => {
       if (typeof FileReader !== "undefined") {
@@ -765,11 +859,9 @@ var MindCache = class {
       }
     });
   }
-  // Helper method to create data URL from base64 and content type
   createDataUrl(base64Data, contentType) {
     return `data:${contentType};base64,${base64Data}`;
   }
-  // Helper method to validate content type for different STM types
   validateContentType(type, contentType) {
     if (type === "text" || type === "json") {
       return true;
@@ -785,11 +877,17 @@ var MindCache = class {
     }
     return false;
   }
-  /** @deprecated Use get_value instead */
-  get(key) {
-    return this.get_value(key);
+  // InjectSTM replacement
+  injectSTM(template, _processingStack) {
+    return template.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
+      const val = this.get_value(key.trim(), _processingStack);
+      return val !== void 0 ? String(val) : `{{${key}}}`;
+    });
+  }
+  // Public API Methods
+  getAll() {
+    return this.serialize();
   }
-  // Get a value from the STM with template processing if enabled
   get_value(key, _processingStack) {
     if (key === "$date") {
       const today = /* @__PURE__ */ new Date();
@@ -799,32 +897,37 @@ var MindCache = class {
       const now = /* @__PURE__ */ new Date();
       return now.toTimeString().split(" ")[0];
     }
-    const entry = this.stm[key];
-    if (!entry) {
+    if (key === "$version") {
+      return this.version;
+    }
+    const entryMap = this.rootMap.get(key);
+    if (!entryMap) {
       return void 0;
     }
-    if (entry.attributes.systemTags?.includes("ApplyTemplate") || entry.attributes.systemTags?.includes("template") || entry.attributes.template) {
-      const processingStack = _processingStack || /* @__PURE__ */ new Set();
-      if (processingStack.has(key)) {
-        return entry.value;
+    const attributes = entryMap.get("attributes");
+    const value = entryMap.get("value");
+    if (attributes?.type === "document" && value instanceof Y__namespace.Text) {
+      return value.toString();
+    }
+    if (_processingStack && _processingStack.has(key)) {
+      return `{{${key}}}`;
+    }
+    if (attributes?.systemTags?.includes("ApplyTemplate") || attributes?.systemTags?.includes("template") || attributes?.template) {
+      if (typeof value === "string") {
+        const stack = _processingStack || /* @__PURE__ */ new Set();
+        stack.add(key);
+        return this.injectSTM(value, stack);
       }
-      processingStack.add(key);
-      const result = this.injectSTM(entry.value, processingStack);
-      processingStack.delete(key);
-      return result;
     }
-    return entry.value;
+    return value;
   }
-  // Get attributes for a key
   get_attributes(key) {
-    if (key === "$date" || key === "$time") {
+    if (key === "$date" || key === "$time" || key === "$version") {
       return {
         type: "text",
         contentTags: [],
         systemTags: ["prompt", "readonly", "protected"],
         zIndex: 999999,
-        // System keys appear last
-        // Legacy attributes
         readonly: true,
         visible: true,
         hardcoded: true,
@@ -832,1270 +935,507 @@ var MindCache = class {
         tags: []
       };
     }
-    const entry = this.stm[key];
-    return entry ? entry.attributes : void 0;
+    const entryMap = this.rootMap.get(key);
+    return entryMap ? entryMap.get("attributes") : void 0;
   }
-  // Set a value in the STM with default attributes
-  set_value(key, value, attributes) {
-    if (key === "$date" || key === "$time") {
+  /**
+   * Update only the attributes of a key without modifying the value.
+   * Useful for updating tags, permissions etc. on document type keys.
+   */
+  set_attributes(key, attributes) {
+    if (key === "$date" || key === "$time" || key === "$version") {
       return;
     }
-    const existingEntry = this.stm[key];
-    const wasHardcoded = existingEntry?.attributes.hardcoded || existingEntry?.attributes.systemTags?.includes("protected");
-    const baseAttributes = existingEntry ? {
-      ...existingEntry.attributes,
-      contentTags: [...existingEntry.attributes.contentTags || []],
-      systemTags: [...existingEntry.attributes.systemTags || []],
-      tags: [...existingEntry.attributes.tags || []],
-      zIndex: existingEntry.attributes.zIndex ?? 0
-    } : {
-      ...DEFAULT_KEY_ATTRIBUTES,
-      contentTags: [],
-      // Fresh array
-      systemTags: ["SystemPrompt", "LLMWrite"],
-      // Fresh array with default
-      tags: [],
-      // Fresh array
-      zIndex: 0
-    };
-    const finalAttributes = attributes ? { ...baseAttributes, ...attributes } : baseAttributes;
-    let systemTags = this.normalizeSystemTags(finalAttributes.systemTags || []);
-    if (attributes) {
-      if ("readonly" in attributes) {
-        if (attributes.readonly) {
-          systemTags = systemTags.filter((t) => t !== "LLMWrite");
-          if (!systemTags.includes("readonly")) {
-            systemTags.push("readonly");
-          }
-        } else if (!wasHardcoded) {
-          if (!systemTags.includes("LLMWrite")) {
-            systemTags.push("LLMWrite");
-          }
-          systemTags = systemTags.filter((t) => t !== "readonly");
-        }
-      }
-      if ("visible" in attributes) {
-        if (attributes.visible) {
-          if (!systemTags.includes("SystemPrompt")) {
-            systemTags.push("SystemPrompt");
-          }
-          systemTags = systemTags.filter((t) => t !== "prompt");
-        } else {
-          systemTags = systemTags.filter((t) => t !== "SystemPrompt" && t !== "prompt");
-        }
-      }
-      if ("systemTags" in attributes && Array.isArray(attributes.systemTags)) {
-        systemTags = this.normalizeSystemTags(attributes.systemTags);
-      }
-      if ("hardcoded" in attributes) {
-        if (attributes.hardcoded && !systemTags.includes("protected")) {
-          systemTags.push("protected");
-        } else if (!attributes.hardcoded && !wasHardcoded) {
-          systemTags = systemTags.filter((t) => t !== "protected");
-        }
-        if (wasHardcoded && !systemTags.includes("protected")) {
-          systemTags.push("protected");
-        }
-      } else if (wasHardcoded) {
-        if (!systemTags.includes("protected")) {
-          systemTags.push("protected");
-        }
+    const entryMap = this.rootMap.get(key);
+    if (!entryMap) {
+      return;
+    }
+    this.doc.transact(() => {
+      const existingAttrs = entryMap.get("attributes");
+      const mergedAttrs = { ...existingAttrs, ...attributes };
+      if (mergedAttrs.systemTags) {
+        mergedAttrs.systemTags = this.normalizeSystemTags(mergedAttrs.systemTags);
       }
-      if ("template" in attributes) {
-        if (attributes.template && !wasHardcoded && !systemTags.includes("ApplyTemplate") && !systemTags.includes("template")) {
-          systemTags.push("ApplyTemplate");
-        } else if (!attributes.template || wasHardcoded) {
-          systemTags = systemTags.filter((t) => t !== "ApplyTemplate" && t !== "template");
+      entryMap.set("attributes", mergedAttrs);
+    });
+  }
+  set_value(key, value, attributes) {
+    if (key === "$date" || key === "$time" || key === "$version") {
+      return;
+    }
+    const existingEntry = this.rootMap.get(key);
+    if (existingEntry) {
+      const existingAttrs = existingEntry.get("attributes");
+      if (existingAttrs?.type === "document") {
+        if (typeof value === "string") {
+          this.replace_document_text(key, value);
         }
+        return;
       }
-    } else if (wasHardcoded) {
-      if (!systemTags.includes("protected")) {
-        systemTags.push("protected");
-      }
-      systemTags = systemTags.filter((t) => t !== "LLMWrite");
-      if (!systemTags.includes("readonly")) {
-        systemTags.push("readonly");
-      }
-      systemTags = systemTags.filter((t) => t !== "template");
     }
-    if (wasHardcoded && !systemTags.includes("protected")) {
-      systemTags.push("protected");
+    let entryMap = this.rootMap.get(key);
+    const isNewEntry = !entryMap;
+    if (isNewEntry) {
+      entryMap = new Y__namespace.Map();
+      this.rootMap.set(key, entryMap);
     }
-    if (systemTags.includes("protected")) {
-      systemTags = systemTags.filter((t) => t !== "LLMWrite");
-      if (!systemTags.includes("readonly")) {
-        systemTags.push("readonly");
+    this.getUndoManager(key);
+    this.doc.transact(() => {
+      const oldAttributes = isNewEntry ? {
+        ...DEFAULT_KEY_ATTRIBUTES,
+        contentTags: [],
+        systemTags: ["SystemPrompt", "LLMWrite"],
+        tags: [],
+        zIndex: 0
+      } : entryMap.get("attributes");
+      const finalAttributes = attributes ? { ...oldAttributes, ...attributes } : oldAttributes;
+      let normalizedAttributes = { ...finalAttributes };
+      if (finalAttributes.systemTags) {
+        normalizedAttributes.systemTags = this.normalizeSystemTags(finalAttributes.systemTags);
+      }
+      if (finalAttributes.template) {
+        if (!normalizedAttributes.systemTags.includes("template")) {
+          normalizedAttributes.systemTags.push("template");
+        }
       }
-      systemTags = systemTags.filter((t) => t !== "template");
-    }
-    finalAttributes.systemTags = systemTags;
-    finalAttributes.readonly = systemTags.includes("readonly") || !systemTags.includes("LLMWrite");
-    finalAttributes.visible = this.hasSystemPrompt(systemTags);
-    finalAttributes.hardcoded = wasHardcoded || systemTags.includes("protected");
-    finalAttributes.template = systemTags.includes("ApplyTemplate") || systemTags.includes("template");
-    if (attributes && "tags" in attributes && attributes.tags) {
-      finalAttributes.contentTags = [...attributes.tags];
-    }
-    finalAttributes.tags = [...finalAttributes.contentTags || []];
-    this.stm[key] = {
-      value,
-      attributes: finalAttributes
-    };
-    if (this.listeners[key]) {
-      this.listeners[key].forEach((listener) => listener(value));
-    }
-    this.notifyGlobalListeners();
+      entryMap.set("value", value);
+      entryMap.set("attributes", normalizedAttributes);
+    });
   }
-  // Internal method for setting values from remote (cloud sync)
-  // This doesn't trigger the global listener to prevent sync loops
-  _setFromRemote(key, value, attributes) {
+  delete_key(key) {
     if (key === "$date" || key === "$time") {
       return;
     }
-    this._isRemoteUpdate = true;
-    let systemTags = attributes.systemTags || [];
-    if (!attributes.systemTags || systemTags.length === 0) {
-      systemTags = [];
-      if (attributes.visible !== false) {
-        systemTags.push("prompt");
-      }
-      if (attributes.readonly) {
-        systemTags.push("readonly");
-      } else {
-        systemTags.push("LLMWrite");
-      }
-      if (attributes.hardcoded) {
-        systemTags.push("protected");
-      }
-      if (attributes.template) {
-        systemTags.push("ApplyTemplate");
-      }
-    }
-    systemTags = this.normalizeSystemTags(systemTags);
-    const contentTags = attributes.contentTags || attributes.tags || [];
-    this.stm[key] = {
-      value,
-      attributes: {
-        ...attributes,
-        contentTags,
-        systemTags,
-        zIndex: attributes.zIndex ?? 0,
-        tags: contentTags,
-        // Sync legacy attributes FROM normalized systemTags
-        readonly: systemTags.includes("readonly") || !systemTags.includes("LLMWrite"),
-        visible: this.hasSystemPrompt(systemTags),
-        hardcoded: systemTags.includes("protected"),
-        template: systemTags.includes("ApplyTemplate") || systemTags.includes("template")
-      }
-    };
-    if (this.listeners[key]) {
-      this.listeners[key].forEach((listener) => listener(value));
-    }
-    this.notifyGlobalListeners();
-    this._isRemoteUpdate = false;
+    this.rootMap.delete(key);
   }
-  // Check if current update is from remote
-  isRemoteUpdate() {
-    return this._isRemoteUpdate;
+  clear() {
+    const keys = Array.from(this.rootMap.keys());
+    this.doc.transact(() => {
+      keys.forEach((k) => this.rootMap.delete(k));
+    });
   }
-  // Internal method for deleting from remote (cloud sync)
-  _deleteFromRemote(key) {
-    if (key === "$date" || key === "$time") {
+  // File methods
+  async set_file(key, file, attributes) {
+    const base64 = await this.encodeFileToBase64(file);
+    const dataUrl = this.createDataUrl(base64, file.type);
+    this.set_value(key, dataUrl, {
+      ...attributes,
+      type: "file",
+      contentType: file.type
+    });
+  }
+  set_image(key, file, attributes) {
+    return this.set_file(key, file, {
+      ...attributes,
+      type: "image"
+      // Override to image
+    });
+  }
+  // Document methods for collaborative editing
+  /**
+   * Create or get a collaborative document key.
+   * Uses Y.Text for character-level concurrent editing.
+   *
+   * Note: This exposes Yjs Y.Text directly for editor bindings (y-quill, y-codemirror, etc.)
+   */
+  set_document(key, initialText, attributes) {
+    if (key === "$date" || key === "$time" || key === "$version") {
       return;
     }
-    this._isRemoteUpdate = true;
-    if (key in this.stm) {
-      delete this.stm[key];
-      if (this.listeners[key]) {
-        this.listeners[key].forEach((listener) => listener(void 0));
-      }
-      this.notifyGlobalListeners();
+    let entryMap = this.rootMap.get(key);
+    if (!entryMap) {
+      entryMap = new Y__namespace.Map();
+      this.rootMap.set(key, entryMap);
+      const yText = new Y__namespace.Text(initialText || "");
+      entryMap.set("value", yText);
+      entryMap.set("attributes", {
+        ...DEFAULT_KEY_ATTRIBUTES,
+        type: "document",
+        contentTags: [],
+        systemTags: ["SystemPrompt", "LLMWrite"],
+        tags: [],
+        zIndex: 0,
+        ...attributes
+      });
     }
-    this._isRemoteUpdate = false;
-  }
-  // Internal method for clearing from remote (cloud sync)
-  _clearFromRemote() {
-    this._isRemoteUpdate = true;
-    this.stm = {};
-    this.notifyGlobalListeners();
-    this._isRemoteUpdate = false;
+    this.getUndoManager(key);
   }
-  // Set attributes for an existing key
-  set_attributes(key, attributes) {
-    if (key === "$date" || key === "$time") {
-      return false;
+  /**
+   * Get the Y.Text object for a document key.
+   * Use this to bind to editors (Quill, CodeMirror, Monaco, etc.)
+   *
+   * @returns Y.Text or undefined if key doesn't exist or isn't a document
+   */
+  get_document(key) {
+    const entryMap = this.rootMap.get(key);
+    if (!entryMap) {
+      return void 0;
     }
-    const entry = this.stm[key];
-    if (!entry) {
-      return false;
+    const attrs = entryMap.get("attributes");
+    if (attrs?.type !== "document") {
+      return void 0;
     }
-    const wasHardcoded = entry.attributes.hardcoded || entry.attributes.systemTags?.includes("protected");
-    const { hardcoded: _hardcoded, systemTags: _systemTags, ...allowedAttributes } = attributes;
-    if (wasHardcoded) {
-      if ("readonly" in allowedAttributes) {
-        delete allowedAttributes.readonly;
-      }
-      if ("template" in allowedAttributes) {
-        delete allowedAttributes.template;
-      }
+    const value = entryMap.get("value");
+    if (value instanceof Y__namespace.Text) {
+      return value;
     }
-    entry.attributes = { ...entry.attributes, ...allowedAttributes };
-    if ("readonly" in attributes || "visible" in attributes || "template" in attributes || "systemTags" in attributes) {
-      let newSystemTags = entry.attributes.systemTags || [];
-      if ("systemTags" in attributes && Array.isArray(attributes.systemTags)) {
-        newSystemTags = this.normalizeSystemTags(attributes.systemTags);
-      } else {
-        newSystemTags = [];
-        if (!entry.attributes.readonly) {
-          newSystemTags.push("LLMWrite");
-        } else {
-          newSystemTags.push("readonly");
-        }
-        if (entry.attributes.visible) {
-          newSystemTags.push("SystemPrompt");
-        }
-        if (entry.attributes.template) {
-          newSystemTags.push("ApplyTemplate");
-        }
-        if (wasHardcoded || entry.attributes.hardcoded) {
-          newSystemTags.push("protected");
-        }
-        newSystemTags = this.normalizeSystemTags(newSystemTags);
-      }
-      if (newSystemTags.includes("protected")) {
-        newSystemTags = newSystemTags.filter((t) => t !== "LLMWrite");
-        if (!newSystemTags.includes("readonly")) {
-          newSystemTags.push("readonly");
-        }
-        newSystemTags = newSystemTags.filter((t) => t !== "ApplyTemplate" && t !== "template");
-        entry.attributes.readonly = true;
-        entry.attributes.template = false;
-      }
-      entry.attributes.systemTags = newSystemTags;
-      entry.attributes.readonly = newSystemTags.includes("readonly") || !newSystemTags.includes("LLMWrite");
-      entry.attributes.visible = this.hasSystemPrompt(newSystemTags);
-      entry.attributes.template = newSystemTags.includes("ApplyTemplate") || newSystemTags.includes("template");
-    } else if (wasHardcoded) {
-      let systemTags = this.normalizeSystemTags(entry.attributes.systemTags || []);
-      if (!systemTags.includes("protected")) {
-        systemTags.push("protected");
-      }
-      systemTags = systemTags.filter((t) => t !== "LLMWrite");
-      if (!systemTags.includes("readonly")) {
-        systemTags.push("readonly");
-      }
-      systemTags = systemTags.filter((t) => t !== "ApplyTemplate" && t !== "template");
-      entry.attributes.systemTags = systemTags;
-      entry.attributes.readonly = true;
-      entry.attributes.visible = this.hasSystemPrompt(systemTags);
-      entry.attributes.template = false;
-    }
-    if (wasHardcoded) {
-      entry.attributes.hardcoded = true;
-      if (!entry.attributes.systemTags?.includes("protected")) {
-        entry.attributes.systemTags = [...entry.attributes.systemTags || [], "protected"];
-      }
-      entry.attributes.readonly = true;
-      entry.attributes.template = false;
-    }
-    if ("contentTags" in attributes) {
-      entry.attributes.tags = [...entry.attributes.contentTags || []];
-    }
-    this.notifyGlobalListeners();
-    return true;
+    return void 0;
   }
-  set(key, value) {
-    this.set_value(key, value);
-  }
-  async set_file(key, file, attributes) {
-    const base64Data = await this.encodeFileToBase64(file);
-    const contentType = file.type;
-    const fileAttributes = {
-      type: contentType.startsWith("image/") ? "image" : "file",
-      contentType,
-      ...attributes
-    };
-    this.set_value(key, base64Data, fileAttributes);
-  }
-  set_base64(key, base64Data, contentType, type = "file", attributes) {
-    if (!this.validateContentType(type, contentType)) {
-      throw new Error(`Invalid content type ${contentType} for type ${type}`);
-    }
-    const fileAttributes = {
-      type,
-      contentType,
-      ...attributes
-    };
-    this.set_value(key, base64Data, fileAttributes);
-  }
-  add_image(key, base64Data, contentType = "image/jpeg", attributes) {
-    if (!contentType.startsWith("image/")) {
-      throw new Error(`Invalid image content type: ${contentType}. Must start with 'image/'`);
-    }
-    this.set_base64(key, base64Data, contentType, "image", attributes);
-    this.set_attributes(key, {
-      type: "image",
-      contentType
-    });
+  /**
+   * Get plain text content of a document key.
+   * For collaborative editing, use get_document() and bind to an editor.
+   */
+  get_document_text(key) {
+    const yText = this.get_document(key);
+    return yText?.toString();
   }
-  get_data_url(key) {
-    const entry = this.stm[key];
-    if (!entry || entry.attributes.type !== "image" && entry.attributes.type !== "file") {
-      return void 0;
-    }
-    if (!entry.attributes.contentType) {
-      return void 0;
+  /**
+   * Insert text at a position in a document key.
+   */
+  insert_text(key, index, text) {
+    const yText = this.get_document(key);
+    if (yText) {
+      yText.insert(index, text);
     }
-    return this.createDataUrl(entry.value, entry.attributes.contentType);
   }
-  get_base64(key) {
-    const entry = this.stm[key];
-    if (!entry || entry.attributes.type !== "image" && entry.attributes.type !== "file") {
-      return void 0;
+  /**
+   * Delete text from a document key.
+   */
+  delete_text(key, index, length2) {
+    const yText = this.get_document(key);
+    if (yText) {
+      yText.delete(index, length2);
     }
-    return entry.value;
   }
-  has(key) {
-    if (key === "$date" || key === "$time") {
-      return true;
+  /**
+   * Replace all text in a document key.
+   * Uses diff-based updates when changes are < diffThreshold (default 80%).
+   * This preserves concurrent edits and provides better undo granularity.
+   *
+   * @param key - The document key
+   * @param newText - The new text content
+   * @param diffThreshold - Percentage (0-1) of change above which full replace is used (default: 0.8)
+   */
+  replace_document_text(key, newText, diffThreshold = 0.8) {
+    const yText = this.get_document(key);
+    if (!yText) {
+      return;
     }
-    return key in this.stm;
-  }
-  delete(key) {
-    if (key === "$date" || key === "$time") {
-      return false;
+    const oldText = yText.toString();
+    if (oldText === newText) {
+      return;
     }
-    if (!(key in this.stm)) {
-      return false;
+    if (oldText.length === 0) {
+      yText.insert(0, newText);
+      return;
     }
-    const deleted = delete this.stm[key];
-    if (deleted) {
-      this.notifyGlobalListeners();
-      if (this.listeners[key]) {
-        this.listeners[key].forEach((listener) => listener(void 0));
+    const diffs = diff__default.default(oldText, newText);
+    let changedChars = 0;
+    for (const [op, text] of diffs) {
+      if (op !== 0) {
+        changedChars += text.length;
       }
     }
-    return deleted;
-  }
-  clear() {
-    this.stm = {};
-    this.notifyGlobalListeners();
-  }
-  /**
-   * Get keys sorted by zIndex (ascending), then by key name
-   */
-  getSortedKeys() {
-    return Object.entries(this.stm).sort(([keyA, entryA], [keyB, entryB]) => {
-      const zIndexA = entryA.attributes.zIndex ?? 0;
-      const zIndexB = entryB.attributes.zIndex ?? 0;
-      if (zIndexA !== zIndexB) {
-        return zIndexA - zIndexB;
-      }
-      return keyA.localeCompare(keyB);
-    }).map(([key]) => key);
-  }
-  keys() {
-    return [...this.getSortedKeys(), "$date", "$time"];
-  }
-  values() {
-    const now = /* @__PURE__ */ new Date();
-    const sortedKeys = this.getSortedKeys();
-    const stmValues = sortedKeys.map((key) => this.stm[key].value);
-    return [
-      ...stmValues,
-      now.toISOString().split("T")[0],
-      now.toTimeString().split(" ")[0]
-    ];
-  }
-  entries() {
-    const now = /* @__PURE__ */ new Date();
-    const sortedKeys = this.getSortedKeys();
-    const stmEntries = sortedKeys.map(
-      (key) => [key, this.stm[key].value]
-    );
-    return [
-      ...stmEntries,
-      ["$date", now.toISOString().split("T")[0]],
-      ["$time", now.toTimeString().split(" ")[0]]
-    ];
-  }
-  size() {
-    return Object.keys(this.stm).length + 2;
-  }
-  getAll() {
-    const now = /* @__PURE__ */ new Date();
-    const result = {};
-    const sortedKeys = this.getSortedKeys();
-    sortedKeys.forEach((key) => {
-      result[key] = this.stm[key].value;
-    });
-    result["$date"] = now.toISOString().split("T")[0];
-    result["$time"] = now.toTimeString().split(" ")[0];
-    return result;
-  }
-  update(newValues) {
-    Object.entries(newValues).forEach(([key, value]) => {
-      if (key !== "$date" && key !== "$time") {
-        this.stm[key] = {
-          value,
-          attributes: { ...DEFAULT_KEY_ATTRIBUTES }
-        };
-        if (this.listeners[key]) {
-          this.listeners[key].forEach((listener) => listener(this.stm[key]?.value));
+    const changeRatio = changedChars / Math.max(oldText.length, newText.length);
+    if (changeRatio > diffThreshold) {
+      this.doc.transact(() => {
+        yText.delete(0, yText.length);
+        yText.insert(0, newText);
+      });
+      return;
+    }
+    this.doc.transact(() => {
+      let cursor = 0;
+      for (const [op, text] of diffs) {
+        if (op === 0) {
+          cursor += text.length;
+        } else if (op === -1) {
+          yText.delete(cursor, text.length);
+        } else if (op === 1) {
+          yText.insert(cursor, text);
+          cursor += text.length;
         }
       }
     });
-    this.notifyGlobalListeners();
   }
+  // ... (subscribe methods)
   subscribe(key, listener) {
     if (!this.listeners[key]) {
       this.listeners[key] = [];
     }
     this.listeners[key].push(listener);
-  }
-  unsubscribe(key, listener) {
-    if (this.listeners[key]) {
+    return () => {
       this.listeners[key] = this.listeners[key].filter((l) => l !== listener);
-    }
+    };
   }
   subscribeToAll(listener) {
     this.globalListeners.push(listener);
+    return () => {
+      this.globalListeners = this.globalListeners.filter((l) => l !== listener);
+    };
   }
   unsubscribeFromAll(listener) {
     this.globalListeners = this.globalListeners.filter((l) => l !== listener);
   }
   notifyGlobalListeners() {
-    this.globalListeners.forEach((listener) => listener());
-  }
-  injectSTM(template, _processingStack) {
-    if (template === null || template === void 0) {
-      return String(template);
-    }
-    const templateStr = String(template);
-    const keys = templateStr.match(/\{\{([$\w]+)\}\}/g);
-    if (!keys) {
-      return templateStr;
-    }
-    const cleanKeys = keys.map((key) => key.replace(/[{}]/g, ""));
-    const inputValues = cleanKeys.reduce((acc, key) => {
-      if (key === "$date" || key === "$time") {
-        return {
-          ...acc,
-          [key]: this.get_value(key, _processingStack)
-        };
-      }
-      const attributes = this.get_attributes(key);
-      if (_processingStack || attributes && attributes.visible) {
-        if (attributes && (attributes.type === "image" || attributes.type === "file")) {
-          return acc;
-        }
-        return {
-          ...acc,
-          [key]: this.get_value(key, _processingStack)
-        };
-      }
-      return acc;
-    }, {});
-    return templateStr.replace(/\{\{([$\w]+)\}\}/g, (match, key) => {
-      if (inputValues[key] !== void 0) {
-        return inputValues[key];
-      }
-      const attributes = this.get_attributes(key);
-      if (attributes && (attributes.type === "image" || attributes.type === "file")) {
-        return match;
-      }
-      return "";
-    });
-  }
-  getSTM() {
-    const now = /* @__PURE__ */ new Date();
-    const entries = [];
-    const sortedKeys = this.getSortedKeys();
-    sortedKeys.forEach((key) => {
-      const entry = this.stm[key];
-      if (entry.attributes.visible) {
-        entries.push([key, this.get_value(key)]);
-      }
-    });
-    entries.push(["$date", now.toISOString().split("T")[0]]);
-    entries.push(["$time", now.toTimeString().split(" ")[0]]);
-    return entries.map(([key, value]) => `${key}: ${value}`).join(", ");
-  }
-  getSTMObject() {
-    return this.getAll();
-  }
-  getSTMForAPI() {
-    const now = /* @__PURE__ */ new Date();
-    const apiData = [];
-    const sortedKeys = this.getSortedKeys();
-    sortedKeys.forEach((key) => {
-      const entry = this.stm[key];
-      if (this.hasLLMRead(entry.attributes.systemTags) || entry.attributes.visible) {
-        const hasTemplate = entry.attributes.systemTags?.includes("ApplyTemplate") || entry.attributes.systemTags?.includes("template") || entry.attributes.template;
-        const processedValue = hasTemplate ? this.get_value(key) : entry.value;
-        apiData.push({
-          key,
-          value: processedValue,
-          type: entry.attributes.type,
-          contentType: entry.attributes.contentType
-        });
-      }
-    });
-    apiData.push({
-      key: "$date",
-      value: now.toISOString().split("T")[0],
-      type: "text"
-    });
-    apiData.push({
-      key: "$time",
-      value: now.toTimeString().split(" ")[0],
-      type: "text"
-    });
-    return apiData;
-  }
-  getVisibleImages() {
-    const imageParts = [];
-    const sortedKeys = this.getSortedKeys();
-    sortedKeys.forEach((key) => {
-      const entry = this.stm[key];
-      if ((this.hasLLMRead(entry.attributes.systemTags) || entry.attributes.visible) && entry.attributes.type === "image" && entry.attributes.contentType) {
-        const dataUrl = this.createDataUrl(entry.value, entry.attributes.contentType);
-        imageParts.push({
-          type: "file",
-          mediaType: entry.attributes.contentType,
-          url: dataUrl,
-          filename: key
-        });
-      }
-    });
-    return imageParts;
+    this.globalListeners.forEach((l) => l());
   }
-  toJSON() {
-    return JSON.stringify(this.serialize());
+  // Sanitize key name for use in tool names
+  sanitizeKeyForTool(key) {
+    return key.replace(/[^a-zA-Z0-9_-]/g, "_");
   }
-  fromJSON(jsonString) {
-    try {
-      const data = JSON.parse(jsonString);
-      this.deserialize(data);
-    } catch (error) {
-      console.error("MindCache: Failed to deserialize JSON:", error);
-    }
-  }
-  serialize() {
-    const result = {};
-    const sortedKeys = this.getSortedKeys();
-    sortedKeys.forEach((key) => {
-      const entry = this.stm[key];
-      if (!entry.attributes.hardcoded) {
-        result[key] = {
-          value: entry.value,
-          attributes: { ...entry.attributes }
-        };
+  // Find original key from sanitized tool name
+  findKeyFromSanitizedTool(sanitizedKey) {
+    for (const [key] of this.rootMap) {
+      if (this.sanitizeKeyForTool(key) === sanitizedKey) {
+        return key;
       }
-    });
-    return result;
-  }
-  deserialize(data) {
-    if (typeof data === "object" && data !== null) {
-      this._isRemoteUpdate = true;
-      this.clear();
-      Object.entries(data).forEach(([key, entry]) => {
-        if (entry && typeof entry === "object" && "value" in entry && "attributes" in entry) {
-          const attrs = entry.attributes;
-          if (attrs.hardcoded === true || attrs.systemTags?.includes("protected")) {
-            return;
-          }
-          let systemTags = attrs.systemTags || [];
-          if (!attrs.systemTags || systemTags.length === 0) {
-            systemTags = [];
-            if (attrs.visible !== false) {
-              systemTags.push("prompt");
-            }
-            if (attrs.readonly) {
-              systemTags.push("readonly");
-            } else {
-              systemTags.push("LLMWrite");
-            }
-            if (attrs.hardcoded) {
-              systemTags.push("protected");
-            }
-            if (attrs.template) {
-              systemTags.push("ApplyTemplate");
-            }
-          }
-          systemTags = this.normalizeSystemTags(systemTags);
-          const contentTags = attrs.contentTags || attrs.tags || [];
-          this.stm[key] = {
-            value: entry.value,
-            attributes: {
-              ...attrs,
-              contentTags,
-              systemTags,
-              zIndex: attrs.zIndex ?? 0,
-              // Sync legacy attributes FROM normalized systemTags
-              tags: contentTags,
-              readonly: systemTags.includes("readonly") || !systemTags.includes("LLMWrite"),
-              visible: this.hasSystemPrompt(systemTags),
-              hardcoded: systemTags.includes("protected"),
-              template: systemTags.includes("ApplyTemplate") || systemTags.includes("template")
-            }
-          };
-        }
-      });
-      this.notifyGlobalListeners();
-      this._isRemoteUpdate = false;
     }
+    return void 0;
   }
-  get_system_prompt() {
-    const now = /* @__PURE__ */ new Date();
-    const promptLines = [];
-    const sortedKeys = this.getSortedKeys();
-    sortedKeys.forEach((key) => {
-      const entry = this.stm[key];
-      if (this.hasLLMRead(entry.attributes.systemTags) || entry.attributes.visible) {
-        if (entry.attributes.type === "image") {
-          promptLines.push(`image ${key} available`);
-          return;
-        }
-        if (entry.attributes.type === "file") {
-          const canWrite2 = this.hasLLMWrite(entry.attributes.systemTags) || !entry.attributes.readonly && !entry.attributes.systemTags.includes("readonly");
-          if (!canWrite2) {
-            promptLines.push(`${key}: [${entry.attributes.type.toUpperCase()}] - ${entry.attributes.contentType || "unknown format"}`);
-          } else {
-            const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
-            promptLines.push(`${key}: [${entry.attributes.type.toUpperCase()}] - ${entry.attributes.contentType || "unknown format"}. You can update this ${entry.attributes.type} using the write_${sanitizedKey} tool.`);
-          }
-          return;
-        }
-        const value = this.get_value(key);
-        const formattedValue = typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
-        const canWrite = this.hasLLMWrite(entry.attributes.systemTags) || !entry.attributes.readonly && !entry.attributes.systemTags.includes("readonly");
-        if (!canWrite) {
-          promptLines.push(`${key}: ${formattedValue}`);
-        } else {
-          const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
-          const toolInstruction = `You can rewrite "${key}" by using the write_${sanitizedKey} tool. This tool DOES NOT append \u2014 start your response with the old value (${formattedValue})`;
-          promptLines.push(`${key}: ${formattedValue}. ${toolInstruction}`);
-        }
-      }
-    });
-    promptLines.push(`$date: ${now.toISOString().split("T")[0]}`);
-    promptLines.push(`$time: ${now.toTimeString().split(" ")[0]}`);
-    return promptLines.join("\n");
-  }
-  findKeyFromToolName(toolName) {
-    if (!toolName.startsWith("write_")) {
-      return void 0;
-    }
-    const sanitizedKey = toolName.replace("write_", "");
-    const sortedKeys = this.getSortedKeys();
-    return sortedKeys.find(
-      (k) => k.replace(/[^a-zA-Z0-9_-]/g, "_") === sanitizedKey
-    );
-  }
+  /**
+   * Generate Vercel AI SDK compatible tools for writable keys.
+   * For document type keys, generates additional tools: append_, insert_, edit_
+   */
   get_aisdk_tools() {
     const tools = {};
-    const sortedKeys = this.getSortedKeys();
-    const writableKeys = sortedKeys.filter((key) => {
-      const entry = this.stm[key];
-      return this.hasLLMWrite(entry.attributes.systemTags) || !entry.attributes.readonly && !entry.attributes.systemTags.includes("readonly");
-    });
-    writableKeys.forEach((key) => {
-      const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
-      const toolName = `write_${sanitizedKey}`;
-      const entry = this.stm[key];
-      const keyType = entry?.attributes.type || "text";
-      let inputSchema;
-      let description = `Write a value to the STM key: ${key}`;
-      if (keyType === "image" || keyType === "file") {
-        description += " (expects base64 encoded data)";
-        inputSchema = zod.z.object({
-          value: zod.z.string().describe(`Base64 encoded data for ${key}`),
-          contentType: zod.z.string().optional().describe(`MIME type for the ${keyType}`)
-        });
-      } else if (keyType === "json") {
-        description += " (expects JSON string)";
-        inputSchema = zod.z.object({
-          value: zod.z.string().describe(`JSON string value for ${key}`)
-        });
-      } else {
-        inputSchema = zod.z.object({
-          value: zod.z.string().describe(`The text value to write to ${key}`)
-        });
+    for (const [key, val] of this.rootMap) {
+      if (key.startsWith("$")) {
+        continue;
       }
-      tools[toolName] = {
-        description,
-        inputSchema,
-        execute: async (input) => {
-          if (keyType === "image" || keyType === "file") {
-            if (input.contentType) {
-              this.set_base64(key, input.value, input.contentType, keyType);
-            } else {
-              const existingContentType = entry?.attributes.contentType;
-              if (existingContentType) {
-                this.set_base64(key, input.value, existingContentType, keyType);
-              } else {
-                throw new Error(`Content type required for ${keyType} data`);
-              }
-            }
-          } else {
-            this.set_value(key, input.value);
-          }
-          let resultMessage;
-          if (keyType === "image") {
-            resultMessage = `Successfully saved image to ${key}`;
-          } else if (keyType === "file") {
-            resultMessage = `Successfully saved file to ${key}`;
-          } else if (keyType === "json") {
-            resultMessage = `Successfully saved JSON data to ${key}`;
+      const entryMap = val;
+      const attributes = entryMap.get("attributes");
+      const isWritable = !attributes?.readonly && (attributes?.systemTags?.includes("LLMWrite") || !attributes?.systemTags);
+      if (!isWritable) {
+        continue;
+      }
+      const sanitizedKey = this.sanitizeKeyForTool(key);
+      const isDocument = attributes?.type === "document";
+      tools[`write_${sanitizedKey}`] = {
+        description: isDocument ? `Rewrite the entire "${key}" document` : `Write a value to the STM key: ${key}`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            value: { type: "string", description: isDocument ? "New document content" : "The value to write" }
+          },
+          required: ["value"]
+        },
+        execute: async ({ value }) => {
+          if (isDocument) {
+            this.replace_document_text(key, value);
           } else {
-            resultMessage = `Successfully wrote "${input.value}" to ${key}`;
+            this.set_value(key, value);
           }
           return {
-            result: resultMessage,
+            result: `Successfully wrote "${value}" to ${key}`,
             key,
-            value: input.value,
-            type: keyType,
-            contentType: input.contentType,
-            sanitizedKey
+            value
           };
         }
       };
-    });
-    if (writableKeys.length === 0) {
-      return {};
+      if (isDocument) {
+        tools[`append_${sanitizedKey}`] = {
+          description: `Append text to the end of "${key}" document`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              text: { type: "string", description: "Text to append" }
+            },
+            required: ["text"]
+          },
+          execute: async ({ text }) => {
+            const yText = this.get_document(key);
+            if (yText) {
+              yText.insert(yText.length, text);
+              return {
+                result: `Successfully appended to ${key}`,
+                key,
+                appended: text
+              };
+            }
+            return { result: `Document ${key} not found`, key };
+          }
+        };
+        tools[`insert_${sanitizedKey}`] = {
+          description: `Insert text at a position in "${key}" document`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              index: { type: "number", description: "Position to insert at (0 = start)" },
+              text: { type: "string", description: "Text to insert" }
+            },
+            required: ["index", "text"]
+          },
+          execute: async ({ index, text }) => {
+            this.insert_text(key, index, text);
+            return {
+              result: `Successfully inserted text at position ${index} in ${key}`,
+              key,
+              index,
+              inserted: text
+            };
+          }
+        };
+        tools[`edit_${sanitizedKey}`] = {
+          description: `Find and replace text in "${key}" document`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              find: { type: "string", description: "Text to find" },
+              replace: { type: "string", description: "Replacement text" }
+            },
+            required: ["find", "replace"]
+          },
+          execute: async ({ find, replace }) => {
+            const yText = this.get_document(key);
+            if (yText) {
+              const text = yText.toString();
+              const idx = text.indexOf(find);
+              if (idx !== -1) {
+                yText.delete(idx, find.length);
+                yText.insert(idx, replace);
+                return {
+                  result: `Successfully replaced "${find}" with "${replace}" in ${key}`,
+                  key,
+                  find,
+                  replace,
+                  index: idx
+                };
+              }
+              return { result: `Text "${find}" not found in ${key}`, key };
+            }
+            return { result: `Document ${key} not found`, key };
+          }
+        };
+      }
     }
     return tools;
   }
-  executeToolCall(toolName, value) {
-    const originalKey = this.findKeyFromToolName(toolName);
-    if (!originalKey) {
-      return null;
-    }
-    const entry = this.stm[originalKey];
-    const canWrite = entry && (this.hasLLMWrite(entry.attributes.systemTags) || !entry.attributes.readonly && !entry.attributes.systemTags.includes("readonly"));
-    if (!canWrite) {
-      return null;
-    }
-    this.set_value(originalKey, value);
-    return {
-      result: `Successfully wrote "${value}" to ${originalKey}`,
-      key: originalKey,
-      value
-    };
-  }
-  // ============================================
-  // Content Tag Methods (available to all access levels)
-  // ============================================
-  /**
-   * Add a content tag to a key (user-level organization)
-   */
-  addTag(key, tag) {
-    if (key === "$date" || key === "$time") {
-      return false;
-    }
-    const entry = this.stm[key];
-    if (!entry) {
-      return false;
-    }
-    if (!entry.attributes.contentTags) {
-      entry.attributes.contentTags = [];
-    }
-    if (!entry.attributes.contentTags.includes(tag)) {
-      entry.attributes.contentTags.push(tag);
-      entry.attributes.tags = [...entry.attributes.contentTags];
-      this.notifyGlobalListeners();
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Remove a content tag from a key
-   */
-  removeTag(key, tag) {
-    if (key === "$date" || key === "$time") {
-      return false;
-    }
-    const entry = this.stm[key];
-    if (!entry || !entry.attributes.contentTags) {
-      return false;
-    }
-    const tagIndex = entry.attributes.contentTags.indexOf(tag);
-    if (tagIndex > -1) {
-      entry.attributes.contentTags.splice(tagIndex, 1);
-      entry.attributes.tags = [...entry.attributes.contentTags];
-      this.notifyGlobalListeners();
-      return true;
-    }
-    return false;
-  }
   /**
-   * Get all content tags for a key
+   * Generate a system prompt containing all visible STM keys and their values.
+   * Indicates which tools can be used to modify writable keys.
    */
-  getTags(key) {
-    if (key === "$date" || key === "$time") {
-      return [];
-    }
-    const entry = this.stm[key];
-    return entry?.attributes.contentTags || [];
-  }
-  /**
-   * Get all unique content tags across all keys
-   */
-  getAllTags() {
-    const allTags = /* @__PURE__ */ new Set();
-    Object.values(this.stm).forEach((entry) => {
-      if (entry.attributes.contentTags) {
-        entry.attributes.contentTags.forEach((tag) => allTags.add(tag));
+  get_system_prompt() {
+    const lines = [];
+    for (const [key, val] of this.rootMap) {
+      if (key.startsWith("$")) {
+        continue;
       }
-    });
-    return Array.from(allTags);
-  }
-  /**
-   * Check if a key has a specific content tag
-   */
-  hasTag(key, tag) {
-    if (key === "$date" || key === "$time") {
-      return false;
-    }
-    const entry = this.stm[key];
-    return entry?.attributes.contentTags?.includes(tag) || false;
-  }
-  /**
-   * Get all keys with a specific content tag as formatted string
-   */
-  getTagged(tag) {
-    const entries = [];
-    const sortedKeys = this.getSortedKeys();
-    sortedKeys.forEach((key) => {
-      const entry = this.stm[key];
-      if (entry.attributes.contentTags?.includes(tag)) {
-        entries.push([key, this.get_value(key)]);
+      const entryMap = val;
+      const attributes = entryMap.get("attributes");
+      const isVisible = attributes?.visible !== false && (attributes?.systemTags?.includes("prompt") || attributes?.systemTags?.includes("SystemPrompt") || !attributes?.systemTags);
+      if (!isVisible) {
+        continue;
       }
-    });
-    return entries.map(([key, value]) => `${key}: ${value}`).join(", ");
-  }
-  /**
-   * Get all keys with a specific content tag
-   */
-  getKeysByTag(tag) {
-    const sortedKeys = this.getSortedKeys();
-    return sortedKeys.filter((key) => {
-      const entry = this.stm[key];
-      return entry.attributes.contentTags?.includes(tag);
-    });
-  }
-  // ============================================
-  // System Tag Methods (requires system access level)
-  // ============================================
-  /**
-   * Add a system tag to a key (requires system access)
-   * System tags: 'prompt', 'readonly', 'protected', 'template'
-   */
-  systemAddTag(key, tag) {
-    if (!this.hasSystemAccess) {
-      console.warn("MindCache: systemAddTag requires system access level");
-      return false;
-    }
-    if (key === "$date" || key === "$time") {
-      return false;
-    }
-    const entry = this.stm[key];
-    if (!entry) {
-      return false;
-    }
-    if (!entry.attributes.systemTags) {
-      entry.attributes.systemTags = [];
-    }
-    if (!entry.attributes.systemTags.includes(tag)) {
-      entry.attributes.systemTags.push(tag);
-      this.syncLegacyFromSystemTags(entry);
-      this.notifyGlobalListeners();
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Remove a system tag from a key (requires system access)
-   */
-  systemRemoveTag(key, tag) {
-    if (!this.hasSystemAccess) {
-      console.warn("MindCache: systemRemoveTag requires system access level");
-      return false;
-    }
-    if (key === "$date" || key === "$time") {
-      return false;
-    }
-    const entry = this.stm[key];
-    if (!entry || !entry.attributes.systemTags) {
-      return false;
-    }
-    const isHardcoded = entry.attributes.hardcoded || entry.attributes.systemTags.includes("protected");
-    if (tag === "protected" && isHardcoded) {
-      return false;
-    }
-    const tagIndex = entry.attributes.systemTags.indexOf(tag);
-    if (tagIndex > -1) {
-      entry.attributes.systemTags.splice(tagIndex, 1);
-      this.syncLegacyFromSystemTags(entry);
-      if (isHardcoded) {
-        if (!entry.attributes.systemTags.includes("protected")) {
-          entry.attributes.systemTags.push("protected");
+      const value = this.get_value(key);
+      const displayValue = typeof value === "object" ? JSON.stringify(value) : value;
+      const isWritable = !attributes?.readonly && (attributes?.systemTags?.includes("LLMWrite") || !attributes?.systemTags);
+      const isDocument = attributes?.type === "document";
+      const sanitizedKey = this.sanitizeKeyForTool(key);
+      if (isWritable) {
+        if (isDocument) {
+          lines.push(`${key}: ${displayValue}. Document tools: write_${sanitizedKey}, append_${sanitizedKey}, edit_${sanitizedKey}`);
+        } else {
+          const oldValueHint = displayValue ? ` This tool DOES NOT append \u2014 start your response with the old value (${displayValue})` : "";
+          lines.push(`${key}: ${displayValue}. You can rewrite "${key}" by using the write_${sanitizedKey} tool.${oldValueHint}`);
         }
-        entry.attributes.hardcoded = true;
-        entry.attributes.readonly = true;
-        entry.attributes.template = false;
+      } else {
+        lines.push(`${key}: ${displayValue}`);
       }
-      this.notifyGlobalListeners();
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Get all system tags for a key (requires system access)
-   */
-  systemGetTags(key) {
-    if (!this.hasSystemAccess) {
-      console.warn("MindCache: systemGetTags requires system access level");
-      return [];
-    }
-    if (key === "$date" || key === "$time") {
-      return [];
-    }
-    const entry = this.stm[key];
-    return entry?.attributes.systemTags || [];
-  }
-  /**
-   * Check if a key has a specific system tag (requires system access)
-   */
-  systemHasTag(key, tag) {
-    if (!this.hasSystemAccess) {
-      console.warn("MindCache: systemHasTag requires system access level");
-      return false;
-    }
-    if (key === "$date" || key === "$time") {
-      return false;
     }
-    const entry = this.stm[key];
-    return entry?.attributes.systemTags?.includes(tag) || false;
+    lines.push(`$date: ${this.get_value("$date")}`);
+    lines.push(`$time: ${this.get_value("$time")}`);
+    return lines.join(", ");
   }
   /**
-   * Set all system tags for a key at once (requires system access)
+   * Execute a tool call by name with the given value.
+   * Returns the result or null if tool not found.
    */
-  systemSetTags(key, tags) {
-    if (!this.hasSystemAccess) {
-      console.warn("MindCache: systemSetTags requires system access level");
-      return false;
-    }
-    if (key === "$date" || key === "$time") {
-      return false;
+  executeToolCall(toolName, value) {
+    const match = toolName.match(/^(write|append|insert|edit)_(.+)$/);
+    if (!match) {
+      return null;
     }
-    const entry = this.stm[key];
-    if (!entry) {
-      return false;
+    const [, action, sanitizedKey] = match;
+    const key = this.findKeyFromSanitizedTool(sanitizedKey);
+    if (!key) {
+      return null;
     }
-    entry.attributes.systemTags = [...tags];
-    this.syncLegacyFromSystemTags(entry);
-    this.notifyGlobalListeners();
-    return true;
-  }
-  /**
-   * Get all keys with a specific system tag (requires system access)
-   */
-  systemGetKeysByTag(tag) {
-    if (!this.hasSystemAccess) {
-      console.warn("MindCache: systemGetKeysByTag requires system access level");
-      return [];
+    const entryMap = this.rootMap.get(key);
+    if (!entryMap) {
+      return null;
     }
-    const sortedKeys = this.getSortedKeys();
-    return sortedKeys.filter((key) => {
-      const entry = this.stm[key];
-      return entry.attributes.systemTags?.includes(tag);
-    });
-  }
-  /**
-   * Helper to sync legacy boolean attributes from system tags
-   */
-  syncLegacyFromSystemTags(entry) {
-    const tags = entry.attributes.systemTags || [];
-    entry.attributes.readonly = tags.includes("readonly");
-    entry.attributes.visible = tags.includes("prompt");
-    entry.attributes.hardcoded = tags.includes("protected");
-    entry.attributes.template = tags.includes("ApplyTemplate") || tags.includes("template");
-  }
-  toMarkdown() {
-    const now = /* @__PURE__ */ new Date();
-    const lines = [];
-    const appendixEntries = [];
-    let appendixCounter = 0;
-    lines.push("# MindCache STM Export");
-    lines.push("");
-    lines.push(`Export Date: ${now.toISOString().split("T")[0]}`);
-    lines.push("");
-    lines.push("---");
-    lines.push("");
-    lines.push("## STM Entries");
-    lines.push("");
-    const sortedKeys = this.getSortedKeys();
-    sortedKeys.forEach((key) => {
-      const entry = this.stm[key];
-      if (entry.attributes.hardcoded) {
-        return;
-      }
-      lines.push(`### ${key}`);
-      const entryType = entry.attributes.type && entry.attributes.type !== "undefined" ? entry.attributes.type : "text";
-      lines.push(`- **Type**: \`${entryType}\``);
-      lines.push(`- **Readonly**: \`${entry.attributes.readonly}\``);
-      lines.push(`- **Visible**: \`${entry.attributes.visible}\``);
-      lines.push(`- **Template**: \`${entry.attributes.template}\``);
-      lines.push(`- **Z-Index**: \`${entry.attributes.zIndex ?? 0}\``);
-      if (entry.attributes.tags && entry.attributes.tags.length > 0) {
-        lines.push(`- **Tags**: \`${entry.attributes.tags.join("`, `")}\``);
-      }
-      if (entry.attributes.contentType) {
-        lines.push(`- **Content Type**: \`${entry.attributes.contentType}\``);
-      }
-      if (entryType === "image" || entryType === "file") {
-        const label = String.fromCharCode(65 + appendixCounter);
-        appendixCounter++;
-        lines.push(`- **Value**: [See Appendix ${label}]`);
-        appendixEntries.push({
-          key,
-          type: entryType,
-          contentType: entry.attributes.contentType || "application/octet-stream",
-          base64: entry.value,
-          label
-        });
-      } else if (entryType === "json") {
-        lines.push("- **Value**:");
-        lines.push("```json");
-        try {
-          const jsonValue = typeof entry.value === "string" ? entry.value : JSON.stringify(entry.value, null, 2);
-          lines.push(jsonValue);
-        } catch {
-          lines.push(String(entry.value));
-        }
-        lines.push("```");
-      } else {
-        const valueStr = String(entry.value);
-        lines.push("- **Value**:");
-        lines.push("```");
-        lines.push(valueStr);
-        lines.push("```");
-      }
-      lines.push("");
-      lines.push("---");
-      lines.push("");
-    });
-    if (appendixEntries.length > 0) {
-      lines.push("## Appendix: Binary Data");
-      lines.push("");
-      appendixEntries.forEach(({ key, contentType, base64, label }) => {
-        lines.push(`### Appendix ${label}: ${key}`);
-        lines.push(`**Type**: ${contentType}`);
-        lines.push("");
-        lines.push("```");
-        lines.push(base64);
-        lines.push("```");
-        lines.push("");
-        lines.push("---");
-        lines.push("");
-      });
+    const attributes = entryMap.get("attributes");
+    const isWritable = !attributes?.readonly && (attributes?.systemTags?.includes("LLMWrite") || !attributes?.systemTags);
+    if (!isWritable) {
+      return null;
     }
-    lines.push("*End of MindCache Export*");
-    return lines.join("\n");
-  }
-  fromMarkdown(markdown) {
-    const lines = markdown.split("\n");
-    let currentSection = "header";
-    let currentKey = null;
-    let currentEntry = null;
-    let inCodeBlock = false;
-    let codeBlockContent = [];
-    let codeBlockType = null;
-    const appendixData = {};
-    let currentAppendixKey = null;
-    const pendingEntries = {};
-    this.clear();
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
-      if (trimmed === "## STM Entries") {
-        currentSection = "entries";
-        continue;
-      }
-      if (trimmed === "## Appendix: Binary Data") {
-        currentSection = "appendix";
-        continue;
-      }
-      if (trimmed === "```" || trimmed === "```json") {
-        if (!inCodeBlock) {
-          inCodeBlock = true;
-          codeBlockContent = [];
-          codeBlockType = currentSection === "appendix" ? "base64" : trimmed === "```json" ? "json" : "value";
+    const isDocument = attributes?.type === "document";
+    switch (action) {
+      case "write":
+        if (isDocument) {
+          this.replace_document_text(key, value);
         } else {
-          inCodeBlock = false;
-          const content = codeBlockContent.join("\n");
-          if (currentSection === "appendix" && currentAppendixKey) {
-            appendixData[currentAppendixKey].base64 = content;
-          } else if (currentEntry && codeBlockType === "json") {
-            currentEntry.value = content;
-          } else if (currentEntry && codeBlockType === "value") {
-            currentEntry.value = content;
-          }
-          codeBlockContent = [];
-          codeBlockType = null;
+          this.set_value(key, value);
         }
-        continue;
-      }
-      if (inCodeBlock) {
-        codeBlockContent.push(line);
-        continue;
-      }
-      if (currentSection === "entries") {
-        if (trimmed.startsWith("### ")) {
-          if (currentKey && currentEntry && currentEntry.attributes) {
-            pendingEntries[currentKey] = currentEntry;
+        return {
+          result: `Successfully wrote "${value}" to ${key}`,
+          key,
+          value
+        };
+      case "append":
+        if (isDocument) {
+          const yText = this.get_document(key);
+          if (yText) {
+            yText.insert(yText.length, value);
+            return {
+              result: `Successfully appended to ${key}`,
+              key,
+              value
+            };
           }
-          currentKey = trimmed.substring(4);
-          currentEntry = {
-            value: void 0,
-            attributes: {
-              ...DEFAULT_KEY_ATTRIBUTES,
-              contentTags: [],
-              systemTags: ["prompt"],
-              tags: []
-            }
+        }
+        return null;
+      case "insert":
+        if (isDocument && typeof value === "object" && value.index !== void 0 && value.text) {
+          this.insert_text(key, value.index, value.text);
+          return {
+            result: `Successfully inserted at position ${value.index} in ${key}`,
+            key,
+            value: value.text
           };
-        } else if (trimmed.startsWith("- **Type**: `")) {
-          const type = trimmed.match(/`([^`]+)`/)?.[1];
-          if (currentEntry && type && type !== "undefined") {
-            currentEntry.attributes.type = type;
-          }
-        } else if (trimmed.startsWith("- **Readonly**: `")) {
-          const value = trimmed.match(/`([^`]+)`/)?.[1] === "true";
-          if (currentEntry) {
-            currentEntry.attributes.readonly = value;
-          }
-        } else if (trimmed.startsWith("- **Visible**: `")) {
-          const value = trimmed.match(/`([^`]+)`/)?.[1] === "true";
-          if (currentEntry) {
-            currentEntry.attributes.visible = value;
-          }
-        } else if (trimmed.startsWith("- **Template**: `")) {
-          const value = trimmed.match(/`([^`]+)`/)?.[1] === "true";
-          if (currentEntry) {
-            currentEntry.attributes.template = value;
-          }
-        } else if (trimmed.startsWith("- **Z-Index**: `")) {
-          const zIndexStr = trimmed.match(/`([^`]+)`/)?.[1];
-          if (currentEntry && zIndexStr) {
-            const zIndex = parseInt(zIndexStr, 10);
-            if (!isNaN(zIndex)) {
-              currentEntry.attributes.zIndex = zIndex;
-            }
-          }
-        } else if (trimmed.startsWith("- **Tags**: `")) {
-          const tagsStr = trimmed.substring(13, trimmed.length - 1);
-          if (currentEntry) {
-            currentEntry.attributes.tags = tagsStr.split("`, `");
-          }
-        } else if (trimmed.startsWith("- **Content Type**: `")) {
-          const contentType = trimmed.match(/`([^`]+)`/)?.[1];
-          if (currentEntry && contentType) {
-            currentEntry.attributes.contentType = contentType;
-          }
-        } else if (trimmed.startsWith("- **Value**: `")) {
-          const value = trimmed.substring(14, trimmed.length - 1);
-          if (currentEntry) {
-            currentEntry.value = value;
-          }
-        } else if (trimmed.startsWith("- **Value**: [See Appendix ")) {
-          const labelMatch = trimmed.match(/Appendix ([A-Z])\]/);
-          if (currentEntry && labelMatch && currentKey) {
-            currentEntry.appendixLabel = labelMatch[1];
-            currentEntry.value = "";
-          }
         }
-      }
-      if (currentSection === "appendix") {
-        if (trimmed.startsWith("### Appendix ")) {
-          const match = trimmed.match(/### Appendix ([A-Z]): (.+)/);
-          if (match) {
-            const label = match[1];
-            const key = match[2];
-            currentAppendixKey = `${label}:${key}`;
-            appendixData[currentAppendixKey] = { contentType: "", base64: "" };
-          }
-        } else if (trimmed.startsWith("**Type**: ")) {
-          const contentType = trimmed.substring(10);
-          if (currentAppendixKey) {
-            appendixData[currentAppendixKey].contentType = contentType;
+        return null;
+      case "edit":
+        if (isDocument && typeof value === "object" && value.find && value.replace !== void 0) {
+          const yText = this.get_document(key);
+          if (yText) {
+            const text = yText.toString();
+            const idx = text.indexOf(value.find);
+            if (idx !== -1) {
+              yText.delete(idx, value.find.length);
+              yText.insert(idx, value.replace);
+              return {
+                result: `Successfully replaced "${value.find}" with "${value.replace}" in ${key}`,
+                key,
+                value: value.replace
+              };
+            }
           }
         }
-      }
+        return null;
+      default:
+        return null;
     }
-    if (currentKey && currentEntry && currentEntry.attributes) {
-      pendingEntries[currentKey] = currentEntry;
-    }
-    Object.entries(pendingEntries).forEach(([key, entry]) => {
-      const appendixLabel = entry.appendixLabel;
-      if (appendixLabel) {
-        const appendixKey = `${appendixLabel}:${key}`;
-        const appendixInfo = appendixData[appendixKey];
-        if (appendixInfo && appendixInfo.base64) {
-          entry.value = appendixInfo.base64;
-          if (!entry.attributes.contentType && appendixInfo.contentType) {
-            entry.attributes.contentType = appendixInfo.contentType;
-          }
-        }
-      }
-      if (entry.value !== void 0 && entry.attributes) {
-        const attrs = entry.attributes;
-        if (attrs.tags && attrs.tags.length > 0 && (!attrs.contentTags || attrs.contentTags.length === 0)) {
-          attrs.contentTags = [...attrs.tags];
-        }
-        if (!attrs.systemTags || attrs.systemTags.length === 0) {
-          const systemTags = [];
-          if (attrs.visible !== false) {
-            systemTags.push("prompt");
-          }
-          if (attrs.readonly) {
-            systemTags.push("readonly");
-          } else {
-            systemTags.push("LLMWrite");
-          }
-          if (attrs.hardcoded) {
-            systemTags.push("protected");
-          }
-          if (attrs.template) {
-            systemTags.push("template");
-          }
-          attrs.systemTags = this.normalizeSystemTags(systemTags);
-        } else {
-          attrs.systemTags = this.normalizeSystemTags(attrs.systemTags);
-        }
-        if (!attrs.contentTags) {
-          attrs.contentTags = [];
-        }
-        if (!attrs.tags) {
-          attrs.tags = [...attrs.contentTags];
-        }
-        const normalizedTags = attrs.systemTags || [];
-        attrs.readonly = normalizedTags.includes("readonly") || !normalizedTags.includes("LLMWrite");
-        attrs.visible = this.hasSystemPrompt(normalizedTags);
-        attrs.hardcoded = normalizedTags.includes("protected");
-        attrs.template = normalizedTags.includes("ApplyTemplate") || normalizedTags.includes("template");
-        this.stm[key] = {
-          value: entry.value,
-          attributes: attrs
-        };
-      }
-    });
-    this.notifyGlobalListeners();
+  }
+  // Internal method stub for legacy compatibility
+  _setFromRemote(_key, _value, _attributes) {
+  }
+  _deleteFromRemote(_key) {
+  }
+  _clearFromRemote() {
   }
 };
-new MindCache();
 
 // src/cloud/index.ts
 init_CloudAdapter();