@trestleinc/replicate 0.1.0 → 1.1.0

package/dist/index.js

@@ -1,375 +1,1620 @@
-import { componentsGeneric } from "convex/server";
-import { NonRetriableError, startOfflineExecutor } from "@tanstack/offline-transactions";
+import { Doc, Map as external_yjs_Map, UndoManager, XmlElement, XmlFragment, XmlText, applyUpdateV2, encodeStateAsUpdateV2, encodeStateVector } from "yjs";
+import { createMutex } from "lib0/mutex";
+import { Context, Data, Effect, Layer } from "effect";
 import { getLogger } from "@logtape/logtape";
-import * as __WEBPACK_EXTERNAL_MODULE_yjs__ from "yjs";
-componentsGeneric();
-class ReplicateStorage {
-    component;
-    collectionName;
-    constructor(component, collectionName){
-        this.component = component;
-        this.collectionName = collectionName;
-    }
-    async insertDocument(ctx, documentId, crdtBytes, version) {
-        return ctx.runMutation(this.component.public.insertDocument, {
-            collectionName: this.collectionName,
-            documentId,
-            crdtBytes,
-            version
+import { IndexeddbPersistence } from "y-indexeddb";
+import { BrowserLevel } from "browser-level";
+import { LeveldbPersistence } from "y-leveldb";
+import { AbstractIterator, AbstractKeyIterator, AbstractLevel, AbstractValueIterator } from "abstract-level";
+function logger_getLogger(category) {
+    return getLogger([
+        'replicate',
+        ...category
+    ]);
+}
+class NetworkError extends Data.TaggedError('NetworkError') {
+}
+class IDBError extends Data.TaggedError('IDBError') {
+}
+class IDBWriteError extends Data.TaggedError('IDBWriteError') {
+}
+class ReconciliationError extends Data.TaggedError('ReconciliationError') {
+}
+class ProseError extends Data.TaggedError('ProseError') {
+}
+class CollectionNotReadyError extends Data.TaggedError('CollectionNotReadyError') {
+}
+class NonRetriableError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'NonRetriableError';
+    }
+}
+class Checkpoint extends Context.Tag('Checkpoint')() {
+}
+function createCheckpointLayer(kv) {
+    return Layer.succeed(Checkpoint, Checkpoint.of({
+        loadCheckpoint: (collection)=>Effect.gen(function*(_) {
+                const key = `checkpoint:${collection}`;
+                const stored = yield* _(Effect.tryPromise({
+                    try: ()=>kv.get(key),
+                    catch: (cause)=>new IDBError({
+                            operation: 'get',
+                            key,
+                            cause
+                        })
+                }));
+                if (stored) {
+                    yield* _(Effect.logDebug('Loaded checkpoint from storage', {
+                        collection,
+                        checkpoint: stored
+                    }));
+                    return stored;
+                }
+                yield* _(Effect.logDebug('No stored checkpoint, using default', {
+                    collection
+                }));
+                return {
+                    lastModified: 0
+                };
+            }),
+        saveCheckpoint: (collection, checkpoint)=>Effect.gen(function*(_) {
+                const key = `checkpoint:${collection}`;
+                yield* _(Effect.tryPromise({
+                    try: ()=>kv.set(key, checkpoint),
+                    catch: (cause)=>new IDBWriteError({
+                            key,
+                            value: checkpoint,
+                            cause
+                        })
+                }));
+                yield* _(Effect.logDebug('Checkpoint saved', {
+                    collection,
+                    checkpoint
+                }));
+            }),
+        clearCheckpoint: (collection)=>Effect.gen(function*(_) {
+                const key = `checkpoint:${collection}`;
+                yield* _(Effect.tryPromise({
+                    try: ()=>kv.del(key),
+                    catch: (cause)=>new IDBError({
+                            operation: 'delete',
+                            key,
+                            cause
+                        })
+                }));
+                yield* _(Effect.logDebug('Checkpoint cleared', {
+                    collection
+                }));
+            })
+    }));
+}
+const logger = logger_getLogger([
+    'replicate',
+    'merge'
+]);
+async function createYjsDocument(collection, kv) {
+    const clientIdKey = `yjsClientId:${collection}`;
+    let clientId = await kv.get(clientIdKey);
+    if (!clientId) {
+        clientId = Math.floor(2147483647 * Math.random());
+        await kv.set(clientIdKey, clientId);
+        logger.info('Generated new Yjs clientID', {
+            collection,
+            clientId
         });
     }
-    async updateDocument(ctx, documentId, crdtBytes, version) {
-        return ctx.runMutation(this.component.public.updateDocument, {
-            collectionName: this.collectionName,
-            documentId,
-            crdtBytes,
-            version
+    const ydoc = new Doc({
+        guid: collection,
+        clientID: clientId
+    });
+    logger.info('Created Yjs document', {
+        collection,
+        clientId
+    });
+    return ydoc;
+}
+function applyUpdate(doc, update, origin) {
+    applyUpdateV2(doc, update, origin);
+}
+function getYMap(doc, name) {
+    return doc.getMap(name);
+}
+function yjsTransact(doc, fn, origin) {
+    return doc.transact(fn, origin);
+}
+function transactWithDelta(doc, fn, origin) {
+    const beforeVector = encodeStateVector(doc);
+    const result = doc.transact(fn, origin);
+    const delta = encodeStateAsUpdateV2(doc, beforeVector);
+    return {
+        result,
+        delta
+    };
+}
+function isYjsAbstractType(value) {
+    if (null === value || 'object' != typeof value) return false;
+    const v = value;
+    return '_map' in v && '_eH' in v && 'doc' in v;
+}
+function isYMap(value) {
+    if (!isYjsAbstractType(value)) return false;
+    const v = value;
+    return 'function' == typeof v.keys && 'function' == typeof v.get;
+}
+function isYArray(value) {
+    if (!isYjsAbstractType(value)) return false;
+    const v = value;
+    return 'function' == typeof v.toArray && 'function' != typeof v.get;
+}
+function isYXmlFragment(value) {
+    if (!isYjsAbstractType(value)) return false;
+    const v = value;
+    return 'function' == typeof v.toArray && 'function' != typeof v.keys;
+}
+function serialize(value) {
+    if (null == value) return value;
+    if ('object' != typeof value) return value;
+    if (isYXmlFragment(value)) return fragmentToJSON(value);
+    if (isYMap(value)) {
+        const result = {};
+        const ymap = value;
+        ymap.forEach((v, k)=>{
+            result[k] = serialize(v);
         });
+        return result;
     }
-    async deleteDocument(ctx, documentId, crdtBytes, version) {
-        return ctx.runMutation(this.component.public.deleteDocument, {
-            collectionName: this.collectionName,
-            documentId,
-            crdtBytes,
-            version
+    if (isYArray(value)) return value.toArray().map(serialize);
+    return value;
+}
+function serializeYMap(ymap) {
+    return serialize(ymap);
+}
+function extractItems(ymap) {
+    const items = [];
+    ymap.forEach((value)=>{
+        if (isYMap(value)) items.push(serialize(value));
+    });
+    return items;
+}
+function extractItem(ymap, key) {
+    const value = ymap.get(key);
+    if (isYMap(value)) return serialize(value);
+    return null;
+}
+function isDoc(value) {
+    return 'object' == typeof value && null !== value && 'type' in value && 'doc' === value.type;
+}
+function fragmentToJSON(fragment) {
+    const content = [];
+    for (const child of fragment.toArray())if (child instanceof XmlElement) content.push(xmlElementToJSON(child));
+    else if (child instanceof XmlText) {
+        const textContent = xmlTextToJSON(child);
+        if (textContent.length > 0) content.push({
+            type: 'paragraph',
+            content: textContent
+        });
+    }
+    return {
+        type: 'doc',
+        content: content.length > 0 ? content : [
+            {
+                type: 'paragraph'
+            }
+        ]
+    };
+}
+function xmlElementToJSON(element) {
+    const result = {
+        type: element.nodeName
+    };
+    const attrs = element.getAttributes();
+    if (Object.keys(attrs).length > 0) result.attrs = attrs;
+    const content = [];
+    for (const child of element.toArray())if (child instanceof XmlElement) content.push(xmlElementToJSON(child));
+    else if (child instanceof XmlText) content.push(...xmlTextToJSON(child));
+    if (content.length > 0) result.content = content;
+    return result;
+}
+function xmlTextToJSON(text) {
+    const result = [];
+    const delta = text.toDelta();
+    for (const op of delta)if ('string' == typeof op.insert) {
+        const node = {
+            type: 'text',
+            text: op.insert
+        };
+        if (op.attributes && Object.keys(op.attributes).length > 0) node.marks = Object.entries(op.attributes).map(([type, attrs])=>({
+                type,
+                attrs: 'object' == typeof attrs ? attrs : void 0
+            }));
+        result.push(node);
+    }
+    return result;
+}
+function fragmentFromJSON(fragment, json) {
+    if (!json.content) return;
+    for (const node of json.content)appendNodeToFragment(fragment, node);
+}
+function extract(content) {
+    if (!content || 'object' != typeof content) return '';
+    const doc = content;
+    if (!doc.content || !Array.isArray(doc.content)) return '';
+    return doc.content.map((block)=>{
+        if (!block.content || !Array.isArray(block.content)) return '';
+        return block.content.map((node)=>node.text || '').join('');
+    }).join(' ');
+}
+function appendNodeToFragment(parent, node) {
+    if ('text' === node.type) {
+        const text = new XmlText();
+        if (node.text) {
+            const attrs = {};
+            if (node.marks) for (const mark of node.marks)attrs[mark.type] = mark.attrs ?? true;
+            text.insert(0, node.text, Object.keys(attrs).length > 0 ? attrs : void 0);
+        }
+        parent.insert(parent.length, [
+            text
+        ]);
+    } else {
+        const element = new XmlElement(node.type);
+        if (node.attrs) for (const [key, value] of Object.entries(node.attrs))element.setAttribute(key, value);
+        if (node.content) for (const child of node.content)appendNodeToFragment(element, child);
+        parent.insert(parent.length, [
+            element
+        ]);
+    }
+}
+function serializeYMapValue(value) {
+    return serialize(value);
+}
+function getFragmentFromYMap(ymap, documentId, field) {
+    const doc = ymap.get(documentId);
+    if (!isYMap(doc)) return null;
+    const fieldValue = doc.get(field);
+    if (isYXmlFragment(fieldValue)) return fieldValue;
+    return null;
+}
+class Reconciliation extends Context.Tag('Reconciliation')() {
+}
+const ReconciliationLive = Layer.succeed(Reconciliation, Reconciliation.of({
+    reconcile: (ydoc, ymap, collection, serverDocs, getKey)=>Effect.gen(function*(_) {
+            const serverDocIds = new Set(serverDocs.map(getKey));
+            const toDelete = [];
+            ymap.forEach((_, key)=>{
+                if (!serverDocIds.has(key)) toDelete.push(key);
+            });
+            if (0 === toDelete.length) {
+                yield* _(Effect.logDebug('No phantom documents found', {
+                    collection
+                }));
+                return [];
+            }
+            yield* _(Effect.logWarning(`Found ${toDelete.length} phantom documents`, {
+                collection,
+                phantomDocs: toDelete.slice(0, 10)
+            }));
+            const removedItems = [];
+            for (const key of toDelete){
+                const itemYMap = ymap.get(key);
+                if (itemYMap instanceof external_yjs_Map) removedItems.push(serializeYMap(itemYMap));
+            }
+            yjsTransact(ydoc, ()=>{
+                for (const key of toDelete)ymap.delete(key);
+            }, 'reconciliation');
+            yield* _(Effect.logInfo('Reconciliation completed', {
+                collection,
+                deletedCount: removedItems.length
+            }));
+            return removedItems;
+        }).pipe(Effect.catchAll((cause)=>Effect.fail(new ReconciliationError({
+                collection,
+                reason: 'Reconciliation failed',
+                cause
+            }))))
+}));
+function createReplicateOps(params) {
+    return {
+        insert (items) {
+            params.begin();
+            for (const item of items)params.write({
+                type: 'insert',
+                value: item
+            });
+            params.commit();
+        },
+        delete (items) {
+            params.begin();
+            for (const item of items)params.write({
+                type: 'delete',
+                value: item
+            });
+            params.commit();
+        },
+        upsert (items) {
+            params.begin();
+            for (const item of items)params.write({
+                type: 'update',
+                value: item
+            });
+            params.commit();
+        },
+        replace (items) {
+            params.begin();
+            params.truncate();
+            for (const item of items)params.write({
+                type: 'insert',
+                value: item
+            });
+            params.commit();
+        }
+    };
+}
+const SERVER_ORIGIN = 'server';
+const prose_logger = logger_getLogger([
+    'replicate',
+    'prose'
+]);
+const DEFAULT_DEBOUNCE_MS = 1000;
+const applyingFromServer = new Map();
+const debounceTimers = new Map();
+const lastSyncedVectors = new Map();
+const pendingState = new Map();
+const pendingListeners = new Map();
+const fragmentObservers = new Map();
+const failedSyncQueue = new Map();
+function isApplyingFromServer(collection, documentId) {
+    const key = `${collection}:${documentId}`;
+    return applyingFromServer.get(key) ?? false;
+}
+function setApplyingFromServer(collection, documentId, value) {
+    const key = `${collection}:${documentId}`;
+    if (value) applyingFromServer.set(key, true);
+    else applyingFromServer.delete(key);
+}
+function setPendingInternal(key, value) {
+    const current = pendingState.get(key) ?? false;
+    if (current !== value) {
+        pendingState.set(key, value);
+        const listeners = pendingListeners.get(key);
+        if (listeners) for (const cb of listeners)try {
+            cb(value);
+        } catch (err) {
+            prose_logger.error('Pending listener error', {
+                key,
+                error: String(err)
+            });
+        }
+    }
+}
+function isPending(collection, documentId) {
+    return pendingState.get(`${collection}:${documentId}`) ?? false;
+}
+function subscribePending(collection, documentId, callback) {
+    const key = `${collection}:${documentId}`;
+    let listeners = pendingListeners.get(key);
+    if (!listeners) {
+        listeners = new Set();
+        pendingListeners.set(key, listeners);
+    }
+    listeners.add(callback);
+    return ()=>{
+        listeners?.delete(callback);
+        if (listeners?.size === 0) pendingListeners.delete(key);
+    };
+}
+function cancelPending(collection, documentId) {
+    const key = `${collection}:${documentId}`;
+    const timer = debounceTimers.get(key);
+    if (timer) {
+        clearTimeout(timer);
+        debounceTimers.delete(key);
+        setPendingInternal(key, false);
+        prose_logger.debug('Cancelled pending sync due to remote update', {
+            collection,
+            documentId
         });
     }
-    async stream(ctx, checkpoint, limit) {
-        return ctx.runQuery(this.component.public.stream, {
-            collectionName: this.collectionName,
-            checkpoint,
-            limit
+}
+function cancelAllPending(collection) {
+    const prefix = `${collection}:`;
+    for (const [key, timer] of debounceTimers)if (key.startsWith(prefix)) {
+        clearTimeout(timer);
+        debounceTimers.delete(key);
+        setPendingInternal(key, false);
+    }
+    prose_logger.debug('Cancelled all pending syncs', {
+        collection
+    });
+}
+function observeFragment(config) {
+    const { collection, documentId, field, fragment, ydoc, ymap, collectionRef, debounceMs = DEFAULT_DEBOUNCE_MS } = config;
+    const key = `${collection}:${documentId}`;
+    const existingCleanup = fragmentObservers.get(key);
+    if (existingCleanup) {
+        prose_logger.debug('Fragment already being observed', {
+            collection,
+            documentId,
+            field
         });
+        return existingCleanup;
     }
+    const observerHandler = (_events, transaction)=>{
+        if (transaction.origin === SERVER_ORIGIN) return;
+        const existing = debounceTimers.get(key);
+        if (existing) clearTimeout(existing);
+        setPendingInternal(key, true);
+        const timer = setTimeout(async ()=>{
+            debounceTimers.delete(key);
+            const itemYMap = ymap.get(documentId);
+            if (!itemYMap) {
+                prose_logger.error('Document not found', {
+                    collection,
+                    documentId
+                });
+                setPendingInternal(key, false);
+                return;
+            }
+            try {
+                const lastVector = lastSyncedVectors.get(key);
+                const delta = lastVector ? encodeStateAsUpdateV2(ydoc, lastVector) : encodeStateAsUpdateV2(ydoc);
+                if (delta.length <= 2) {
+                    prose_logger.debug('No changes to sync', {
+                        collection,
+                        documentId
+                    });
+                    setPendingInternal(key, false);
+                    return;
+                }
+                const crdtBytes = delta.buffer;
+                const currentVector = encodeStateVector(ydoc);
+                prose_logger.debug('Syncing prose delta', {
+                    collection,
+                    documentId,
+                    deltaSize: delta.byteLength
+                });
+                const materializedDoc = serializeYMapValue(itemYMap);
+                const result = collectionRef.update(documentId, {
+                    metadata: {
+                        contentSync: {
+                            crdtBytes,
+                            materializedDoc
+                        }
+                    }
+                }, (draft)=>{
+                    draft.updatedAt = Date.now();
+                });
+                await result.isPersisted.promise;
+                lastSyncedVectors.set(key, currentVector);
+                failedSyncQueue.delete(key);
+                setPendingInternal(key, false);
+                prose_logger.debug('Prose sync completed', {
+                    collection,
+                    documentId
+                });
+            } catch (err) {
+                prose_logger.error('Prose sync failed, queued for retry', {
+                    collection,
+                    documentId,
+                    error: String(err)
+                });
+                failedSyncQueue.set(key, true);
+            }
+        }, debounceMs);
+        debounceTimers.set(key, timer);
+        if (failedSyncQueue.has(key)) {
+            failedSyncQueue.delete(key);
+            prose_logger.debug('Retrying failed sync', {
+                collection,
+                documentId
+            });
+        }
+    };
+    fragment.observeDeep(observerHandler);
+    const cleanup = ()=>{
+        fragment.unobserveDeep(observerHandler);
+        cancelPending(collection, documentId);
+        fragmentObservers.delete(key);
+        lastSyncedVectors.delete(key);
+        prose_logger.debug('Fragment observer cleaned up', {
+            collection,
+            documentId,
+            field
+        });
+    };
+    fragmentObservers.set(key, cleanup);
+    prose_logger.debug('Fragment observer registered', {
+        collection,
+        documentId,
+        field
+    });
+    return cleanup;
 }
-function logger_getLogger(category) {
-    return getLogger([
-        'convex-replicate',
-        ...category
-    ]);
+function prose_cleanup(collection) {
+    const prefix = `${collection}:`;
+    for (const [key, timer] of debounceTimers)if (key.startsWith(prefix)) {
+        clearTimeout(timer);
+        debounceTimers.delete(key);
+    }
+    for (const key of pendingState.keys())if (key.startsWith(prefix)) pendingState.delete(key);
+    for (const key of pendingListeners.keys())if (key.startsWith(prefix)) pendingListeners.delete(key);
+    for (const key of applyingFromServer.keys())if (key.startsWith(prefix)) applyingFromServer.delete(key);
+    for (const key of lastSyncedVectors.keys())if (key.startsWith(prefix)) lastSyncedVectors.delete(key);
+    for (const [key, cleanupFn] of fragmentObservers)if (key.startsWith(prefix)) {
+        cleanupFn();
+        fragmentObservers.delete(key);
+    }
+    for (const key of failedSyncQueue.keys())if (key.startsWith(prefix)) failedSyncQueue.delete(key);
+    prose_logger.debug('Prose cleanup complete', {
+        collection
+    });
 }
-const logger = logger_getLogger([
-    'convex-replicate',
+const collection_logger = logger_getLogger([
+    'replicate',
     'collection'
 ]);
-function convexCollectionOptions({ getKey, initialData, convexClient, api, collectionName }) {
-    const ydoc = new __WEBPACK_EXTERNAL_MODULE_yjs__.Doc({
-        guid: collectionName
+function handleMutationError(error, operation, collection) {
+    const httpError = error;
+    collection_logger.error(`${operation} failed`, {
+        collection,
+        error: httpError?.message,
+        status: httpError?.status
     });
-    const ymap = ydoc.getMap(collectionName);
-    let pendingUpdate = null;
-    ydoc.on('update', (update, origin)=>{
-        pendingUpdate = update;
-        logger.debug('Yjs update event fired', {
-            collectionName,
-            updateSize: update.length,
-            origin
-        });
+    if (httpError?.status === 401 || httpError?.status === 403) throw new NonRetriableError('Authentication failed');
+    if (httpError?.status === 422) throw new NonRetriableError('Validation error');
+    throw error;
+}
+const cleanupFunctions = new Map();
+const collectionDocs = new Map();
+const collectionUndoConfig = new Map();
+const DEFAULT_UNDO_CAPTURE_TIMEOUT = 500;
+const collection_DEFAULT_DEBOUNCE_MS = 1000;
+const collectionMutex = new Map();
+const fragmentUndoManagers = new Map();
+const debounceConfig = new Map();
+const collectionRefs = new Map();
+const serverStateVectors = new Map();
+function getOrCreateMutex(collection) {
+    let mux = collectionMutex.get(collection);
+    if (!mux) {
+        mux = createMutex();
+        collectionMutex.set(collection, mux);
+    }
+    return mux;
+}
+function getOrCreateFragmentUndoManager(collection, documentId, field, fragment) {
+    const key = `${collection}:${documentId}:${field}`;
+    let um = fragmentUndoManagers.get(key);
+    if (um) return um;
+    const config = collectionUndoConfig.get(collection);
+    um = new UndoManager([
+        fragment
+    ], {
+        captureTimeout: config?.captureTimeout ?? DEFAULT_UNDO_CAPTURE_TIMEOUT,
+        trackedOrigins: new Set([
+            "fragment"
+        ])
+    });
+    fragmentUndoManagers.set(key, um);
+    return um;
+}
+function convexCollectionOptions({ getKey, material, convexClient, api, collection, prose: proseFields, undoCaptureTimeout = 500, persistence }) {
+    const proseFieldSet = new Set(proseFields);
+    const utils = {
+        async prose (documentId, field) {
+            const fieldStr = field;
+            if (!proseFieldSet.has(fieldStr)) throw new ProseError({
+                documentId,
+                field: fieldStr,
+                collection
+            });
+            let docs = collectionDocs.get(collection);
+            if (!docs) {
+                await new Promise((resolve, reject)=>{
+                    const maxWait = 10000;
+                    const startTime = Date.now();
+                    const check = setInterval(()=>{
+                        if (collectionDocs.has(collection)) {
+                            clearInterval(check);
+                            resolve();
+                        } else if (Date.now() - startTime > maxWait) {
+                            clearInterval(check);
+                            reject(new ProseError({
+                                documentId,
+                                field: fieldStr,
+                                collection
+                            }));
+                        }
+                    }, 10);
+                });
+                docs = collectionDocs.get(collection);
+            }
+            if (!docs) throw new ProseError({
+                documentId,
+                field: fieldStr,
+                collection
+            });
+            const fragment = getFragmentFromYMap(docs.ymap, documentId, fieldStr);
+            if (!fragment) throw new ProseError({
+                documentId,
+                field: fieldStr,
+                collection
+            });
+            const collectionRef = collectionRefs.get(collection);
+            if (collectionRef) observeFragment({
+                collection,
+                documentId,
+                field: fieldStr,
+                fragment,
+                ydoc: docs.ydoc,
+                ymap: docs.ymap,
+                collectionRef,
+                debounceMs: debounceConfig.get(collection) ?? collection_DEFAULT_DEBOUNCE_MS
+            });
+            const undoManager = getOrCreateFragmentUndoManager(collection, documentId, fieldStr, fragment);
+            return {
+                fragment,
+                provider: {
+                    awareness: null
+                },
+                get pending () {
+                    return isPending(collection, documentId);
+                },
+                onPendingChange (callback) {
+                    return subscribePending(collection, documentId, callback);
+                },
+                undo () {
+                    undoManager.undo();
+                },
+                redo () {
+                    undoManager.redo();
+                },
+                canUndo () {
+                    return undoManager.canUndo();
+                },
+                canRedo () {
+                    return undoManager.canRedo();
+                }
+            };
+        }
+    };
+    let ydoc = null;
+    let ymap = null;
+    let docPersistence = null;
+    let ops = null;
+    const checkpointLayer = createCheckpointLayer(persistence.kv);
+    const servicesLayer = Layer.mergeAll(checkpointLayer, ReconciliationLive);
+    let resolvePersistenceReady;
+    const persistenceReadyPromise = new Promise((resolve)=>{
+        resolvePersistenceReady = resolve;
+    });
+    let resolveOptimisticReady;
+    const optimisticReadyPromise = new Promise((resolve)=>{
+        resolveOptimisticReady = resolve;
     });
+    const reconcile = (ops)=>Effect.gen(function*() {
+            if (!api.material) return;
+            const materialApi = api.material;
+            const reconciliation = yield* Reconciliation;
+            const serverResponse = yield* Effect.tryPromise({
+                try: ()=>convexClient.query(materialApi, {}),
+                catch: (error)=>new Error(`Reconciliation query failed: ${error}`)
+            });
+            const serverDocs = Array.isArray(serverResponse) ? serverResponse : serverResponse.documents || [];
+            const removedItems = yield* reconciliation.reconcile(ydoc, ymap, collection, serverDocs, (doc)=>String(getKey(doc)));
+            if (removedItems.length > 0) ops.delete(removedItems);
+        }).pipe(Effect.catchAll((error)=>Effect.gen(function*() {
+                yield* Effect.logError('Reconciliation failed', {
+                    collection,
+                    error
+                });
+            })));
+    const recoverSync = async ()=>{
+        if (!api.recovery) return void collection_logger.debug('No recovery API configured, skipping recovery sync', {
+            collection
+        });
+        try {
+            const localStateVector = encodeStateVector(ydoc);
+            collection_logger.debug('Starting recovery sync', {
+                collection,
+                localVectorSize: localStateVector.byteLength
+            });
+            const response = await convexClient.query(api.recovery, {
+                clientStateVector: localStateVector.buffer
+            });
+            if (response.diff) {
+                const mux = getOrCreateMutex(collection);
+                mux(()=>{
+                    applyUpdate(ydoc, new Uint8Array(response.diff), "server");
+                });
+                collection_logger.info('Recovery sync applied diff', {
+                    collection,
+                    diffSize: response.diff.byteLength
+                });
+            } else collection_logger.debug('Recovery sync - no diff needed', {
+                collection
+            });
+            if (response.serverStateVector) serverStateVectors.set(collection, new Uint8Array(response.serverStateVector));
+        } catch (error) {
+            collection_logger.error('Recovery sync failed', {
+                collection,
+                error: String(error)
+            });
+        }
+    };
+    const applyYjsInsert = (mutations)=>{
+        const { delta } = transactWithDelta(ydoc, ()=>{
+            mutations.forEach((mut)=>{
+                const itemYMap = new external_yjs_Map();
+                ymap.set(String(mut.key), itemYMap);
+                Object.entries(mut.modified).forEach(([k, v])=>{
+                    if (proseFieldSet.has(k) && isDoc(v)) {
+                        const fragment = new XmlFragment();
+                        itemYMap.set(k, fragment);
+                        fragmentFromJSON(fragment, v);
+                    } else itemYMap.set(k, v);
+                });
+            });
+        }, "local");
+        return delta;
+    };
+    const applyYjsUpdate = (mutations)=>{
+        const { delta } = transactWithDelta(ydoc, ()=>{
+            mutations.forEach((mut)=>{
+                const itemYMap = ymap.get(String(mut.key));
+                if (itemYMap) {
+                    const modifiedFields = mut.modified;
+                    if (!modifiedFields) return void collection_logger.warn('mut.modified is null/undefined', {
+                        collection,
+                        key: String(mut.key)
+                    });
+                    Object.entries(modifiedFields).forEach(([k, v])=>{
+                        const existingValue = itemYMap.get(k);
+                        if (proseFieldSet.has(k)) return void collection_logger.debug('Skipping prose field in applyYjsUpdate', {
+                            field: k
+                        });
+                        if (existingValue instanceof XmlFragment) return void collection_logger.debug('Preserving live fragment field', {
+                            field: k
+                        });
+                        itemYMap.set(k, v);
+                    });
+                } else collection_logger.error('Update attempted on non-existent item', {
+                    collection,
+                    key: String(mut.key)
+                });
+            });
+        }, "local");
+        return delta;
+    };
+    const applyYjsDelete = (mutations)=>{
+        const { delta } = transactWithDelta(ydoc, ()=>{
+            mutations.forEach((mut)=>{
+                ymap.delete(String(mut.key));
+            });
+        }, "local");
+        return delta;
+    };
     return {
-        id: collectionName,
+        id: collection,
         getKey,
         _convexClient: convexClient,
-        _collectionName: collectionName,
+        _collection: collection,
+        _proseFields: proseFields,
+        _persistence: persistence,
+        utils,
         onInsert: async ({ transaction })=>{
-            logger.debug('onInsert handler called', {
-                collectionName,
-                mutationCount: transaction.mutations.length
-            });
             try {
-                ydoc.transact(()=>{
-                    transaction.mutations.forEach((mut)=>{
-                        const itemYMap = new __WEBPACK_EXTERNAL_MODULE_yjs__.Map();
-                        Object.entries(mut.modified).forEach(([k, v])=>{
-                            itemYMap.set(k, v);
-                        });
-                        ymap.set(String(mut.key), itemYMap);
-                    });
-                }, 'insert');
-                if (pendingUpdate) {
-                    logger.debug('Sending insert delta to Convex', {
-                        collectionName,
-                        documentId: String(transaction.mutations[0].key),
-                        deltaSize: pendingUpdate.length
-                    });
-                    await convexClient.mutation(api.insertDocument, {
-                        collectionName,
-                        documentId: String(transaction.mutations[0].key),
-                        crdtBytes: pendingUpdate.buffer,
-                        materializedDoc: transaction.mutations[0].modified,
-                        version: Date.now()
-                    });
-                    pendingUpdate = null;
-                    logger.info('Insert persisted to Convex', {
-                        collectionName,
-                        documentId: String(transaction.mutations[0].key)
+                await Promise.all([
+                    persistenceReadyPromise,
+                    optimisticReadyPromise
+                ]);
+                const delta = applyYjsInsert(transaction.mutations);
+                if (delta.length > 0) {
+                    const documentKey = String(transaction.mutations[0].key);
+                    const itemYMap = ymap.get(documentKey);
+                    const materializedDoc = itemYMap ? serializeYMapValue(itemYMap) : transaction.mutations[0].modified;
+                    await convexClient.mutation(api.insert, {
+                        documentId: documentKey,
+                        crdtBytes: delta.slice().buffer,
+                        materializedDoc
                     });
                 }
             } catch (error) {
-                logger.error('Insert failed', {
-                    collectionName,
-                    error: error?.message,
-                    status: error?.status
-                });
-                if (error?.status === 401 || error?.status === 403) throw new NonRetriableError('Authentication failed');
-                if (error?.status === 422) throw new NonRetriableError('Validation error');
-                throw error;
+                handleMutationError(error, 'Insert', collection);
             }
         },
         onUpdate: async ({ transaction })=>{
-            logger.debug('onUpdate handler called', {
-                collectionName,
-                mutationCount: transaction.mutations.length
-            });
             try {
-                ydoc.transact(()=>{
-                    transaction.mutations.forEach((mut)=>{
-                        const itemYMap = ymap.get(String(mut.key));
-                        if (itemYMap) Object.entries(mut.modified || {}).forEach(([k, v])=>{
-                            itemYMap.set(k, v);
-                        });
-                        else {
-                            const newYMap = new __WEBPACK_EXTERNAL_MODULE_yjs__.Map();
-                            Object.entries(mut.modified).forEach(([k, v])=>{
-                                newYMap.set(k, v);
-                            });
-                            ymap.set(String(mut.key), newYMap);
-                        }
-                    });
-                }, 'update');
-                if (pendingUpdate) {
-                    logger.debug('Sending update delta to Convex', {
-                        collectionName,
-                        documentId: String(transaction.mutations[0].key),
-                        deltaSize: pendingUpdate.length
-                    });
-                    await convexClient.mutation(api.updateDocument, {
-                        collectionName,
-                        documentId: String(transaction.mutations[0].key),
-                        crdtBytes: pendingUpdate.buffer,
-                        materializedDoc: transaction.mutations[0].modified,
-                        version: Date.now()
+                const mutation = transaction.mutations[0];
+                const documentKey = String(mutation.key);
+                if (isApplyingFromServer(collection, documentKey)) return void collection_logger.debug('Skipping onUpdate - data from server', {
+                    collection,
+                    documentKey
+                });
+                await Promise.all([
+                    persistenceReadyPromise,
+                    optimisticReadyPromise
+                ]);
+                const metadata = mutation.metadata;
+                if (metadata?.contentSync) {
+                    const { crdtBytes, materializedDoc } = metadata.contentSync;
+                    await convexClient.mutation(api.update, {
+                        documentId: documentKey,
+                        crdtBytes,
+                        materializedDoc
                     });
-                    pendingUpdate = null;
-                    logger.info('Update persisted to Convex', {
-                        collectionName,
-                        documentId: String(transaction.mutations[0].key)
+                    return;
+                }
+                const delta = applyYjsUpdate(transaction.mutations);
+                if (delta.length > 0) {
+                    const itemYMap = ymap.get(documentKey);
+                    const fullDoc = itemYMap ? serializeYMapValue(itemYMap) : mutation.modified;
+                    await convexClient.mutation(api.update, {
+                        documentId: documentKey,
+                        crdtBytes: delta.slice().buffer,
+                        materializedDoc: fullDoc
                     });
                 }
             } catch (error) {
-                logger.error('Update failed', {
-                    collectionName,
-                    error: error?.message,
-                    status: error?.status
-                });
-                if (error?.status === 401 || error?.status === 403) throw new NonRetriableError('Authentication failed');
-                if (error?.status === 422) throw new NonRetriableError('Validation error');
-                throw error;
+                handleMutationError(error, 'Update', collection);
             }
         },
         onDelete: async ({ transaction })=>{
-            logger.debug('onDelete handler called', {
-                collectionName,
-                mutationCount: transaction.mutations.length
-            });
             try {
-                ydoc.transact(()=>{
-                    transaction.mutations.forEach((mut)=>{
-                        ymap.delete(String(mut.key));
-                    });
-                }, 'delete');
-                if (pendingUpdate) {
-                    logger.debug('Sending delete delta to Convex', {
-                        collectionName,
-                        documentId: String(transaction.mutations[0].key),
-                        deltaSize: pendingUpdate.length
-                    });
-                    await convexClient.mutation(api.deleteDocument, {
-                        collectionName,
-                        documentId: String(transaction.mutations[0].key),
-                        crdtBytes: pendingUpdate.buffer,
-                        version: Date.now()
-                    });
-                    pendingUpdate = null;
-                    logger.info('Delete persisted to Convex', {
-                        collectionName,
-                        documentId: String(transaction.mutations[0].key)
+                await Promise.all([
+                    persistenceReadyPromise,
+                    optimisticReadyPromise
+                ]);
+                const delta = applyYjsDelete(transaction.mutations);
+                const itemsToDelete = transaction.mutations.map((mut)=>mut.original).filter((item)=>void 0 !== item && Object.keys(item).length > 0);
+                ops.delete(itemsToDelete);
+                if (delta.length > 0) {
+                    const documentKey = String(transaction.mutations[0].key);
+                    await convexClient.mutation(api.remove, {
+                        documentId: documentKey,
+                        crdtBytes: delta.slice().buffer
                     });
                 }
             } catch (error) {
-                logger.error('Delete failed', {
-                    collectionName,
-                    error: error?.message,
-                    status: error?.status
-                });
-                if (error?.status === 401 || error?.status === 403) throw new NonRetriableError('Authentication failed');
-                if (error?.status === 422) throw new NonRetriableError('Validation error');
-                throw error;
+                handleMutationError(error, 'Delete', collection);
             }
         },
         sync: {
+            rowUpdateMode: 'partial',
             sync: (params)=>{
-                const { begin, write, commit, markReady } = params;
-                if (initialData && initialData.length > 0) {
-                    ydoc.transact(()=>{
-                        for (const item of initialData){
-                            const key = getKey(item);
-                            const itemYMap = new __WEBPACK_EXTERNAL_MODULE_yjs__.Map();
-                            Object.entries(item).forEach(([k, v])=>{
-                                itemYMap.set(k, v);
-                            });
-                            ymap.set(String(key), itemYMap);
-                        }
-                    }, 'ssr-init');
-                    begin();
-                    for (const item of initialData)write({
-                        type: 'insert',
-                        value: item
-                    });
-                    commit();
-                    logger.debug('Initialized with SSR data', {
-                        collectionName,
-                        count: initialData.length
-                    });
+                const { markReady, collection: collectionInstance } = params;
+                collectionRefs.set(collection, collectionInstance);
+                const existingCleanup = cleanupFunctions.get(collection);
+                if (existingCleanup) {
+                    existingCleanup();
+                    cleanupFunctions.delete(collection);
                 }
-                logger.debug("Setting up Convex subscription", {
-                    collectionName
-                });
-                let previousItems = new Map();
-                const subscription = convexClient.onUpdate(api.stream, {}, async (items)=>{
+                let subscription = null;
+                const ssrDocuments = material?.documents;
+                const ssrCheckpoint = material?.checkpoint;
+                const ssrCRDTBytes = material?.crdtBytes;
+                const docs = ssrDocuments ? [
+                    ...ssrDocuments
+                ] : [];
+                (async ()=>{
                     try {
-                        logger.debug("Subscription update received", {
-                            collectionName,
-                            itemCount: items.length
+                        ydoc = await createYjsDocument(collection, persistence.kv);
+                        ymap = getYMap(ydoc, collection);
+                        collectionDocs.set(collection, {
+                            ydoc,
+                            ymap
                         });
-                        const currentItems = new Map();
-                        for (const item of items){
-                            const key = getKey(item);
-                            currentItems.set(key, item);
-                        }
-                        const deletedItems = [];
-                        for (const [prevId, prevItem] of previousItems)if (!currentItems.has(prevId)) deletedItems.push(prevItem);
-                        if (deletedItems.length > 0) logger.info('Detected remote hard deletes', {
-                            collectionName,
-                            deletedCount: deletedItems.length,
-                            deletedIds: deletedItems.map((item)=>getKey(item))
+                        const trackedOrigins = new Set([
+                            "local"
+                        ]);
+                        collectionUndoConfig.set(collection, {
+                            captureTimeout: undoCaptureTimeout,
+                            trackedOrigins
+                        });
+                        docPersistence = persistence.createDocPersistence(collection, ydoc);
+                        docPersistence.whenSynced.then(()=>{
+                            collection_logger.debug('Persistence synced', {
+                                collection
+                            });
+                            resolvePersistenceReady?.();
                         });
-                        begin();
-                        for (const deletedItem of deletedItems){
-                            const deletedId = getKey(deletedItem);
-                            ydoc.transact(()=>{
-                                ymap.delete(String(deletedId));
-                            }, 'remote-delete');
-                            write({
-                                type: 'delete',
-                                value: deletedItem
+                        await persistenceReadyPromise;
+                        collection_logger.info('Persistence ready', {
+                            collection,
+                            ymapSize: ymap.size
+                        });
+                        ops = createReplicateOps(params);
+                        resolveOptimisticReady?.();
+                        if (ssrCRDTBytes) applyUpdate(ydoc, new Uint8Array(ssrCRDTBytes), "server");
+                        await recoverSync();
+                        if (ymap.size > 0) {
+                            const items = extractItems(ymap);
+                            ops.replace(items);
+                            collection_logger.info('Data loaded to TanStack DB', {
+                                collection,
+                                itemCount: items.length
+                            });
+                        } else {
+                            ops.replace([]);
+                            collection_logger.info('No data, cleared TanStack DB', {
+                                collection
                             });
                         }
-                        ydoc.transact(()=>{
-                            for (const item of items){
-                                const key = getKey(item);
-                                const itemYMap = new __WEBPACK_EXTERNAL_MODULE_yjs__.Map();
-                                Object.entries(item).forEach(([k, v])=>{
-                                    itemYMap.set(k, v);
+                        collection_logger.debug('Running reconciliation', {
+                            collection,
+                            ymapSize: ymap.size
+                        });
+                        await Effect.runPromise(reconcile(ops).pipe(Effect.provide(servicesLayer)));
+                        collection_logger.debug('Reconciliation complete', {
+                            collection
+                        });
+                        markReady();
+                        collection_logger.info('Collection ready', {
+                            collection,
+                            ymapSize: ymap.size
+                        });
+                        const checkpoint = ssrCheckpoint || await Effect.runPromise(Effect.gen(function*() {
+                            const checkpointSvc = yield* Checkpoint;
+                            return yield* checkpointSvc.loadCheckpoint(collection);
+                        }).pipe(Effect.provide(checkpointLayer)));
+                        collection_logger.info('Checkpoint loaded', {
+                            collection,
+                            checkpoint,
+                            source: ssrCheckpoint ? 'SSR' : 'IndexedDB',
+                            ymapSize: ymap.size
+                        });
+                        const mux = getOrCreateMutex(collection);
+                        const handleSnapshotChange = (crdtBytes)=>{
+                            cancelAllPending(collection);
+                            mux(()=>{
+                                try {
+                                    collection_logger.debug('Applying snapshot', {
+                                        collection,
+                                        bytesLength: crdtBytes.byteLength
+                                    });
+                                    applyUpdate(ydoc, new Uint8Array(crdtBytes), "server");
+                                    const items = extractItems(ymap);
+                                    collection_logger.debug('Snapshot applied', {
+                                        collection,
+                                        itemCount: items.length
+                                    });
+                                    ops.replace(items);
+                                } catch (error) {
+                                    collection_logger.error('Error applying snapshot', {
+                                        collection,
+                                        error: String(error)
+                                    });
+                                    throw new Error(`Snapshot application failed: ${error}`);
+                                }
+                            });
+                        };
+                        const handleDeltaChange = (crdtBytes, documentId)=>{
+                            if (documentId) {
+                                cancelPending(collection, documentId);
+                                setApplyingFromServer(collection, documentId, true);
+                            }
+                            mux(()=>{
+                                try {
+                                    collection_logger.debug('Applying delta', {
+                                        collection,
+                                        documentId,
+                                        bytesLength: crdtBytes.byteLength
+                                    });
+                                    const itemBefore = documentId ? extractItem(ymap, documentId) : null;
+                                    applyUpdate(ydoc, new Uint8Array(crdtBytes), "server");
+                                    if (!documentId) return void collection_logger.debug('Delta applied (no documentId)', {
+                                        collection
+                                    });
+                                    const itemAfter = extractItem(ymap, documentId);
+                                    if (itemAfter) {
+                                        collection_logger.debug('Upserting item after delta', {
+                                            collection,
+                                            documentId
+                                        });
+                                        ops.upsert([
+                                            itemAfter
+                                        ]);
+                                    } else if (itemBefore) {
+                                        collection_logger.debug('Deleting item after delta', {
+                                            collection,
+                                            documentId
+                                        });
+                                        ops.delete([
+                                            itemBefore
+                                        ]);
+                                    } else collection_logger.debug('No change detected after delta', {
+                                        collection,
+                                        documentId
+                                    });
+                                } catch (error) {
+                                    collection_logger.error('Error applying delta', {
+                                        collection,
+                                        documentId,
+                                        error: String(error)
+                                    });
+                                    throw new Error(`Delta application failed for ${documentId}: ${error}`);
+                                } finally{
+                                    if (documentId) setApplyingFromServer(collection, documentId, false);
+                                }
+                            });
+                        };
+                        const handleSubscriptionUpdate = async (response)=>{
+                            try {
+                                if (!response || !Array.isArray(response.changes)) return void collection_logger.error("Invalid subscription response", {
+                                    response
+                                });
+                                const { changes, checkpoint: newCheckpoint } = response;
+                                for (const change of changes){
+                                    const { operationType, crdtBytes, documentId } = change;
+                                    if (!crdtBytes) {
+                                        collection_logger.warn('Skipping change with missing crdtBytes', {
+                                            change
+                                        });
+                                        continue;
+                                    }
+                                    try {
+                                        if ('snapshot' === operationType) handleSnapshotChange(crdtBytes);
+                                        else handleDeltaChange(crdtBytes, documentId);
+                                    } catch (changeError) {
+                                        collection_logger.error('Failed to apply change', {
+                                            operationType,
+                                            documentId,
+                                            error: String(changeError)
+                                        });
+                                    }
+                                }
+                                if (newCheckpoint) try {
+                                    const key = `checkpoint:${collection}`;
+                                    await persistence.kv.set(key, newCheckpoint);
+                                    collection_logger.debug('Checkpoint saved', {
+                                        collection,
+                                        checkpoint: newCheckpoint
+                                    });
+                                } catch (checkpointError) {
+                                    collection_logger.error('Failed to save checkpoint', {
+                                        collection,
+                                        error: String(checkpointError)
+                                    });
+                                }
+                            } catch (error) {
+                                collection_logger.error("Subscription handler error", {
+                                    collection,
+                                    error: String(error)
                                 });
-                                ymap.set(String(key), itemYMap);
                             }
-                        }, "subscription-sync");
-                        for (const item of items){
-                            const key = getKey(item);
-                            params.collection.has(key) ? write({
-                                type: 'update',
-                                value: item
-                            }) : write({
-                                type: 'insert',
-                                value: item
+                        };
+                        collection_logger.info("Establishing subscription", {
+                            collection,
+                            checkpoint,
+                            limit: 1000
+                        });
+                        subscription = convexClient.onUpdate(api.stream, {
+                            checkpoint,
+                            limit: 1000
+                        }, (response)=>{
+                            collection_logger.debug("Subscription received update", {
+                                collection,
+                                changesCount: response.changes?.length ?? 0,
+                                checkpoint: response.checkpoint,
+                                hasMore: response.hasMore
                             });
-                        }
-                        commit();
-                        previousItems = currentItems;
-                        logger.debug('Successfully synced items to collection', {
-                            count: items.length,
-                            deletedCount: deletedItems.length
+                            handleSubscriptionUpdate(response);
+                        });
+                        collection_logger.info("Subscription established", {
+                            collection
                         });
                     } catch (error) {
-                        logger.error("Failed to sync items from subscription", {
-                            error: error.message,
-                            errorName: error.name,
-                            stack: error?.stack,
-                            collectionName,
-                            itemCount: items.length
+                        collection_logger.error('Failed to set up collection', {
+                            error,
+                            collection
                         });
-                        throw error;
+                        markReady();
+                    }
+                })();
+                return {
+                    material: docs,
+                    cleanup: ()=>{
+                        subscription?.();
+                        prose_cleanup(collection);
+                        const prefix = `${collection}:`;
+                        for (const [key, um] of fragmentUndoManagers)if (key.startsWith(prefix)) {
+                            um.destroy();
+                            fragmentUndoManagers.delete(key);
+                        }
+                        collectionMutex.delete(collection);
+                        debounceConfig.delete(collection);
+                        collectionRefs.delete(collection);
+                        collectionUndoConfig.delete(collection);
+                        collectionDocs.delete(collection);
+                        docPersistence?.destroy();
+                        ydoc?.destroy();
+                        cleanupFunctions.delete(collection);
                     }
-                });
-                markReady();
-                return ()=>{
-                    logger.debug("Cleaning up Convex subscription", {
-                        collectionName
-                    });
-                    subscription();
                 };
             }
         }
     };
 }
-function createConvexCollection(rawCollection) {
-    const config = rawCollection.config;
-    const convexClient = config._convexClient;
-    const collectionName = config._collectionName;
-    if (!convexClient || !collectionName) throw new Error("createConvexCollection requires a collection created with convexCollectionOptions. Make sure you pass convexClient and collectionName to convexCollectionOptions.");
-    logger.info('Creating Convex collection with offline support', {
-        collectionName
-    });
-    const offline = startOfflineExecutor({
-        collections: {
-            [collectionName]: rawCollection
-        },
-        mutationFns: {},
-        beforeRetry: (transactions)=>{
-            const cutoff = Date.now() - 86400000;
-            const filtered = transactions.filter((tx)=>{
-                const isRecent = tx.createdAt.getTime() > cutoff;
-                const notExhausted = tx.retryCount < 10;
-                return isRecent && notExhausted;
-            });
-            if (filtered.length < transactions.length) logger.warn('Filtered stale transactions', {
-                collectionName,
-                before: transactions.length,
-                after: filtered.length
-            });
-            return filtered;
-        },
-        onLeadershipChange: (isLeader)=>{
-            logger.info(isLeader ? 'Offline mode active' : 'Online-only mode', {
-                collectionName
-            });
-        },
-        onStorageFailure: (diagnostic)=>{
-            logger.warn('Storage failed - online-only mode', {
-                collectionName,
-                code: diagnostic.code,
-                message: diagnostic.message
-            });
+class BrowserLevelKeyValueStore {
+    db;
+    constructor(dbName){
+        this.db = new BrowserLevel(dbName);
+    }
+    async get(key) {
+        try {
+            const value = await this.db.get(key);
+            if (void 0 === value) return;
+            return JSON.parse(value);
+        } catch (err) {
+            if ('LEVEL_NOT_FOUND' === err.code) return;
+            throw err;
         }
-    });
-    if (convexClient.connectionState) {
-        const connectionState = convexClient.connectionState();
-        logger.debug('Initial connection state', {
-            collectionName,
-            isConnected: connectionState.isWebSocketConnected
+    }
+    async set(key, value) {
+        await this.db.put(key, JSON.stringify(value));
+    }
+    async del(key) {
+        try {
+            await this.db.del(key);
+        } catch (err) {
+            if ('LEVEL_NOT_FOUND' !== err.code) throw err;
+        }
+    }
+    async close() {
+        await this.db.close();
+    }
+}
+class IndexedDBPersistenceProvider {
+    persistence;
+    whenSynced;
+    constructor(collection, ydoc){
+        this.persistence = new IndexeddbPersistence(collection, ydoc);
+        this.whenSynced = new Promise((resolve)=>{
+            if (this.persistence.synced) resolve();
+            else this.persistence.once('synced', ()=>resolve());
+        });
+    }
+    destroy() {
+        this.persistence.destroy();
+    }
+}
+function indexeddbPersistence(dbName = 'replicate-kv') {
+    const kv = new BrowserLevelKeyValueStore(dbName);
+    return {
+        createDocPersistence: (collection, ydoc)=>new IndexedDBPersistenceProvider(collection, ydoc),
+        kv
+    };
+}
+class MemoryKeyValueStore {
+    store = new Map();
+    async get(key) {
+        return this.store.get(key);
+    }
+    async set(key, value) {
+        this.store.set(key, value);
+    }
+    async del(key) {
+        this.store.delete(key);
+    }
+}
+class MemoryPersistenceProvider {
+    whenSynced = Promise.resolve();
+    destroy() {}
+}
+function memoryPersistence() {
+    const kv = new MemoryKeyValueStore();
+    return {
+        createDocPersistence: (_collection, _ydoc)=>new MemoryPersistenceProvider(),
+        kv
+    };
+}
+class SqliteLevel extends AbstractLevel {
+    adapter = null;
+    adapterFactory = null;
+    constructor(_location, options){
+        super({
+            encodings: {
+                utf8: true,
+                buffer: true,
+                view: true
+            },
+            seek: true,
+            permanence: true,
+            createIfMissing: true,
+            errorIfExists: false,
+            additionalMethods: {}
+        }, {
+            keyEncoding: options?.keyEncoding ?? 'utf8',
+            valueEncoding: options?.valueEncoding ?? 'utf8'
         });
+        if (options?.adapter) this.adapter = options.adapter;
+    }
+    setAdapterFactory(factory) {
+        this.adapterFactory = factory;
+    }
+    async _open() {
+        if (!this.adapter) if (this.adapterFactory) this.adapter = await this.adapterFactory();
+        else throw new Error('No SQLite adapter configured. Call setAdapterFactory() before open().');
+        await this.adapter.execute(`
+      CREATE TABLE IF NOT EXISTS entries (
+        key BLOB PRIMARY KEY,
+        value BLOB NOT NULL
+      )
+    `);
+        await this.adapter.execute(`
+      CREATE INDEX IF NOT EXISTS entries_key_idx ON entries (key)
+    `);
+    }
+    async _close() {
+        if (this.adapter) {
+            this.adapter.close();
+            this.adapter = null;
+        }
+    }
+    async _get(key) {
+        if (!this.adapter) throw new Error('Database not open');
+        const keyBytes = this.encodeKey(key);
+        const result = await this.adapter.execute('SELECT value FROM entries WHERE key = ?', [
+            keyBytes
+        ]);
+        if (0 === result.rows.length) return;
+        return this.decodeValue(result.rows[0].value);
+    }
+    async _put(key, value) {
+        if (!this.adapter) throw new Error('Database not open');
+        const keyBytes = this.encodeKey(key);
+        const valueBytes = this.encodeValue(value);
+        await this.adapter.execute('INSERT OR REPLACE INTO entries (key, value) VALUES (?, ?)', [
+            keyBytes,
+            valueBytes
+        ]);
+    }
+    async _del(key) {
+        if (!this.adapter) throw new Error('Database not open');
+        const keyBytes = this.encodeKey(key);
+        await this.adapter.execute('DELETE FROM entries WHERE key = ?', [
+            keyBytes
+        ]);
+    }
+    async _batch(operations) {
+        if (!this.adapter) throw new Error('Database not open');
+        await this.adapter.execute('BEGIN TRANSACTION');
+        try {
+            for (const op of operations)if ('put' === op.type) {
+                const keyBytes = this.encodeKey(op.key);
+                const valueBytes = this.encodeValue(op.value);
+                await this.adapter.execute('INSERT OR REPLACE INTO entries (key, value) VALUES (?, ?)', [
+                    keyBytes,
+                    valueBytes
+                ]);
+            } else if ('del' === op.type) {
+                const keyBytes = this.encodeKey(op.key);
+                await this.adapter.execute('DELETE FROM entries WHERE key = ?', [
+                    keyBytes
+                ]);
+            }
+            await this.adapter.execute('COMMIT');
+        } catch (error) {
+            await this.adapter.execute('ROLLBACK');
+            throw error;
+        }
+    }
+    async _clear() {
+        if (!this.adapter) throw new Error('Database not open');
+        await this.adapter.execute('DELETE FROM entries');
+    }
+    _iterator(options) {
+        if (!this.adapter) throw new Error('Database not open');
+        return new SqliteIterator(this, this.adapter, options);
+    }
+    _keys(options) {
+        if (!this.adapter) throw new Error('Database not open');
+        return new SqliteKeyIterator(this, this.adapter, options);
+    }
+    _values(options) {
+        if (!this.adapter) throw new Error('Database not open');
+        return new SqliteValueIterator(this, this.adapter, options);
+    }
+    encodeKey(key) {
+        if (key instanceof Uint8Array) return key;
+        if ('string' == typeof key) return new TextEncoder().encode(key);
+        return new TextEncoder().encode(String(key));
+    }
+    encodeValue(value) {
+        if (value instanceof Uint8Array) return value;
+        if ('string' == typeof value) return new TextEncoder().encode(value);
+        return new TextEncoder().encode(JSON.stringify(value));
+    }
+    decodeValue(bytes) {
+        return new TextDecoder().decode(bytes);
+    }
+}
+class SqliteIterator extends AbstractIterator {
+    adapter;
+    options;
+    rows = null;
+    index = 0;
+    constructor(db, adapter, options){
+        super(db, options);
+        this.adapter = adapter;
+        this.options = options;
+    }
+    async _next() {
+        if (null === this.rows) await this.loadRows();
+        if (this.rows && this.index < this.rows.length) {
+            const row = this.rows[this.index++];
+            const key = new TextDecoder().decode(row.key);
+            const value = new TextDecoder().decode(row.value);
+            return [
+                key,
+                value
+            ];
+        }
+    }
+    async _nextv(size) {
+        if (null === this.rows) await this.loadRows();
+        const result = [];
+        while(this.rows && this.index < this.rows.length && result.length < size){
+            const row = this.rows[this.index++];
+            const key = new TextDecoder().decode(row.key);
+            const value = new TextDecoder().decode(row.value);
+            result.push([
+                key,
+                value
+            ]);
+        }
+        return result;
+    }
+    async loadRows() {
+        const { reverse, limit, gt, gte, lt, lte } = this.options;
+        let sql = 'SELECT key, value FROM entries';
+        const params = [];
+        const conditions = [];
+        if (void 0 !== gt) {
+            conditions.push('key > ?');
+            params.push(this.encodeKey(gt));
+        }
+        if (void 0 !== gte) {
+            conditions.push('key >= ?');
+            params.push(this.encodeKey(gte));
+        }
+        if (void 0 !== lt) {
+            conditions.push('key < ?');
+            params.push(this.encodeKey(lt));
+        }
+        if (void 0 !== lte) {
+            conditions.push('key <= ?');
+            params.push(this.encodeKey(lte));
+        }
+        if (conditions.length > 0) sql += ` WHERE ${conditions.join(' AND ')}`;
+        sql += ` ORDER BY key ${reverse ? 'DESC' : 'ASC'}`;
+        if (void 0 !== limit && limit >= 0) sql += ` LIMIT ${limit}`;
+        const result = await this.adapter.execute(sql, params);
+        this.rows = result.rows;
+    }
+    encodeKey(key) {
+        if (key instanceof Uint8Array) return key;
+        if ('string' == typeof key) return new TextEncoder().encode(key);
+        return new TextEncoder().encode(String(key));
+    }
+}
+class SqliteKeyIterator extends AbstractKeyIterator {
+    adapter;
+    options;
+    rows = null;
+    index = 0;
+    constructor(db, adapter, options){
+        super(db, options);
+        this.adapter = adapter;
+        this.options = options;
+    }
+    async _next() {
+        if (null === this.rows) await this.loadRows();
+        if (this.rows && this.index < this.rows.length) {
+            const row = this.rows[this.index++];
+            return new TextDecoder().decode(row.key);
+        }
+    }
+    async loadRows() {
+        const { reverse, limit } = this.options;
+        let sql = 'SELECT key FROM entries';
+        sql += ` ORDER BY key ${reverse ? 'DESC' : 'ASC'}`;
+        if (void 0 !== limit && limit >= 0) sql += ` LIMIT ${limit}`;
+        const result = await this.adapter.execute(sql);
+        this.rows = result.rows;
     }
-    if ('undefined' != typeof window) window.addEventListener('online', ()=>{
-        logger.info('Network online - notifying offline executor', {
-            collectionName
+}
+class SqliteValueIterator extends AbstractValueIterator {
+    adapter;
+    options;
+    rows = null;
+    index = 0;
+    constructor(db, adapter, options){
+        super(db, options);
+        this.adapter = adapter;
+        this.options = options;
+    }
+    async _next() {
+        if (null === this.rows) await this.loadRows();
+        if (this.rows && this.index < this.rows.length) {
+            const row = this.rows[this.index++];
+            return new TextDecoder().decode(row.value);
+        }
+    }
+    async loadRows() {
+        const { reverse, limit } = this.options;
+        let sql = 'SELECT value FROM entries';
+        sql += ` ORDER BY key ${reverse ? 'DESC' : 'ASC'}`;
+        if (void 0 !== limit && limit >= 0) sql += ` LIMIT ${limit}`;
+        const result = await this.adapter.execute(sql);
+        this.rows = result.rows;
+    }
+}
+class SqliteKeyValueStore {
+    db;
+    prefix = 'kv:';
+    constructor(db){
+        this.db = db;
+    }
+    async get(key) {
+        try {
+            const value = await this.db.get(this.prefix + key);
+            if (void 0 === value) return;
+            return JSON.parse(value);
+        } catch  {
+            return;
+        }
+    }
+    async set(key, value) {
+        await this.db.put(this.prefix + key, JSON.stringify(value));
+    }
+    async del(key) {
+        await this.db.del(this.prefix + key);
+    }
+}
+class SqlitePersistenceProvider {
+    persistence;
+    whenSynced;
+    constructor(collection, _ydoc, leveldb){
+        this.persistence = leveldb;
+        this.whenSynced = this.persistence.getYDoc(collection).then((storedDoc)=>{
+            storedDoc.store;
         });
-        offline.notifyOnline();
+    }
+    destroy() {
+        this.persistence.destroy();
+    }
+}
+async function sqlitePersistence(options) {
+    const { adapter, dbName = 'replicate' } = options;
+    const db = new SqliteLevel(dbName);
+    db.setAdapterFactory(()=>Promise.resolve(adapter));
+    await db.open();
+    const leveldb = new LeveldbPersistence(dbName, {
+        level: db
+    });
+    const kv = new SqliteKeyValueStore(db);
+    return {
+        createDocPersistence: (collection, ydoc)=>new SqlitePersistenceProvider(collection, ydoc, leveldb),
+        kv
+    };
+}
+class SqlJsAdapter {
+    db;
+    onPersist;
+    constructor(db, options = {}){
+        this.db = db;
+        this.onPersist = options.onPersist;
+    }
+    async execute(sql, params) {
+        const rows = [];
+        if (sql.trim().toUpperCase().startsWith('CREATE') || sql.trim().toUpperCase().startsWith('INSERT') || sql.trim().toUpperCase().startsWith('UPDATE') || sql.trim().toUpperCase().startsWith('DELETE') || sql.trim().toUpperCase().startsWith('BEGIN') || sql.trim().toUpperCase().startsWith('COMMIT') || sql.trim().toUpperCase().startsWith('ROLLBACK')) {
+            this.db.run(sql, params);
+            await this.persist();
+            return {
+                rows
+            };
+        }
+        const stmt = this.db.prepare(sql);
+        if (params && params.length > 0) stmt.bind(params);
+        while(stmt.step())rows.push(stmt.getAsObject());
+        stmt.free();
+        return {
+            rows
+        };
+    }
+    close() {
+        this.db.close();
+    }
+    async persist() {
+        if (this.onPersist) {
+            const data = this.db.export();
+            await this.onPersist(new Uint8Array(data));
+        }
+    }
+}
+async function loadFromOPFS(dbName) {
+    try {
+        const root = await navigator.storage.getDirectory();
+        const handle = await root.getFileHandle(`${dbName}.sqlite`);
+        const file = await handle.getFile();
+        const buffer = await file.arrayBuffer();
+        return new Uint8Array(buffer);
+    } catch  {
+        return null;
+    }
+}
+function createOPFSSaver(dbName) {
+    return async (data)=>{
+        try {
+            const root = await navigator.storage.getDirectory();
+            const handle = await root.getFileHandle(`${dbName}.sqlite`, {
+                create: true
+            });
+            const writable = await handle.createWritable();
+            const buffer = new ArrayBuffer(data.length);
+            new Uint8Array(buffer).set(data);
+            await writable.write(buffer);
+            await writable.close();
+        } catch  {}
+    };
+}
+async function createBrowserSqlitePersistence(SQL, dbName) {
+    const existingData = await loadFromOPFS(dbName);
+    const db = existingData ? new SQL.Database(existingData) : new SQL.Database();
+    const adapter = new SqlJsAdapter(db, {
+        onPersist: createOPFSSaver(dbName)
     });
-    logger.info('Offline support initialized', {
-        collectionName,
-        mode: offline.mode
+    return sqlitePersistence({
+        adapter,
+        dbName
     });
-    return rawCollection;
 }
-export { NonRetriableError, ReplicateStorage, __WEBPACK_EXTERNAL_MODULE_yjs__ as Y, convexCollectionOptions, createConvexCollection };
+class OPSqliteAdapter {
+    db;
+    constructor(db){
+        this.db = db;
+    }
+    async execute(sql, params) {
+        const result = await this.db.execute(sql, params);
+        return {
+            rows: result.rows || []
+        };
+    }
+    close() {
+        this.db.close();
+    }
+}
+async function createReactNativeSqlitePersistence(db, dbName) {
+    const adapter = new OPSqliteAdapter(db);
+    return sqlitePersistence({
+        adapter,
+        dbName
+    });
+}
+const persistence_persistence = {
+    indexeddb: indexeddbPersistence,
+    memory: memoryPersistence,
+    sqlite: {
+        browser: createBrowserSqlitePersistence,
+        native: createReactNativeSqlitePersistence,
+        create: sqlitePersistence
+    }
+};
+const errors = {
+    Network: NetworkError,
+    IDB: IDBError,
+    IDBWrite: IDBWriteError,
+    Reconciliation: ReconciliationError,
+    Prose: ProseError,
+    CollectionNotReady: CollectionNotReadyError,
+    NonRetriable: NonRetriableError
+};
+const prose = {
+    extract: extract
+};
+const adapters = {
+    sqljs: SqlJsAdapter,
+    opsqlite: OPSqliteAdapter
+};
+export { adapters, convexCollectionOptions, errors, persistence_persistence as persistence, prose };