mindoodb 0.0.2 → 0.0.3

package/dist/core/BaseMindooDB.js

@@ -1,41 +1,12 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseMindooDB = void 0;
-const Automerge = __importStar(require("@automerge/automerge"));
+// Import platform-appropriate Automerge implementation
+// React Native: native Rust (react-native-automerge-generated)
+// Browser/Node.js: WASM (@automerge/automerge/slim)
+const automerge_adapter_1 = require("./automerge-adapter");
 const uuid_1 = require("uuid");
+const bloom_1 = require("./appendonlystores/bloom");
 const idGeneration_1 = require("./utils/idGeneration");
 const errors_1 = require("./errors");
 const logging_1 = require("./logging");
@@ -73,6 +44,7 @@ class BaseMindooDB {
         this.docCache = new Map();
         // Track which entry IDs we've already processed
         this.processedEntryIds = [];
+        this.processedEntryCursor = null;
         // Index: automergeHash -> entryId for each document
         // Used for resolving Automerge dependency hashes to entry IDs
         this.automergeHashToEntryId = new Map(); // Map<docId, Map<automergeHash, entryId>>
@@ -265,7 +237,7 @@ class BaseMindooDB {
         this.logger.debug(`Syncing store changes for database ${this.store.getId()} in tenant ${this.tenant.getId()}`);
         this.logger.debug(`Already processed ${this.processedEntryIds.length} entry IDs`);
         // Find new entries that we haven't processed yet
-        const newEntryMetadata = await this.store.findNewEntries(this.processedEntryIds);
+        const newEntryMetadata = await this.getNewEntryMetadataForSync();
         this.logger.debug(`Found ${newEntryMetadata.length} new entries`);
         if (newEntryMetadata.length === 0) {
             this.logger.debug(`No new entries to process`);
@@ -367,6 +339,105 @@ class BaseMindooDB {
         this.processedEntryIds.push(...newEntryMetadata.map(em => em.id));
         this.logger.debug(`Synced ${newEntryMetadata.length} new entries, index now has ${this.index.length} documents`);
     }
+    supportsCursorScan(store) {
+        return typeof store.scanEntriesSince === "function";
+    }
+    async scanAllMetadata(store, filters) {
+        if (!this.supportsCursorScan(store)) {
+            if (filters?.docId) {
+                return store.findNewEntriesForDoc([], filters.docId);
+            }
+            return store.findNewEntries([]);
+        }
+        const all = [];
+        let cursor = null;
+        while (true) {
+            const page = await store.scanEntriesSince(cursor, 1000, filters);
+            all.push(...page.entries);
+            cursor = page.nextCursor;
+            if (!page.hasMore) {
+                break;
+            }
+        }
+        return all;
+    }
+    async getNewEntryMetadataForSync() {
+        if (!this.supportsCursorScan(this.store)) {
+            return this.store.findNewEntries(this.processedEntryIds);
+        }
+        const allNew = [];
+        let cursor = this.processedEntryCursor;
+        while (true) {
+            const page = await this.store.scanEntriesSince(cursor, 1000);
+            allNew.push(...page.entries);
+            cursor = page.nextCursor;
+            if (!page.hasMore) {
+                break;
+            }
+        }
+        this.processedEntryCursor = cursor;
+        return allNew;
+    }
+    async syncEntriesFromStore(sourceStore, targetStore) {
+        let transferred = 0;
+        let targetBloom = null;
+        if (typeof targetStore.getIdBloomSummary === "function") {
+            try {
+                targetBloom = await targetStore.getIdBloomSummary();
+            }
+            catch (error) {
+                this.logger.warn("Failed to get bloom summary from target store, falling back to exact checks", error);
+            }
+        }
+        if (this.supportsCursorScan(sourceStore)) {
+            let cursor = null;
+            while (true) {
+                const page = await sourceStore.scanEntriesSince(cursor, 1000);
+                if (page.entries.length > 0) {
+                    const ids = page.entries.map((m) => m.id);
+                    let definitelyMissing = [];
+                    let maybeExisting = ids;
+                    if (targetBloom) {
+                        definitelyMissing = [];
+                        maybeExisting = [];
+                        for (const id of ids) {
+                            if ((0, bloom_1.bloomMightContainId)(targetBloom, id)) {
+                                maybeExisting.push(id);
+                            }
+                            else {
+                                definitelyMissing.push(id);
+                            }
+                        }
+                    }
+                    let missingIds = definitelyMissing;
+                    if (maybeExisting.length > 0) {
+                        const existing = await targetStore.hasEntries(maybeExisting);
+                        const existingSet = new Set(existing);
+                        const maybeMissing = maybeExisting.filter((id) => !existingSet.has(id));
+                        missingIds = missingIds.concat(maybeMissing);
+                    }
+                    if (missingIds.length > 0) {
+                        const missingEntries = await sourceStore.getEntries(missingIds);
+                        await targetStore.putEntries(missingEntries);
+                        transferred += missingEntries.length;
+                    }
+                }
+                cursor = page.nextCursor;
+                if (!page.hasMore) {
+                    break;
+                }
+            }
+            return transferred;
+        }
+        const targetIds = await targetStore.getAllIds();
+        const sourceNewMetadata = await sourceStore.findNewEntries(targetIds);
+        if (sourceNewMetadata.length === 0) {
+            return 0;
+        }
+        const sourceEntries = await sourceStore.getEntries(sourceNewMetadata.map((m) => m.id));
+        await targetStore.putEntries(sourceEntries);
+        return sourceEntries.length;
+    }
     getStore() {
         return this.store;
     }
@@ -407,18 +478,18 @@ class BaseMindooDB {
         const docId = (0, uuid_1.v7)();
         this.logger.debug(`Creating document ${docId} with key ${keyId}${useCustomSigningKey ? ' using custom signing key' : ''}`);
         // Create initial Automerge document
-        const initialDoc = Automerge.init();
+        const initialDoc = automerge_adapter_1.Automerge.init();
         // Create the first change
         const now = Date.now();
         this.logger.debug(`Creating initial Automerge change for document ${docId}`);
         let newDoc;
         try {
-            newDoc = Automerge.change(initialDoc, (doc) => {
+            newDoc = automerge_adapter_1.Automerge.change(initialDoc, (doc) => {
                 // Store metadata in the document payload
                 // We need to modify the document to ensure a change is created
                 doc._attachments = [];
             });
-            this.logger.debug(`Successfully created Automerge change, document heads: ${JSON.stringify(Automerge.getHeads(newDoc))}`);
+            this.logger.debug(`Successfully created Automerge change, document heads: ${JSON.stringify(automerge_adapter_1.Automerge.getHeads(newDoc))}`);
         }
         catch (error) {
             this.logger.error(`Error in Automerge.change for document ${docId}:`, error);
@@ -426,7 +497,7 @@ class BaseMindooDB {
         }
         // Get the change bytes from the document
         this.logger.debug(`Getting change bytes from document ${docId}`);
-        const changeBytes = Automerge.getLastLocalChange(newDoc);
+        const changeBytes = automerge_adapter_1.Automerge.getLastLocalChange(newDoc);
         if (!changeBytes) {
             throw new Error("Failed to get change bytes from Automerge document");
         }
@@ -435,7 +506,7 @@ class BaseMindooDB {
         this.logger.debug(`Decoding change to get hash and dependencies`);
         let decodedChange;
         try {
-            decodedChange = Automerge.decodeChange(changeBytes);
+            decodedChange = automerge_adapter_1.Automerge.decodeChange(changeBytes);
             this.logger.debug(`Successfully decoded change, hash: ${decodedChange.hash}, deps: ${decodedChange.deps?.length || 0}`);
         }
         catch (error) {
@@ -523,7 +594,7 @@ class BaseMindooDB {
     async getDocumentAtTimestamp(docId, timestamp) {
         this.logger.debug(`Getting document ${docId} at timestamp ${timestamp}`);
         // Get all entry metadata for this document
-        const allEntryMetadata = await this.store.findNewEntriesForDoc([], docId);
+        const allEntryMetadata = await this.scanAllMetadata(this.store, { docId });
         // Filter entries up to the timestamp
         const relevantEntries = allEntryMetadata
             .filter(em => em.createdAt <= timestamp)
@@ -534,7 +605,7 @@ class BaseMindooDB {
         // Load entries
         const entries = await this.store.getEntries(relevantEntries.map(em => em.id));
         // Apply changes in order
-        let doc = Automerge.init();
+        let doc = automerge_adapter_1.Automerge.init();
         for (const entryData of entries) {
             // Admin-only mode: only accept entries signed by the admin key
             if (this._isAdminOnlyDb && entryData.createdByPublicKey !== this.getAdminPublicKey()) {
@@ -551,7 +622,7 @@ class BaseMindooDB {
             // Decrypt payload (only after signature verification passes)
             const decryptedPayload = await this.tenant.decryptPayload(entryData.encryptedData, entryData.decryptionKeyId);
             // Apply change using loadIncremental - this is the recommended way for binary change data
-            doc = Automerge.loadIncremental(doc, decryptedPayload);
+            doc = automerge_adapter_1.Automerge.loadIncremental(doc, decryptedPayload);
             // Register the automerge hash -> entry ID mapping for future dependency resolution
             const parsed = (0, idGeneration_1.parseDocEntryId)(entryData.id);
             if (parsed) {
@@ -581,7 +652,7 @@ class BaseMindooDB {
     async *iterateDocumentHistory(docId) {
         this.logger.debug(`Iterating document history for ${docId}`);
         // Get all entry metadata for this document
-        const allEntryMetadata = await this.store.findNewEntriesForDoc([], docId);
+        const allEntryMetadata = await this.scanAllMetadata(this.store, { docId });
         // Filter to only doc_create, doc_change, and doc_delete entries (exclude snapshots)
         const relevantEntries = allEntryMetadata
             .filter(em => em.entryType === "doc_create" || em.entryType === "doc_change" || em.entryType === "doc_delete")
@@ -623,17 +694,17 @@ class BaseMindooDB {
                     this.logger.warn(`First entry is not doc_create, skipping`);
                     continue;
                 }
-                currentDoc = Automerge.init();
+                currentDoc = automerge_adapter_1.Automerge.init();
                 createdAt = entryMetadata.createdAt;
                 decryptionKeyId = entryMetadata.decryptionKeyId;
             }
             // Check document heads before applying change (for non-first entries)
-            const headsBefore = isFirstEntry ? null : (currentDoc ? Automerge.getHeads(currentDoc) : null);
+            const headsBefore = isFirstEntry ? null : (currentDoc ? automerge_adapter_1.Automerge.getHeads(currentDoc) : null);
             // Apply change using loadIncremental
             if (currentDoc === null) {
                 throw new Error("currentDoc should not be null at this point");
             }
-            currentDoc = Automerge.loadIncremental(currentDoc, decryptedPayload);
+            currentDoc = automerge_adapter_1.Automerge.loadIncremental(currentDoc, decryptedPayload);
             // Check if document actually changed by comparing heads
             // For first entry (doc_create), always yield since it's the initial creation
             // For delete entries, always yield
@@ -643,7 +714,7 @@ class BaseMindooDB {
                 shouldYield = true;
             }
             else {
-                const headsAfter = Automerge.getHeads(currentDoc);
+                const headsAfter = automerge_adapter_1.Automerge.getHeads(currentDoc);
                 const headsChanged = headsBefore !== null && JSON.stringify(headsBefore) !== JSON.stringify(headsAfter);
                 shouldYield = headsChanged;
             }
@@ -655,7 +726,7 @@ class BaseMindooDB {
             // Only yield if document actually changed (or if this is create/delete entry)
             if (shouldYield) {
                 // Clone the document to ensure independence
-                const clonedDoc = Automerge.clone(currentDoc);
+                const clonedDoc = automerge_adapter_1.Automerge.clone(currentDoc);
                 // Create internal doc representation
                 const internalDoc = {
                     id: docId,
@@ -690,10 +761,14 @@ class BaseMindooDB {
         return docIds;
     }
     async getAllDocumentIdsAtTimestamp(timestamp) {
+        // findEntries() uses an exclusive upper bound (createdAt < creationDateUntil).
+        // Query up to timestamp + 1 so entries created exactly at `timestamp` are included
+        // for the strict checks below (createTime < timestamp, deleteTime > timestamp).
+        const upperBoundExclusive = timestamp === Number.MAX_SAFE_INTEGER ? timestamp : timestamp + 1;
         // Efficiently query for doc_create and doc_delete entries before the timestamp
         const [creates, deletes] = await Promise.all([
-            this.store.findEntries("doc_create", null, timestamp),
-            this.store.findEntries("doc_delete", null, timestamp)
+            this.store.findEntries("doc_create", null, upperBoundExclusive),
+            this.store.findEntries("doc_delete", null, upperBoundExclusive)
         ]);
         // Build sets of docIds for efficient lookup
         const createdDocIds = new Set();
@@ -722,9 +797,9 @@ class BaseMindooDB {
             const createTime = createTimes.get(docId);
             const deleteTime = deleteTimes.get(docId);
             // Document exists at timestamp if:
-            // 1. It was created before the timestamp
+            // 1. It was created at or before the timestamp
             // 2. Either it was never deleted, or it was deleted after the timestamp
-            if (createTime < timestamp) {
+            if (createTime <= timestamp) {
                 if (!deleteTime || deleteTime > timestamp) {
                     docIds.push(docId);
                 }
@@ -764,7 +839,7 @@ class BaseMindooDB {
         // Create deletion change by clearing all fields from the document
         // This ensures Automerge produces actual change bytes
         // The deletion is also tracked via the "doc_delete" type entry in the append-only store
-        const newDoc = Automerge.change(internalDoc.doc, (doc) => {
+        const newDoc = automerge_adapter_1.Automerge.change(internalDoc.doc, (doc) => {
             // Remove all fields from the document
             for (const key of Object.keys(doc)) {
                 delete doc[key];
@@ -773,12 +848,12 @@ class BaseMindooDB {
             doc._deleted = true;
         });
         // Get the change bytes from the document
-        const changeBytes = Automerge.getLastLocalChange(newDoc);
+        const changeBytes = automerge_adapter_1.Automerge.getLastLocalChange(newDoc);
         if (!changeBytes) {
             throw new Error("Failed to get change bytes from Automerge document");
         }
         // Decode the change to get hash and dependencies
-        const decodedChange = Automerge.decodeChange(changeBytes);
+        const decodedChange = automerge_adapter_1.Automerge.decodeChange(changeBytes);
         const automergeHash = decodedChange.hash;
         const automergeDepHashes = decodedChange.deps || []; // Dependencies from the decoded change
         // Encrypt the change payload first
@@ -873,7 +948,7 @@ class BaseMindooDB {
         // Apply the change function
         const now = Date.now();
         this.logger.debug(`Applying change function to document ${docId}`);
-        this.logger.debug(`Document state before change: heads=${JSON.stringify(Automerge.getHeads(internalDoc.doc))}`);
+        this.logger.debug(`Document state before change: heads=${JSON.stringify(automerge_adapter_1.Automerge.getHeads(internalDoc.doc))}`);
         // For async callbacks, we need to handle document modifications carefully.
         // Automerge.change() requires synchronous modifications, so we'll:
         // 1. Execute the async callback to do any async work (like signing)
@@ -916,8 +991,8 @@ class BaseMindooDB {
                             pendingDeletions.delete(prop);
                             // Track the change
                             pendingChanges.set(prop, value);
-                            // Also set on the target for immediate access
-                            target[prop] = value;
+                            // NOTE: Don't set on target immediately - Automerge requires changes
+                            // to be made inside Automerge.change(). Pending changes are applied later.
                         }
                         return true;
                     },
@@ -928,8 +1003,8 @@ class BaseMindooDB {
                             pendingDeletions.add(prop);
                             // Remove from pending changes if it was there
                             pendingChanges.delete(prop);
-                            // Also delete from the target for immediate access
-                            delete target[prop];
+                            // NOTE: Don't delete from target immediately - Automerge requires changes
+                            // to be made inside Automerge.change(). Pending deletions are applied later.
                         }
                         return true;
                     },
@@ -1048,7 +1123,7 @@ class BaseMindooDB {
         // Now apply the collected changes synchronously in Automerge.change()
         let newDoc;
         try {
-            newDoc = Automerge.change(internalDoc.doc, (automergeDoc) => {
+            newDoc = automerge_adapter_1.Automerge.change(internalDoc.doc, (automergeDoc) => {
                 // Apply all pending changes (sets/updates)
                 for (const [key, value] of pendingChanges) {
                     automergeDoc[key] = value;
@@ -1087,7 +1162,7 @@ class BaseMindooDB {
                 // Update lastModified timestamp
                 automergeDoc._lastModified = now;
             });
-            this.logger.debug(`Successfully applied change function, new document heads: ${JSON.stringify(Automerge.getHeads(newDoc))}`);
+            this.logger.debug(`Successfully applied change function, new document heads: ${JSON.stringify(automerge_adapter_1.Automerge.getHeads(newDoc))}`);
         }
         catch (error) {
             this.logger.error(`Error in Automerge.change for document ${docId}:`, error);
@@ -1095,14 +1170,14 @@ class BaseMindooDB {
         }
         // Get the change bytes from the document
         this.logger.debug(`Getting change bytes from document ${docId}`);
-        const changeBytes = Automerge.getLastLocalChange(newDoc);
+        const changeBytes = automerge_adapter_1.Automerge.getLastLocalChange(newDoc);
         if (!changeBytes) {
             //TODO decide if we just exit here or throw an error
             throw new Error("Failed to get change bytes from Automerge document");
         }
         this.logger.debug(`Got change bytes: ${changeBytes.length} bytes`);
         // Decode the change to get hash and dependencies
-        const decodedChange = Automerge.decodeChange(changeBytes);
+        const decodedChange = automerge_adapter_1.Automerge.decodeChange(changeBytes);
         const automergeHash = decodedChange.hash;
         const automergeDepHashes = decodedChange.deps || []; // Dependencies from the decoded change
         // Encrypt the change payload first
@@ -1256,7 +1331,7 @@ class BaseMindooDB {
         }
         this.logger.debug(`Applying ${newEntryMetadata.length} new entries to cached document ${docId}`);
         // Get current document heads to check if it changes
-        const headsBefore = Automerge.getHeads(cachedDoc.doc);
+        const headsBefore = automerge_adapter_1.Automerge.getHeads(cachedDoc.doc);
         // Filter entries to only include change entries (exclude snapshots)
         const entriesToApply = newEntryMetadata.filter(em => em.entryType === "doc_create" || em.entryType === "doc_change" || em.entryType === "doc_delete");
         if (entriesToApply.length === 0) {
@@ -1340,12 +1415,12 @@ class BaseMindooDB {
         // Clone the cached document to avoid "outdated document" error
         // This happens when the document has been wrapped and returned to the user
         // Automerge marks documents as outdated when they're accessed, preventing direct mutation
-        const clonedDoc = Automerge.clone(cachedDoc.doc);
+        const clonedDoc = automerge_adapter_1.Automerge.clone(cachedDoc.doc);
         // Apply all changes at once (Automerge handles dependency ordering)
-        const result = Automerge.applyChanges(clonedDoc, changeBytes);
+        const result = automerge_adapter_1.Automerge.applyChanges(clonedDoc, changeBytes);
         const updatedDoc = result[0];
         // Check if document actually changed
-        const headsAfter = Automerge.getHeads(updatedDoc);
+        const headsAfter = automerge_adapter_1.Automerge.getHeads(updatedDoc);
         const headsChanged = JSON.stringify(headsBefore) !== JSON.stringify(headsAfter);
         if (!headsChanged) {
             this.logger.debug(`Document ${docId} heads unchanged after applying new entries`);
@@ -1385,7 +1460,7 @@ class BaseMindooDB {
         // Get all entry metadata for this document
         // TODO: Implement loading from last snapshot if available
         this.logger.debug(`Getting all entry hashes for document ${docId}`);
-        const allEntryMetadata = await this.store.findNewEntriesForDoc([], docId);
+        const allEntryMetadata = await this.scanAllMetadata(this.store, { docId });
         this.logger.debug(`Found ${allEntryMetadata.length} total entry hashes for document ${docId}`);
         if (allEntryMetadata.length === 0) {
             this.logger.debug(`No entry hashes found for document ${docId}, returning null`);
@@ -1447,8 +1522,8 @@ class BaseMindooDB {
                     // This deserializes a full document snapshot from binary data
                     // According to Automerge docs: load() is equivalent to init() followed by loadIncremental()
                     this.logger.debug(`Loading snapshot into Automerge document`);
-                    doc = Automerge.load(decryptedSnapshot);
-                    this.logger.debug(`Successfully loaded snapshot, document heads: ${JSON.stringify(Automerge.getHeads(doc))}`);
+                    doc = automerge_adapter_1.Automerge.load(decryptedSnapshot);
+                    this.logger.debug(`Successfully loaded snapshot, document heads: ${JSON.stringify(automerge_adapter_1.Automerge.getHeads(doc))}`);
                     // Register the snapshot's automerge hash -> entry ID mapping
                     const parsed = (0, idGeneration_1.parseDocEntryId)(snapshotData.id);
                     if (parsed) {
@@ -1460,8 +1535,8 @@ class BaseMindooDB {
         // If we don't have a snapshot, start from scratch
         if (!doc) {
             this.logger.debug(`Initializing new Automerge document for ${docId}`);
-            doc = Automerge.init();
-            this.logger.debug(`Initialized empty document, heads: ${JSON.stringify(Automerge.getHeads(doc))}`);
+            doc = automerge_adapter_1.Automerge.init();
+            this.logger.debug(`Initialized empty document, heads: ${JSON.stringify(automerge_adapter_1.Automerge.getHeads(doc))}`);
         }
         // Sort entries by timestamp
         entriesToLoad.sort((a, b) => a.createdAt - b.createdAt);
@@ -1472,7 +1547,7 @@ class BaseMindooDB {
         this.logger.debug(`Retrieved ${entries.length} entries from store for document ${docId}`);
         this.logger.debug(`Loading document ${docId}: found ${entries.length} entries to apply (${startFromSnapshot ? 'starting from snapshot' : 'starting from scratch'})`);
         // Log current document state before applying entries
-        this.logger.debug(`Document state before applying entries: heads=${JSON.stringify(Automerge.getHeads(doc))}`);
+        this.logger.debug(`Document state before applying entries: heads=${JSON.stringify(automerge_adapter_1.Automerge.getHeads(doc))}`);
         // Filter entries for admin-only mode first
         const validEntries = entries.filter(entryData => {
             if (this._isAdminOnlyDb && entryData.createdByPublicKey !== this.getAdminPublicKey()) {
@@ -1551,10 +1626,10 @@ class BaseMindooDB {
                 if (changeBytes.length > 0) {
                     this.logger.debug(`Applying ${changeBytes.length} changes to document ${docId} using batch applyChanges`);
                     try {
-                        const result = Automerge.applyChanges(doc, changeBytes);
+                        const result = automerge_adapter_1.Automerge.applyChanges(doc, changeBytes);
                         doc = result[0];
                         this.logger.debug(`Successfully applied ${changeBytes.length} changes to document ${docId}`);
-                        this.logger.debug(`Document state after applying changes: heads=${JSON.stringify(Automerge.getHeads(doc))}`);
+                        this.logger.debug(`Document state after applying changes: heads=${JSON.stringify(automerge_adapter_1.Automerge.getHeads(doc))}`);
                     }
                     catch (error) {
                         this.logger.error(`Error applying changes to document ${docId}:`, error);
@@ -1566,7 +1641,7 @@ class BaseMindooDB {
         }
         // Extract metadata from document (doc is guaranteed to be defined at this point)
         this.logger.debug(`All entries applied successfully for document ${docId}`);
-        this.logger.debug(`Final document heads: ${JSON.stringify(Automerge.getHeads(doc))}`);
+        this.logger.debug(`Final document heads: ${JSON.stringify(automerge_adapter_1.Automerge.getHeads(doc))}`);
         const payload = doc;
         // Check if document was deleted by looking for a "doc_delete" type entry
         const hasDeleteEntry = allEntryMetadata.some(em => em.entryType === "doc_delete");
@@ -1594,6 +1669,50 @@ class BaseMindooDB {
         this.logger.debug(`===== Successfully loaded document ${docId} and cached it =====`);
         return internalDoc;
     }
+    /**
+     * Convert an Automerge document to a plain JS object, converting Text objects to strings.
+     * If using native Automerge (react-native-automerge-generated), this uses the native
+     * materialize() method which properly converts Text objects to strings.
+     * Falls back to direct access if native backend is not available.
+     */
+    convertAutomergeToJS(doc) {
+        // Check if this document has a native Automerge handle attached
+        // The native implementation attaches metadata with Symbol.for('_am_meta')
+        const STATE = Symbol.for('_am_meta');
+        const meta = doc[STATE];
+        if (meta && meta.handle && typeof meta.handle.materialize === 'function') {
+            // Use native materialize() which properly converts Text objects to strings
+            try {
+                const materialized = meta.handle.materialize('/');
+                return materialized;
+            }
+            catch (error) {
+                console.error('[MindooDB] Failed to materialize document:', error);
+                // Fall through to direct access
+            }
+        }
+        // Fallback: direct access (for WASM or if native fails)
+        const result = {};
+        const keys = Object.keys(doc);
+        for (const key of keys) {
+            const value = doc[key];
+            if (value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Uint8Array)) {
+                result[key] = this.convertAutomergeToJS(value);
+            }
+            else if (Array.isArray(value)) {
+                result[key] = value.map(item => {
+                    if (item !== null && typeof item === 'object' && !Array.isArray(item) && !(item instanceof Uint8Array)) {
+                        return this.convertAutomergeToJS(item);
+                    }
+                    return item;
+                });
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
     /**
      * Wrap an internal document in the MindooDoc interface.
      * This is the read-only wrapper - write methods throw errors.
@@ -1626,7 +1745,11 @@ class BaseMindooDB {
             getCreatedAt: () => internalDoc.createdAt,
             getLastModified: () => internalDoc.lastModified,
             isDeleted: () => internalDoc.isDeleted,
-            getData: () => createReadOnlyProxy(internalDoc.doc),
+            getData: () => {
+                // Convert Automerge document to plain JS object, converting Text objects to strings
+                const jsDoc = this.convertAutomergeToJS(internalDoc.doc);
+                return createReadOnlyProxy(jsDoc);
+            },
             // ========== Attachment Write Methods ==========
             // These throw errors in the read-only wrapper
             addAttachment: async () => {
@@ -2019,27 +2142,16 @@ class BaseMindooDB {
             throw new Error(`[BaseMindooDB] Cannot pull entries from the incompatible store ${this.store.getId()}`);
         }
         this.logger.info(`Pulling entries from remote store ${remoteStore.getId()}`);
-        // Get all entry IDs we already have in our local store
-        const localEntryIds = await this.store.getAllIds();
-        this.logger.debug(`Local store has ${localEntryIds.length} entry IDs`);
-        // Find entries in the remote store that we don't have
-        const newEntryMetadata = await remoteStore.findNewEntries(localEntryIds);
-        this.logger.debug(`Found ${newEntryMetadata.length} new entries in remote store`);
-        if (newEntryMetadata.length === 0) {
+        const transferred = await this.syncEntriesFromStore(remoteStore, this.store);
+        this.logger.debug(`Transferred ${transferred} entries from remote store`);
+        if (transferred === 0) {
             this.logger.debug(`No new entries to pull`);
             return;
         }
-        // Get the full entries from the remote store
-        const newEntries = await remoteStore.getEntries(newEntryMetadata.map(em => em.id));
-        this.logger.debug(`Retrieved ${newEntries.length} entries from remote store`);
-        // Store all entries in our local store
-        // The putEntries method handles deduplication (no-op if entry already exists)
-        await this.store.putEntries(newEntries);
-        this.logger.debug(`Stored ${newEntries.length} entries in local store`);
         // Sync the local store to process the new entries
         // This will update the index, cache, and processedEntryIds
         await this.syncStoreChanges();
-        this.logger.info(`Pull complete, synced ${newEntries.length} entries`);
+        this.logger.info(`Pull complete, synced ${transferred} entries`);
     }
     /**
      * Push changes to a remote content-addressed store.
@@ -2057,23 +2169,13 @@ class BaseMindooDB {
             throw new Error(`[BaseMindooDB] Cannot push entries to the incompatible store ${this.store.getId()}`);
         }
         this.logger.info(`Pushing entries to remote store ${remoteStore.getId()}`);
-        // Get all entry IDs the remote store already has
-        const remoteEntryIds = await remoteStore.getAllIds();
-        this.logger.debug(`Remote store has ${remoteEntryIds.length} entry IDs`);
-        // Find entries in our local store that the remote doesn't have
-        const newEntryMetadata = await this.store.findNewEntries(remoteEntryIds);
-        this.logger.debug(`Found ${newEntryMetadata.length} new entries to push`);
-        if (newEntryMetadata.length === 0) {
+        const transferred = await this.syncEntriesFromStore(this.store, remoteStore);
+        this.logger.debug(`Transferred ${transferred} entries to remote store`);
+        if (transferred === 0) {
             this.logger.debug(`No new entries to push`);
             return;
         }
-        // Get the full entries from our local store
-        const newEntries = await this.store.getEntries(newEntryMetadata.map(em => em.id));
-        this.logger.debug(`Retrieved ${newEntries.length} entries from local store`);
-        // Store all entries in the remote store
-        // The putEntries method handles deduplication (no-op if entry already exists)
-        await remoteStore.putEntries(newEntries);
-        this.logger.info(`Pushed ${newEntries.length} entries to remote store`);
+        this.logger.info(`Pushed ${transferred} entries to remote store`);
     }
 }
 exports.BaseMindooDB = BaseMindooDB;