@fatagnus/dink-sync 1.0.0

package/dist/client/collection.js

@@ -0,0 +1,924 @@
+import { CollectionValidationError } from './validation.js';
+import { SyncStatus, SyncPriority as SyncPriorityEnum } from './types.js';
+import { YjsDocument } from './crdt/yjs-doc.js';
+/**
+ * Generate a unique document ID.
+ */
+function generateId() {
+    // Use crypto.randomUUID if available, otherwise fallback
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    // Fallback for environments without crypto.randomUUID
+    return `${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 11)}`;
+}
+/**
+ * Encode a stored document to Uint8Array for persistence.
+ * Format: [4 bytes yjsUpdate length][yjsUpdate bytes][JSON sync metadata]
+ */
+function encodeStoredDocument(stored) {
+    const syncJson = JSON.stringify(stored.sync);
+    const syncBytes = new TextEncoder().encode(syncJson);
+    // Create buffer: 4 bytes for yjsUpdate length + yjsUpdate + syncBytes
+    const buffer = new Uint8Array(4 + stored.yjsUpdate.length + syncBytes.length);
+    // Write yjsUpdate length as 4 bytes (big endian)
+    const view = new DataView(buffer.buffer);
+    view.setUint32(0, stored.yjsUpdate.length, false);
+    // Write yjsUpdate
+    buffer.set(stored.yjsUpdate, 4);
+    // Write sync metadata
+    buffer.set(syncBytes, 4 + stored.yjsUpdate.length);
+    return buffer;
+}
+/**
+ * Decode a Uint8Array to a stored document.
+ */
+function decodeStoredDocument(data) {
+    // Try new binary format first
+    if (data.length >= 4) {
+        const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const yjsUpdateLength = view.getUint32(0, false);
+        // Validate that this looks like our binary format
+        if (yjsUpdateLength > 0 && yjsUpdateLength < data.length - 4) {
+            const yjsUpdate = data.slice(4, 4 + yjsUpdateLength);
+            const syncBytes = data.slice(4 + yjsUpdateLength);
+            try {
+                const syncJson = new TextDecoder().decode(syncBytes);
+                const sync = JSON.parse(syncJson);
+                return { yjsUpdate, sync };
+            }
+            catch {
+                // Fall through to legacy format
+            }
+        }
+    }
+    // Legacy format: plain JSON with doc and sync fields
+    try {
+        const json = new TextDecoder().decode(data);
+        const parsed = JSON.parse(json);
+        // Convert legacy document to YjsDocument format
+        const yjsDoc = new YjsDocument();
+        if (parsed.doc) {
+            // Store each field from the legacy document
+            for (const [key, value] of Object.entries(parsed.doc)) {
+                yjsDoc.set(key, value);
+            }
+        }
+        else {
+            // Even older format: just the document itself
+            for (const [key, value] of Object.entries(parsed)) {
+                if (key !== 'sync') {
+                    yjsDoc.set(key, value);
+                }
+            }
+        }
+        const yjsUpdate = yjsDoc.encodeStateAsUpdate();
+        yjsDoc.destroy();
+        return {
+            yjsUpdate,
+            sync: parsed.sync ?? { status: SyncStatus.Synced },
+        };
+    }
+    catch {
+        // If all else fails, return empty document
+        const emptyDoc = new YjsDocument();
+        const yjsUpdate = emptyDoc.encodeStateAsUpdate();
+        emptyDoc.destroy();
+        return {
+            yjsUpdate,
+            sync: { status: SyncStatus.Synced },
+        };
+    }
+}
+/**
+ * Extract document fields from a YjsDocument as a typed object.
+ */
+function extractDocFromYjs(yjsDoc, id) {
+    const doc = { id };
+    // Get all fields from the Yjs document
+    const yDoc = yjsDoc.getYDoc();
+    const fields = yDoc.getMap('fields');
+    fields.forEach((value, key) => {
+        if (key !== 'id') {
+            doc[key] = yjsDoc.get(key);
+        }
+    });
+    return doc;
+}
+/**
+ * Create a SyncedDocument from a document and its sync metadata.
+ */
+function createSyncedDocument(doc, sync) {
+    return Object.assign({}, doc, { _sync: sync });
+}
+/**
+ * Create initial sync metadata for a new local document.
+ */
+function createLocalSyncMetadata() {
+    return {
+        status: SyncStatus.Local,
+        lastSyncAttempt: undefined,
+        lastSynced: undefined,
+        retryCount: 0,
+    };
+}
+/**
+ * Creates a collection implementation backed by a persistence provider.
+ * Uses YjsDocument internally for CRDT-based conflict-free merging.
+ */
+export function createCollection(name, persistence) {
+    // In-memory cache of YjsDocuments and sync metadata
+    const yjsDocs = new Map();
+    const syncMetadataCache = new Map();
+    const subscribers = new Set();
+    const rejectedSubscribers = new Set();
+    const conflictSubscribers = new Set();
+    const conflicts = new Map();
+    const tombstones = new Map();
+    const documentPriorities = new Map();
+    let initialized = false;
+    let validator = null;
+    // Default tombstone retention: 7 days
+    const DEFAULT_TOMBSTONE_RETENTION = 7 * 24 * 60 * 60 * 1000;
+    let tombstoneRetention = DEFAULT_TOMBSTONE_RETENTION;
+    // Track last update timestamp for conflict resolution
+    const lastUpdateTimestamps = new Map();
+    // Tombstone collection name for persistence
+    const TOMBSTONE_COLLECTION = `_tombstones_${name}`;
+    /**
+     * Persist a tombstone to storage.
+     */
+    const persistTombstone = async (tombstone) => {
+        const data = new TextEncoder().encode(JSON.stringify(tombstone));
+        await persistence.save(TOMBSTONE_COLLECTION, tombstone.documentId, data);
+    };
+    /**
+     * Delete a tombstone from storage.
+     */
+    const deleteTombstoneFromPersistence = async (id) => {
+        await persistence.delete(TOMBSTONE_COLLECTION, id);
+    };
+    /**
+     * Load tombstones from persistence.
+     */
+    const loadTombstones = async () => {
+        const tombstoneIds = await persistence.list(TOMBSTONE_COLLECTION);
+        for (const id of tombstoneIds) {
+            const data = await persistence.load(TOMBSTONE_COLLECTION, id);
+            if (data) {
+                try {
+                    const tombstone = JSON.parse(new TextDecoder().decode(data));
+                    tombstones.set(id, tombstone);
+                }
+                catch {
+                    // Ignore corrupted tombstone data
+                }
+            }
+        }
+    };
+    /**
+     * Run validation on document data if validator is set.
+     * @param doc - Document data without id
+     * @param skipValidation - Whether to skip validation
+     * @throws CollectionValidationError if validation fails
+     */
+    const runValidation = (doc, skipValidation) => {
+        if (skipValidation || !validator) {
+            return;
+        }
+        const result = validator(doc);
+        if (!result.valid) {
+            throw new CollectionValidationError(result.errors);
+        }
+    };
+    // Load initial data from persistence
+    const initPromise = (async () => {
+        // Load tombstones first
+        await loadTombstones();
+        const docIds = await persistence.list(name);
+        for (const docId of docIds) {
+            const data = await persistence.load(name, docId);
+            if (data) {
+                const stored = decodeStoredDocument(data);
+                // Create YjsDocument and apply the stored update
+                const yjsDoc = new YjsDocument(docId);
+                yjsDoc.applyUpdate(stored.yjsUpdate);
+                yjsDocs.set(docId, yjsDoc);
+                syncMetadataCache.set(docId, stored.sync);
+                // Track the last sync time as the update timestamp for conflict resolution
+                if (stored.sync.lastSynced) {
+                    lastUpdateTimestamps.set(docId, stored.sync.lastSynced);
+                }
+                else if (stored.sync.lastSyncAttempt) {
+                    lastUpdateTimestamps.set(docId, stored.sync.lastSyncAttempt);
+                }
+            }
+        }
+        initialized = true;
+    })();
+    const getDocFromCache = (id) => {
+        const yjsDoc = yjsDocs.get(id);
+        if (!yjsDoc)
+            return null;
+        return extractDocFromYjs(yjsDoc, id);
+    };
+    const getSyncedDocs = () => {
+        const docs = [];
+        for (const [id, yjsDoc] of yjsDocs) {
+            const doc = extractDocFromYjs(yjsDoc, id);
+            const sync = syncMetadataCache.get(id) ?? { status: SyncStatus.Synced };
+            docs.push(createSyncedDocument(doc, sync));
+        }
+        return docs;
+    };
+    const notifySubscribers = () => {
+        const docs = getSyncedDocs();
+        subscribers.forEach(callback => callback(docs));
+    };
+    const notifyRejected = (event) => {
+        rejectedSubscribers.forEach(callback => callback(event));
+    };
+    const notifyConflictDetected = (event) => {
+        conflictSubscribers.forEach(callback => callback(event));
+    };
+    const ensureInitialized = async () => {
+        if (!initialized) {
+            await initPromise;
+        }
+    };
+    const persistDocument = async (id, yjsDoc, sync) => {
+        const stored = {
+            yjsUpdate: yjsDoc.encodeStateAsUpdate(),
+            sync,
+        };
+        const encoded = encodeStoredDocument(stored);
+        await persistence.save(name, id, encoded);
+    };
+    return {
+        name,
+        setValidator(newValidator) {
+            validator = newValidator;
+        },
+        async insert(doc, options) {
+            await ensureInitialized();
+            // Run validation before any persistence
+            runValidation(doc, options?.skipValidation);
+            const id = generateId();
+            const now = Date.now();
+            const syncMetadata = createLocalSyncMetadata();
+            // Create YjsDocument and set all fields
+            const yjsDoc = new YjsDocument(id);
+            for (const [key, value] of Object.entries(doc)) {
+                yjsDoc.set(key, value);
+            }
+            // Store in cache
+            yjsDocs.set(id, yjsDoc);
+            syncMetadataCache.set(id, syncMetadata);
+            // Track update timestamp for conflict resolution
+            lastUpdateTimestamps.set(id, now);
+            // Set priority if specified, otherwise default to normal
+            documentPriorities.set(id, options?.priority ?? SyncPriorityEnum.Normal);
+            // Persist to storage
+            await persistDocument(id, yjsDoc, syncMetadata);
+            // Notify subscribers
+            notifySubscribers();
+            const fullDoc = extractDocFromYjs(yjsDoc, id);
+            return createSyncedDocument(fullDoc, syncMetadata);
+        },
+        async update(id, updates, options) {
+            await ensureInitialized();
+            const yjsDoc = yjsDocs.get(id);
+            if (!yjsDoc) {
+                throw new Error(`Document not found: ${id}`);
+            }
+            // Get current document data and merge with updates for validation
+            const currentDoc = extractDocFromYjs(yjsDoc, id);
+            const { id: _id, ...currentData } = currentDoc;
+            const mergedDoc = { ...currentData, ...updates };
+            // Run validation on merged document before any changes
+            runValidation(mergedDoc, options?.skipValidation);
+            const now = Date.now();
+            // Apply updates to YjsDocument (creates CRDT delta internally)
+            for (const [key, value] of Object.entries(updates)) {
+                yjsDoc.set(key, value);
+            }
+            // Track update timestamp for conflict resolution
+            lastUpdateTimestamps.set(id, now);
+            // Update priority if specified
+            if (options?.priority) {
+                documentPriorities.set(id, options.priority);
+            }
+            // Reset to local status when document is modified
+            const existingSync = syncMetadataCache.get(id);
+            const syncMetadata = {
+                status: SyncStatus.Local,
+                lastSyncAttempt: existingSync?.lastSyncAttempt,
+                lastSynced: existingSync?.lastSynced,
+                retryCount: 0,
+            };
+            syncMetadataCache.set(id, syncMetadata);
+            // Persist to storage
+            await persistDocument(id, yjsDoc, syncMetadata);
+            // Notify subscribers
+            notifySubscribers();
+            const fullDoc = extractDocFromYjs(yjsDoc, id);
+            return createSyncedDocument(fullDoc, syncMetadata);
+        },
+        async delete(id) {
+            await ensureInitialized();
+            // Create tombstone record before deleting
+            const tombstone = {
+                documentId: id,
+                deletedAt: Date.now(),
+                synced: false,
+            };
+            tombstones.set(id, tombstone);
+            // Persist tombstone
+            await persistTombstone(tombstone);
+            // Clean up YjsDocument
+            const yjsDoc = yjsDocs.get(id);
+            if (yjsDoc) {
+                yjsDoc.destroy();
+                yjsDocs.delete(id);
+            }
+            syncMetadataCache.delete(id);
+            lastUpdateTimestamps.delete(id);
+            documentPriorities.delete(id);
+            // Clean up any conflicts
+            conflicts.delete(id);
+            // Delete from persistence
+            await persistence.delete(name, id);
+            // Notify subscribers
+            notifySubscribers();
+        },
+        async get(id) {
+            await ensureInitialized();
+            const doc = getDocFromCache(id);
+            if (!doc)
+                return null;
+            const sync = syncMetadataCache.get(id) ?? { status: SyncStatus.Synced };
+            return createSyncedDocument(doc, sync);
+        },
+        async list() {
+            await ensureInitialized();
+            return getSyncedDocs();
+        },
+        subscribe(callback) {
+            subscribers.add(callback);
+            // Call immediately with current data (after init)
+            // But only if still subscribed when init completes
+            ensureInitialized().then(() => {
+                if (subscribers.has(callback)) {
+                    callback(getSyncedDocs());
+                }
+            });
+            return () => {
+                subscribers.delete(callback);
+            };
+        },
+        onSyncRejected(callback) {
+            rejectedSubscribers.add(callback);
+            return () => {
+                rejectedSubscribers.delete(callback);
+            };
+        },
+        async getSyncStatus(id) {
+            await ensureInitialized();
+            const sync = syncMetadataCache.get(id);
+            if (!sync)
+                return null;
+            return { ...sync };
+        },
+        async retrySync(id) {
+            await ensureInitialized();
+            const yjsDoc = yjsDocs.get(id);
+            if (!yjsDoc) {
+                throw new Error(`Document not found: ${id}`);
+            }
+            const existingSync = syncMetadataCache.get(id);
+            // Reset to local status to trigger re-sync
+            const syncMetadata = {
+                status: SyncStatus.Local,
+                lastSyncAttempt: existingSync?.lastSyncAttempt,
+                lastSynced: existingSync?.lastSynced,
+                retryCount: (existingSync?.retryCount ?? 0) + 1,
+            };
+            syncMetadataCache.set(id, syncMetadata);
+            // Persist to storage
+            await persistDocument(id, yjsDoc, syncMetadata);
+            // Notify subscribers
+            notifySubscribers();
+        },
+        async _markSynced(id) {
+            await ensureInitialized();
+            const yjsDoc = yjsDocs.get(id);
+            if (!yjsDoc)
+                return;
+            const syncMetadata = {
+                status: SyncStatus.Synced,
+                lastSyncAttempt: Date.now(),
+                lastSynced: Date.now(),
+                retryCount: 0,
+            };
+            syncMetadataCache.set(id, syncMetadata);
+            // Persist to storage
+            await persistDocument(id, yjsDoc, syncMetadata);
+            // Notify subscribers
+            notifySubscribers();
+        },
+        async _markRejected(id, error) {
+            await ensureInitialized();
+            const yjsDoc = yjsDocs.get(id);
+            if (!yjsDoc)
+                return;
+            const existingSync = syncMetadataCache.get(id);
+            const syncMetadata = {
+                status: SyncStatus.Rejected,
+                error,
+                lastSyncAttempt: Date.now(),
+                lastSynced: existingSync?.lastSynced,
+                retryCount: (existingSync?.retryCount ?? 0) + 1,
+            };
+            syncMetadataCache.set(id, syncMetadata);
+            // Persist to storage
+            await persistDocument(id, yjsDoc, syncMetadata);
+            // Notify subscribers
+            notifySubscribers();
+            // Emit rejected event
+            const doc = extractDocFromYjs(yjsDoc, id);
+            notifyRejected({
+                collection: name,
+                documentId: id,
+                document: doc,
+                error,
+            });
+        },
+        async _markSyncing(id) {
+            await ensureInitialized();
+            const yjsDoc = yjsDocs.get(id);
+            if (!yjsDoc)
+                return;
+            const existingSync = syncMetadataCache.get(id);
+            const syncMetadata = {
+                status: SyncStatus.Syncing,
+                lastSyncAttempt: Date.now(),
+                lastSynced: existingSync?.lastSynced,
+                retryCount: existingSync?.retryCount ?? 0,
+            };
+            syncMetadataCache.set(id, syncMetadata);
+            // Persist to storage
+            await persistDocument(id, yjsDoc, syncMetadata);
+            // Notify subscribers
+            notifySubscribers();
+        },
+        async getYjsUpdate(id) {
+            await ensureInitialized();
+            const yjsDoc = yjsDocs.get(id);
+            if (!yjsDoc)
+                return null;
+            return yjsDoc.encodeStateAsUpdate();
+        },
+        async getStateVector(id) {
+            await ensureInitialized();
+            const yjsDoc = yjsDocs.get(id);
+            if (!yjsDoc)
+                return null;
+            return yjsDoc.getStateVector();
+        },
+        async getDeltaUpdate(id, sinceStateVector) {
+            await ensureInitialized();
+            const yjsDoc = yjsDocs.get(id);
+            if (!yjsDoc)
+                return null;
+            return yjsDoc.encodeStateAsUpdate(sinceStateVector);
+        },
+        async getConflict(id) {
+            await ensureInitialized();
+            return conflicts.get(id) ?? null;
+        },
+        async resolveConflict(id, choice) {
+            await ensureInitialized();
+            const yjsDoc = yjsDocs.get(id);
+            if (!yjsDoc) {
+                throw new Error(`Document not found: ${id}`);
+            }
+            const conflict = conflicts.get(id);
+            if (!conflict) {
+                throw new Error(`No conflict exists for document: ${id}`);
+            }
+            // Apply the chosen version
+            const chosenVersion = choice === 'local' ? conflict.localVersion : conflict.serverVersion;
+            // Update all fields from chosen version
+            for (const [key, value] of Object.entries(chosenVersion)) {
+                if (key !== 'id') {
+                    yjsDoc.set(key, value);
+                }
+            }
+            // Clear the conflict
+            conflicts.delete(id);
+            // Reset to local status for re-sync
+            const existingSync = syncMetadataCache.get(id);
+            const syncMetadata = {
+                status: SyncStatus.Local,
+                lastSyncAttempt: existingSync?.lastSyncAttempt,
+                lastSynced: existingSync?.lastSynced,
+                retryCount: 0,
+            };
+            syncMetadataCache.set(id, syncMetadata);
+            // Persist to storage
+            await persistDocument(id, yjsDoc, syncMetadata);
+            // Notify subscribers
+            notifySubscribers();
+        },
+        async keepBoth(id) {
+            await ensureInitialized();
+            const yjsDoc = yjsDocs.get(id);
+            if (!yjsDoc) {
+                throw new Error(`Document not found: ${id}`);
+            }
+            const conflict = conflicts.get(id);
+            if (!conflict) {
+                throw new Error(`No conflict exists for document: ${id}`);
+            }
+            // Keep local version in original document
+            for (const [key, value] of Object.entries(conflict.localVersion)) {
+                if (key !== 'id') {
+                    yjsDoc.set(key, value);
+                }
+            }
+            // Clear the conflict for original
+            conflicts.delete(id);
+            // Update original document status
+            const existingSync = syncMetadataCache.get(id);
+            const syncMetadata = {
+                status: SyncStatus.Local,
+                lastSyncAttempt: existingSync?.lastSyncAttempt,
+                lastSynced: existingSync?.lastSynced,
+                retryCount: 0,
+            };
+            syncMetadataCache.set(id, syncMetadata);
+            await persistDocument(id, yjsDoc, syncMetadata);
+            // Create a new document with server version (excluding id)
+            const { id: _serverId, ...serverData } = conflict.serverVersion;
+            const copyDoc = await this.insert(serverData);
+            // Note: insert() already notifies subscribers
+            return copyDoc.id;
+        },
+        async hasConflict(id) {
+            await ensureInitialized();
+            return conflicts.has(id);
+        },
+        async listConflicts() {
+            await ensureInitialized();
+            return Array.from(conflicts.values());
+        },
+        onConflictDetected(callback) {
+            conflictSubscribers.add(callback);
+            return () => {
+                conflictSubscribers.delete(callback);
+            };
+        },
+        async _setConflict(id, conflict) {
+            await ensureInitialized();
+            const yjsDoc = yjsDocs.get(id);
+            if (!yjsDoc) {
+                throw new Error(`Document not found: ${id}`);
+            }
+            conflicts.set(id, conflict);
+            // Emit conflict detected event
+            notifyConflictDetected({
+                collection: name,
+                documentId: id,
+                localVersion: conflict.localVersion,
+                serverVersion: conflict.serverVersion,
+                detectedAt: conflict.detectedAt,
+            });
+        },
+        async applyUpdate(id, update, initialDoc) {
+            await ensureInitialized();
+            let yjsDoc = yjsDocs.get(id);
+            let isNewDoc = false;
+            if (!yjsDoc) {
+                // Create new YjsDocument for this ID
+                yjsDoc = new YjsDocument(id);
+                yjsDocs.set(id, yjsDoc);
+                syncMetadataCache.set(id, createLocalSyncMetadata());
+                isNewDoc = true;
+            }
+            // Apply the external Yjs update (CRDT merge) FIRST
+            // This is important - the update contains the authoritative CRDT state
+            yjsDoc.applyUpdate(update);
+            // Only set initialDoc fields if document is new AND they don't conflict
+            // with the applied update. This is for bootstrapping a document that
+            // will receive updates but needs some initial structure.
+            // In practice, if we have an update, it should contain all the state.
+            if (isNewDoc && initialDoc) {
+                const yDoc = yjsDoc.getYDoc();
+                const fields = yDoc.getMap('fields');
+                for (const [key, value] of Object.entries(initialDoc)) {
+                    // Only set if not already present from the update
+                    if (!fields.has(key)) {
+                        yjsDoc.set(key, value);
+                    }
+                }
+            }
+            // Get current sync metadata
+            const existingSync = syncMetadataCache.get(id);
+            const syncMetadata = isNewDoc ? existingSync : {
+                ...existingSync,
+                // Keep status as-is, the merge doesn't change local sync status
+            };
+            // Persist to storage
+            await persistDocument(id, yjsDoc, syncMetadata);
+            // Notify subscribers
+            notifySubscribers();
+        },
+        // ============ Tombstone Methods ============
+        async getTombstone(id) {
+            await ensureInitialized();
+            return tombstones.get(id) ?? null;
+        },
+        async listTombstones() {
+            await ensureInitialized();
+            return Array.from(tombstones.values());
+        },
+        async getTombstoneDelta() {
+            await ensureInitialized();
+            const unsyncedTombstones = Array.from(tombstones.values()).filter(t => !t.synced);
+            return {
+                collection: name,
+                tombstones: unsyncedTombstones,
+            };
+        },
+        async applyTombstone(remoteTombstone) {
+            await ensureInitialized();
+            const id = remoteTombstone.documentId;
+            const existingTombstone = tombstones.get(id);
+            // If we already have a tombstone, use the newer one
+            if (existingTombstone) {
+                if (remoteTombstone.deletedAt > existingTombstone.deletedAt) {
+                    const updatedTombstone = {
+                        documentId: id,
+                        deletedAt: remoteTombstone.deletedAt,
+                        synced: true, // Remote tombstones are already synced
+                    };
+                    tombstones.set(id, updatedTombstone);
+                    await persistTombstone(updatedTombstone);
+                }
+                return;
+            }
+            // Check if document exists and compare timestamps
+            const lastUpdate = lastUpdateTimestamps.get(id) ?? 0;
+            // Delete wins if tombstone is newer than last update
+            if (remoteTombstone.deletedAt >= lastUpdate) {
+                // Create tombstone
+                const newTombstone = {
+                    documentId: id,
+                    deletedAt: remoteTombstone.deletedAt,
+                    synced: true, // Remote tombstones are already synced
+                };
+                tombstones.set(id, newTombstone);
+                await persistTombstone(newTombstone);
+                // Clean up document if it exists
+                const yjsDoc = yjsDocs.get(id);
+                if (yjsDoc) {
+                    yjsDoc.destroy();
+                    yjsDocs.delete(id);
+                }
+                syncMetadataCache.delete(id);
+                lastUpdateTimestamps.delete(id);
+                conflicts.delete(id);
+                // Delete from persistence
+                await persistence.delete(name, id);
+                // Notify subscribers
+                notifySubscribers();
+            }
+        },
+        async applyUpdateWithTimestamp(id, updates, timestamp) {
+            await ensureInitialized();
+            // Check if there's a newer tombstone
+            const tombstone = tombstones.get(id);
+            if (tombstone && tombstone.deletedAt > timestamp) {
+                // Tombstone is newer, don't resurrect the document
+                return;
+            }
+            // If there's an older tombstone, remove it (document is being resurrected)
+            if (tombstone && tombstone.deletedAt <= timestamp) {
+                tombstones.delete(id);
+            }
+            let yjsDoc = yjsDocs.get(id);
+            if (!yjsDoc) {
+                // Create new document
+                yjsDoc = new YjsDocument(id);
+                yjsDocs.set(id, yjsDoc);
+                syncMetadataCache.set(id, createLocalSyncMetadata());
+            }
+            // Apply updates
+            for (const [key, value] of Object.entries(updates)) {
+                yjsDoc.set(key, value);
+            }
+            // Track the update timestamp
+            lastUpdateTimestamps.set(id, timestamp);
+            // Update sync metadata
+            const existingSync = syncMetadataCache.get(id);
+            const syncMetadata = {
+                status: SyncStatus.Local,
+                lastSyncAttempt: existingSync?.lastSyncAttempt,
+                lastSynced: existingSync?.lastSynced,
+                retryCount: 0,
+            };
+            syncMetadataCache.set(id, syncMetadata);
+            // Persist to storage
+            await persistDocument(id, yjsDoc, syncMetadata);
+            // Notify subscribers
+            notifySubscribers();
+        },
+        async _markTombstoneSynced(id) {
+            await ensureInitialized();
+            const tombstone = tombstones.get(id);
+            if (tombstone) {
+                const updatedTombstone = {
+                    ...tombstone,
+                    synced: true,
+                };
+                tombstones.set(id, updatedTombstone);
+                await persistTombstone(updatedTombstone);
+            }
+        },
+        getTombstoneRetention() {
+            return tombstoneRetention;
+        },
+        setTombstoneRetention(retention) {
+            tombstoneRetention = retention;
+        },
+        async cleanupTombstones() {
+            await ensureInitialized();
+            const now = Date.now();
+            const toDelete = [];
+            for (const [id, tombstone] of tombstones) {
+                // Only clean up tombstones that are:
+                // 1. Synced (so other edges know about the deletion)
+                // 2. Older than the retention period
+                if (tombstone.synced && (now - tombstone.deletedAt) > tombstoneRetention) {
+                    toDelete.push(id);
+                }
+            }
+            for (const id of toDelete) {
+                tombstones.delete(id);
+                await deleteTombstoneFromPersistence(id);
+            }
+        },
+        async _clear() {
+            await ensureInitialized();
+            // Get all document IDs
+            const docIds = Array.from(yjsDocs.keys());
+            // Clean up all YjsDocuments
+            for (const yjsDoc of yjsDocs.values()) {
+                yjsDoc.destroy();
+            }
+            yjsDocs.clear();
+            syncMetadataCache.clear();
+            lastUpdateTimestamps.clear();
+            conflicts.clear();
+            tombstones.clear();
+            documentPriorities.clear();
+            // Delete from persistence
+            for (const docId of docIds) {
+                await persistence.delete(name, docId);
+            }
+            // Delete all tombstones from persistence
+            const tombstoneIds = await persistence.list(TOMBSTONE_COLLECTION);
+            for (const tombstoneId of tombstoneIds) {
+                await persistence.delete(TOMBSTONE_COLLECTION, tombstoneId);
+            }
+            // Notify subscribers that collection is now empty
+            notifySubscribers();
+        },
+        async getPriority(id) {
+            await ensureInitialized();
+            const yjsDoc = yjsDocs.get(id);
+            if (!yjsDoc)
+                return null;
+            return documentPriorities.get(id) ?? SyncPriorityEnum.Normal;
+        },
+        async setPriority(id, priority) {
+            await ensureInitialized();
+            const yjsDoc = yjsDocs.get(id);
+            if (!yjsDoc) {
+                throw new Error(`Document not found: ${id}`);
+            }
+            documentPriorities.set(id, priority);
+        },
+        async setCollectionPriority(priority) {
+            await ensureInitialized();
+            for (const id of yjsDocs.keys()) {
+                documentPriorities.set(id, priority);
+            }
+        },
+        async query(options) {
+            await ensureInitialized();
+            // Start with all documents
+            let results = getSyncedDocs();
+            // Apply filters
+            if (options.filter) {
+                results = results.filter(doc => {
+                    for (const [field, operators] of Object.entries(options.filter)) {
+                        const fieldValue = doc[field];
+                        const ops = operators;
+                        // Check each operator
+                        if (ops.eq !== undefined && fieldValue !== ops.eq) {
+                            return false;
+                        }
+                        if (ops.ne !== undefined && fieldValue === ops.ne) {
+                            return false;
+                        }
+                        if (ops.gt !== undefined) {
+                            if (fieldValue === undefined || fieldValue === null)
+                                return false;
+                            if (fieldValue <= ops.gt)
+                                return false;
+                        }
+                        if (ops.lt !== undefined) {
+                            if (fieldValue === undefined || fieldValue === null)
+                                return false;
+                            if (fieldValue >= ops.lt)
+                                return false;
+                        }
+                        if (ops.gte !== undefined) {
+                            if (fieldValue === undefined || fieldValue === null)
+                                return false;
+                            if (fieldValue < ops.gte)
+                                return false;
+                        }
+                        if (ops.lte !== undefined) {
+                            if (fieldValue === undefined || fieldValue === null)
+                                return false;
+                            if (fieldValue > ops.lte)
+                                return false;
+                        }
+                        if (ops.in !== undefined) {
+                            if (!Array.isArray(ops.in))
+                                return false;
+                            if (ops.in.length === 0)
+                                return false;
+                            if (!ops.in.includes(fieldValue))
+                                return false;
+                        }
+                        if (ops.notIn !== undefined) {
+                            if (!Array.isArray(ops.notIn))
+                                return false;
+                            if (ops.notIn.length > 0 && ops.notIn.includes(fieldValue))
+                                return false;
+                        }
+                        if (ops.contains !== undefined) {
+                            if (!Array.isArray(fieldValue))
+                                return false;
+                            if (!fieldValue.includes(ops.contains))
+                                return false;
+                        }
+                    }
+                    return true;
+                });
+            }
+            // Apply sorting
+            if (options.orderBy) {
+                const { field, direction = 'asc' } = options.orderBy;
+                results = results.sort((a, b) => {
+                    const aVal = a[field];
+                    const bVal = b[field];
+                    // Handle undefined/null values
+                    if (aVal === undefined || aVal === null)
+                        return direction === 'asc' ? 1 : -1;
+                    if (bVal === undefined || bVal === null)
+                        return direction === 'asc' ? -1 : 1;
+                    // Compare values
+                    let comparison = 0;
+                    if (typeof aVal === 'string' && typeof bVal === 'string') {
+                        comparison = aVal.localeCompare(bVal);
+                    }
+                    else if (typeof aVal === 'number' && typeof bVal === 'number') {
+                        comparison = aVal - bVal;
+                    }
+                    else if (typeof aVal === 'boolean' && typeof bVal === 'boolean') {
+                        comparison = (aVal === bVal) ? 0 : (aVal ? 1 : -1);
+                    }
+                    else {
+                        comparison = String(aVal).localeCompare(String(bVal));
+                    }
+                    return direction === 'desc' ? -comparison : comparison;
+                });
+            }
+            // Apply pagination
+            const offset = options.offset ?? 0;
+            const limit = options.limit;
+            if (offset > 0) {
+                results = results.slice(offset);
+            }
+            if (limit !== undefined && limit >= 0) {
+                results = results.slice(0, limit);
+            }
+            return results;
+        },
+    };
+}
+//# sourceMappingURL=collection.js.map