dexie-cloud-addon 4.1.0-alpha.8 → 4.1.0-beta.25

package/dist/modern/dexie-cloud-addon.js

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.1.0-alpha.8, Tue Oct 15 2024
+ * Version 4.1.0-beta.25, Wed Dec 04 2024
  *
  * https://dexie.org
  *
@@ -16,8 +16,8 @@
  * 
  */
 
-import Dexie, { PropModification, cmp, DexieYProvider, liveQuery } from 'dexie';
-import { firstValueFrom, from as from$1, filter as filter$1, Observable as Observable$1, BehaviorSubject, Subject, fromEvent, of, merge, mergeMap as mergeMap$1, Subscription as Subscription$1, throwError, combineLatest, map as map$1, share, timer as timer$1 } from 'rxjs';
+import Dexie, { PropModification, cmp, DexieYProvider, RangeSet, liveQuery } from 'dexie';
+import { firstValueFrom, from as from$1, filter as filter$1, Observable as Observable$1, BehaviorSubject, Subject, fromEvent, of, merge, switchMap as switchMap$1, tap as tap$1, mergeMap as mergeMap$1, Subscription as Subscription$1, throwError, combineLatest, map as map$1, share, timer as timer$1, startWith as startWith$1 } from 'rxjs';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -979,13 +979,20 @@ const writeAny = (encoder, data) => {
 function encodeYMessage(msg) {
     const encoder = new Encoder();
     writeVarString(encoder, msg.type);
-    writeVarString(encoder, msg.table);
-    writeVarString(encoder, msg.prop);
+    if ('table' in msg)
+        writeVarString(encoder, msg.table);
+    if ('prop' in msg)
+        writeVarString(encoder, msg.prop);
     switch (msg.type) {
         case 'u-ack':
         case 'u-reject':
             writeBigUint64(encoder, BigInt(msg.i));
             break;
+        case 'outdated-server-rev':
+            break;
+        case 'y-complete-sync-done':
+            writeVarString(encoder, msg.yServerRev);
+            break;
         default:
             writeAny(encoder, msg.k);
             switch (msg.type) {
@@ -1329,6 +1336,12 @@ const readAny = decoder => readAnyLookupTable[127 - readUint8(decoder)](decoder)
 function decodeYMessage(a) {
     const decoder = new Decoder(a);
     const type = readVarString(decoder);
+    if (type === 'outdated-server-rev') {
+        return { type };
+    }
+    if (type === 'y-complete-sync-done') {
+        return { type, yServerRev: readVarString(decoder) };
+    }
     const table = readVarString(decoder);
     const prop = readVarString(decoder);
     switch (type) {
@@ -2987,8 +3000,8 @@ function registerSyncEvent(db, purpose) {
     });
 }
 function registerPeriodicSyncEvent(db) {
-    var _a;
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         try {
             // Register periodicSync event to SW:
             // @ts-ignore
@@ -3199,8 +3212,8 @@ function confirmLogout(userInteraction, currentUserId, numUnsyncedChanges) {
 }
 
 function loadAccessToken(db) {
-    var _a, _b, _c;
     return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
         const currentUser = yield db.getCurrentUser();
         const { accessToken, accessTokenExpiration, refreshToken, refreshTokenExpiration, claims, } = currentUser;
         if (!accessToken)
@@ -3414,10 +3427,10 @@ function formatAsPem(str) {
 }
 
 // Emulate true-private property db. Why? So it's not stored in DB.
-const wm$1 = new WeakMap();
+const wm$2 = new WeakMap();
 class AuthPersistedContext {
     constructor(db, userLogin) {
-        wm$1.set(this, db);
+        wm$2.set(this, db);
         Object.assign(this, userLogin);
     }
     static load(db, userId) {
@@ -3434,7 +3447,7 @@ class AuthPersistedContext {
     }
     save() {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = wm$1.get(this);
+            const db = wm$2.get(this);
             db.table("$logins").put(this);
         });
     }
@@ -3472,8 +3485,8 @@ function logout(db) {
         }
     });
 }
-function _logout(db, { deleteUnsyncedData = false } = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
+function _logout(db_1) {
+    return __awaiter(this, arguments, void 0, function* (db, { deleteUnsyncedData = false } = {}) {
         // Clear the database without emptying configuration options.
         const [numUnsynced, loggedOut] = yield db.dx.transaction('rw', db.dx.tables, (tx) => __awaiter(this, void 0, void 0, function* () {
             // @ts-ignore
@@ -3521,11 +3534,11 @@ class HttpError extends Error {
 
 function otpFetchTokenCallback(db) {
     const { userInteraction } = db.cloud;
-    return function otpAuthenticate({ public_key, hints }) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
+    return function otpAuthenticate(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ public_key, hints }) {
+            var _b;
             let tokenRequest;
-            const url = (_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.databaseUrl;
+            const url = (_b = db.cloud.options) === null || _b === void 0 ? void 0 : _b.databaseUrl;
             if (!url)
                 throw new Error(`No database URL given.`);
             if ((hints === null || hints === void 0 ? void 0 : hints.grant_type) === 'demo') {
@@ -3691,8 +3704,8 @@ function setCurrentUser(db, user) {
 }
 
 function login(db, hints) {
-    var _a;
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         const currentUser = yield db.getCurrentUser();
         const origUserId = currentUser.userId;
         if (currentUser.isLoggedIn && (!hints || (!hints.email && !hints.userId))) {
@@ -3880,8 +3893,8 @@ class BroadcastedAndLocalEvent extends Observable$1 {
     }
 }
 
-function computeRealmSetHash({ realms, inviteRealms, }) {
-    return __awaiter(this, void 0, void 0, function* () {
+function computeRealmSetHash(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ realms, inviteRealms, }) {
         const data = JSON.stringify([
             ...realms.map((realmId) => ({ realmId, accepted: true })),
             ...inviteRealms.map((realmId) => ({ realmId, accepted: false })),
@@ -3917,8 +3930,8 @@ function flatten(a) {
     return concat.apply([], a);
 }
 
-function listClientChanges(mutationTables, db, { since = {}, limit = Infinity } = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
+function listClientChanges(mutationTables_1, db_1) {
+    return __awaiter(this, arguments, void 0, function* (mutationTables, db, { since = {}, limit = Infinity } = {}) {
         const allMutsOnTables = yield Promise.all(mutationTables.map((mutationTable) => __awaiter(this, void 0, void 0, function* () {
             const tableName = getTableFromMutationTable(mutationTable.name);
             const lastRevision = since[tableName];
@@ -4653,8 +4666,8 @@ function cloneChange(change, rewriteValues) {
 // seconds (given that there is a Ratelimit-Reset header).
 let syncRatelimitDelays = new WeakMap();
 function checkSyncRateLimitDelay(db) {
-    var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
         const delatMilliseconds = ((_b = (_a = syncRatelimitDelays.get(db)) === null || _a === void 0 ? void 0 : _a.getTime()) !== null && _b !== void 0 ? _b : 0) - Date.now();
         if (delatMilliseconds > 0) {
             console.debug(`Stalling sync request ${delatMilliseconds} ms to spare ratelimits`);
@@ -4715,6 +4728,7 @@ function syncWithServer(changes, y, syncState, baseRevs, db, databaseUrl, schema
             lastPull: syncState
                 ? {
                     serverRevision: syncState.serverRevision,
+                    yServerRevision: syncState.yServerRevision,
                     realms: syncState.realms,
                     inviteRealms: syncState.inviteRealms,
                 }
@@ -4944,7 +4958,7 @@ function listUpdatesSince(yTable, sinceIncluding) {
         .toArray();
 }
 
-function $Y(db) {
+function $Y$1(db) {
     const $Y = db.dx._options.Y;
     if (!$Y)
         throw new Error('Y library not supplied to Dexie constructor');
@@ -4974,7 +4988,7 @@ function listYClientMessagesAndStateVector(db, tablesToSync) {
         for (const table of tablesToSync) {
             if (table.schema.yProps) {
                 for (const yProp of table.schema.yProps) {
-                    const Y = $Y(db); // This is how we retrieve the user-provided Y library
+                    const Y = $Y$1(db); // This is how we retrieve the user-provided Y library
                     const yTable = db.table(yProp.updatesTable); // the updates-table for this combo of table+propName
                     const syncState = (yield yTable.get(DEXIE_CLOUD_SYNCER_ID));
                     // unsentFrom = the `i` value of updates that aren't yet sent to server (or at least not acked by the server yet)
@@ -5059,12 +5073,15 @@ function getUpdatesTable(db, table, ydocProp) {
 
 function applyYServerMessages(yMessages, db) {
     return __awaiter(this, void 0, void 0, function* () {
-        const result = {};
+        var _a;
+        const receivedUntils = {};
+        let resyncNeeded = false;
+        let yServerRevision;
         for (const m of yMessages) {
             switch (m.type) {
                 case 'u-s': {
                     const utbl = getUpdatesTable(db, m.table, m.prop);
-                    result[utbl.name] = yield utbl.add({
+                    receivedUntils[utbl.name] = yield utbl.add({
                         k: m.k,
                         u: m.u,
                     });
@@ -5089,7 +5106,24 @@ function applyYServerMessages(yMessages, db) {
                     // See my question in https://discuss.yjs.dev/t/generate-an-inverse-update/2765
                     console.debug(`Y update rejected. Deleting it.`);
                     const utbl = getUpdatesTable(db, m.table, m.prop);
-                    yield utbl.delete(m.i);
+                    // Delete the rejected update and all local updates since (avoid holes in the CRDT)
+                    // and destroy it's open document if there is one.
+                    const primaryKey = (_a = (yield utbl.get(m.i))) === null || _a === void 0 ? void 0 : _a.k;
+                    if (primaryKey != null) {
+                        yield db.transaction('rw', utbl, (tx) => {
+                            // @ts-ignore
+                            tx.idbtrans._rejecting_y_ypdate = true; // Inform ydoc triggers that we delete because of a rejection and not GC
+                            return utbl
+                                .where('i')
+                                .aboveOrEqual(m.i)
+                                .filter((u) => cmp(u.k, primaryKey) === 0 && ((u.f || 0) & 1) === 1)
+                                .delete();
+                        });
+                        // Destroy active doc
+                        const activeDoc = DexieYProvider.getDocCache(db.dx).find(m.table, primaryKey, m.prop);
+                        if (activeDoc)
+                            activeDoc.destroy(); // Destroy the document so that editors don't continue to work on it
+                    }
                     break;
                 }
                 case 'in-sync': {
@@ -5099,15 +5133,26 @@ function applyYServerMessages(yMessages, db) {
                     }
                     break;
                 }
+                case 'y-complete-sync-done': {
+                    yServerRevision = m.yServerRev;
+                    break;
+                }
+                case 'outdated-server-rev':
+                    resyncNeeded = true;
+                    break;
             }
         }
-        return result;
+        return {
+            receivedUntils,
+            resyncNeeded,
+            yServerRevision
+        };
     });
 }
 
-function updateYSyncStates(lastUpdateIdsBeforeSync, receivedUntilsAfterSync, db, serverRevision) {
-    var _a, _b, _c, _d, _e;
+function updateYSyncStates(lastUpdateIdsBeforeSync, receivedUntilsAfterSync, db) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
         // We want to update unsentFrom for each yTable to the value specified in first argument
         //  because we got those values before we synced with server and here we are back from server
         //  that has successfully received all those messages - no matter if the last update was a client or server update,
@@ -5154,14 +5199,12 @@ function updateYSyncStates(lastUpdateIdsBeforeSync, receivedUntilsAfterSync, db,
                     yield db.table(yTable).add({
                         i: DEXIE_CLOUD_SYNCER_ID,
                         unsentFrom,
-                        receivedUntil,
-                        serverRev: serverRevision,
+                        receivedUntil
                     });
                 }
                 else {
                     state.unsentFrom = Math.max(unsentFrom, state.unsentFrom || 1);
                     state.receivedUntil = Math.max(receivedUntil, state.receivedUntil || 0);
-                    state.serverRev = serverRevision;
                     yield db.table(yTable).put(state);
                 }
             }));
@@ -5172,8 +5215,8 @@ function updateYSyncStates(lastUpdateIdsBeforeSync, receivedUntilsAfterSync, db,
 const BINSTREAM_TYPE_REALMID = 1;
 const BINSTREAM_TYPE_TABLE_AND_PROP = 2;
 const BINSTREAM_TYPE_DOCUMENT = 3;
-function downloadYDocsFromServer(db, databaseUrl, { yDownloadedRealms, realms }) {
-    return __awaiter(this, void 0, void 0, function* () {
+function downloadYDocsFromServer(db_1, databaseUrl_1, _a) {
+    return __awaiter(this, arguments, void 0, function* (db, databaseUrl, { yDownloadedRealms, realms }) {
         if (yDownloadedRealms &&
             realms &&
             realms.every((realmId) => yDownloadedRealms[realmId] === '*')) {
@@ -5288,8 +5331,7 @@ function downloadYDocsFromServer(db, databaseUrl, { yDownloadedRealms, realms })
 
 const CURRENT_SYNC_WORKER = 'currentSyncWorker';
 function sync(db, options, schema, syncOptions) {
-    return _sync
-        .apply(this, arguments)
+    return _sync(db, options, schema, syncOptions)
         .then((result) => {
         if (!(syncOptions === null || syncOptions === void 0 ? void 0 : syncOptions.justCheckIfNeeded)) { // && syncOptions?.purpose !== 'push') {
             db.syncStateChangedEvent.next({
@@ -5331,11 +5373,11 @@ function sync(db, options, schema, syncOptions) {
         return Promise.reject(error);
     }));
 }
-function _sync(db, options, schema, { isInitialSync, cancelToken, justCheckIfNeeded, purpose } = {
-    isInitialSync: false,
-}) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function* () {
+function _sync(db_1, options_1, schema_1) {
+    return __awaiter(this, arguments, void 0, function* (db, options, schema, { isInitialSync, cancelToken, justCheckIfNeeded, purpose } = {
+        isInitialSync: false,
+    }) {
+        var _a;
         if (!justCheckIfNeeded) {
             console.debug('SYNC STARTED', { isInitialSync, purpose });
         }
@@ -5352,7 +5394,7 @@ function _sync(db, options, schema, { isInitialSync, cancelToken, justCheckIfNee
         // Prepare for syncification by modifying locally unauthorized objects:
         //
         const persistedSyncState = yield db.getPersistedSyncState();
-        const readyForSyncification = !isInitialSync && currentUser.isLoggedIn;
+        const readyForSyncification = currentUser.isLoggedIn;
         const tablesToSyncify = readyForSyncification
             ? getTablesToSyncify(db, persistedSyncState)
             : [];
@@ -5377,7 +5419,7 @@ function _sync(db, options, schema, { isInitialSync, cancelToken, justCheckIfNee
         const [clientChangeSet, syncState, baseRevs, { yMessages, lastUpdateIds }] = yield db.transaction('r', db.tables, () => __awaiter(this, void 0, void 0, function* () {
             const syncState = yield db.getPersistedSyncState();
             const baseRevs = yield db.$baseRevs.toArray();
-            let clientChanges = yield listClientChanges(mutationTables);
+            let clientChanges = yield listClientChanges(mutationTables, db);
             const yResults = yield listYClientMessagesAndStateVector(db, tablesToSync);
             throwIfCancelled(cancelToken);
             if (doSyncify) {
@@ -5497,6 +5539,7 @@ function _sync(db, options, schema, { isInitialSync, cancelToken, justCheckIfNee
             newSyncState.realms = res.realms;
             newSyncState.inviteRealms = res.inviteRealms;
             newSyncState.serverRevision = res.serverRevision;
+            newSyncState.yServerRevision = res.serverRevision;
             newSyncState.timestamp = new Date();
             delete newSyncState.error;
             const filteredChanges = filterServerChangesThroughAddedClientChanges(res.changes, addedClientChanges);
@@ -5508,11 +5551,17 @@ function _sync(db, options, schema, { isInitialSync, cancelToken, justCheckIfNee
                 //
                 // apply yMessages
                 //
-                const receivedUntils = yield applyYServerMessages(res.yMessages, db);
+                const { receivedUntils, resyncNeeded, yServerRevision } = yield applyYServerMessages(res.yMessages, db);
+                if (yServerRevision) {
+                    newSyncState.yServerRevision = yServerRevision;
+                }
                 //
                 // update Y SyncStates
                 //
-                yield updateYSyncStates(lastUpdateIds, receivedUntils, db, res.serverRevision);
+                yield updateYSyncStates(lastUpdateIds, receivedUntils, db);
+                if (resyncNeeded) {
+                    newSyncState.yDownloadedRealms = {}; // Will trigger a full download of Y-documents below...
+                }
             }
             //
             // Update regular syncState
@@ -5646,8 +5695,8 @@ function MessagesFromServerConsumer(db) {
         event.next(null);
     }
     function consumeQueue() {
-        var _a, _b, _c, _d, _e, _f;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
             while (queue.length > 0) {
                 const msg = queue.shift();
                 try {
@@ -5805,7 +5854,7 @@ function MessagesFromServerConsumer(db) {
     };
 }
 
-const wm = new WeakMap();
+const wm$1 = new WeakMap();
 const DEXIE_CLOUD_SCHEMA = {
     members: '@id, [userId+realmId], [email+realmId], realmId',
     roles: '[realmId+name]',
@@ -5819,7 +5868,7 @@ let static_counter = 0;
 function DexieCloudDB(dx) {
     if ('vip' in dx)
         dx = dx['vip']; // Avoid race condition. Always map to a vipped dexie that don't block during db.on.ready().
-    let db = wm.get(dx.cloud);
+    let db = wm$1.get(dx.cloud);
     if (!db) {
         const localSyncEvent = new Subject();
         let syncStateChangedEvent = new BroadcastedAndLocalEvent(`syncstatechanged-${dx.name}`);
@@ -5907,7 +5956,7 @@ function DexieCloudDB(dx) {
         Object.assign(db, helperMethods);
         db.messageConsumer = MessagesFromServerConsumer(db);
         db.messageProducer = new Subject();
-        wm.set(dx.cloud, db);
+        wm$1.set(dx.cloud, db);
     }
     return db;
 }
@@ -6303,8 +6352,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                             outstandingTransactions.next(outstandingTransactions.value);
                         };
                         const txComplete = () => {
-                            if (tx.mutationsAdded &&
-                                !isEagerSyncDisabled(db)) {
+                            if (tx.mutationsAdded && !isEagerSyncDisabled(db)) {
                                 triggerSync(db, 'push');
                             }
                             removeTransaction();
@@ -6386,26 +6434,107 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                                 : mutateAndLog(req);
                         } }));
                     function mutateAndLog(req) {
+                        var _a, _b;
                         const trans = req.trans;
-                        trans.mutationsAdded = true;
+                        const unsyncedProps = (_b = (_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.unsyncedProperties) === null || _b === void 0 ? void 0 : _b[tableName];
                         const { txid, currentUser: { userId }, } = trans;
                         const { type } = req;
                         const opNo = ++trans.opCount;
+                        function stripChangeSpec(changeSpec) {
+                            if (!unsyncedProps)
+                                return changeSpec;
+                            let rv = changeSpec;
+                            for (const keyPath of Object.keys(changeSpec)) {
+                                if (unsyncedProps.some((p) => keyPath === p || keyPath.startsWith(p + '.'))) {
+                                    if (rv === changeSpec)
+                                        rv = Object.assign({}, changeSpec); // clone on demand
+                                    delete rv[keyPath];
+                                }
+                            }
+                            return rv;
+                        }
                         return table.mutate(req).then((res) => {
+                            var _a;
                             const { numFailures: hasFailures, failures } = res;
                             let keys = type === 'delete' ? req.keys : res.results;
                             let values = 'values' in req ? req.values : [];
-                            let updates = 'updates' in req && req.updates;
+                            let changeSpec = 'changeSpec' in req ? req.changeSpec : undefined;
+                            let updates = 'updates' in req ? req.updates : undefined;
                             if (hasFailures) {
                                 keys = keys.filter((_, idx) => !failures[idx]);
                                 values = values.filter((_, idx) => !failures[idx]);
                             }
+                            if (unsyncedProps) {
+                                // Filter out unsynced properties
+                                values = values.map((value) => {
+                                    const newValue = Object.assign({}, value);
+                                    for (const prop of unsyncedProps) {
+                                        delete newValue[prop];
+                                    }
+                                    return newValue;
+                                });
+                                if (changeSpec) {
+                                    // modify operation with criteria and changeSpec.
+                                    // We must strip out unsynced properties from changeSpec.
+                                    // We deal with criteria later.
+                                    changeSpec = stripChangeSpec(changeSpec);
+                                    if (Object.keys(changeSpec).length === 0) {
+                                        // Nothing to change on server
+                                        return res;
+                                    }
+                                }
+                                if (updates) {
+                                    let strippedChangeSpecs = updates.changeSpecs.map(stripChangeSpec);
+                                    let newUpdates = {
+                                        keys: [],
+                                        changeSpecs: [],
+                                    };
+                                    const validKeys = new RangeSet();
+                                    let anyChangeSpecBecameEmpty = false;
+                                    for (let i = 0, l = strippedChangeSpecs.length; i < l; ++i) {
+                                        if (Object.keys(strippedChangeSpecs[i]).length > 0) {
+                                            newUpdates.keys.push(updates.keys[i]);
+                                            newUpdates.changeSpecs.push(strippedChangeSpecs[i]);
+                                            validKeys.addKey(updates.keys[i]);
+                                        }
+                                        else {
+                                            anyChangeSpecBecameEmpty = true;
+                                        }
+                                    }
+                                    updates = newUpdates;
+                                    if (anyChangeSpecBecameEmpty) {
+                                        // Some keys were stripped. We must also strip them from keys and values
+                                        let newKeys = [];
+                                        let newValues = [];
+                                        for (let i = 0, l = keys.length; i < l; ++i) {
+                                            if (validKeys.hasKey(keys[i])) {
+                                                newKeys.push(keys[i]);
+                                                newValues.push(values[i]);
+                                            }
+                                        }
+                                        keys = newKeys;
+                                        values = newValues;
+                                    }
+                                }
+                            }
                             const ts = Date.now();
                             // Canonicalize req.criteria.index to null if it's on the primary key.
-                            const criteria = 'criteria' in req && req.criteria
+                            let criteria = 'criteria' in req && req.criteria
                                 ? Object.assign(Object.assign({}, req.criteria), { index: req.criteria.index === schema.primaryKey.keyPath // Use null to inform server that criteria is on primary key
                                         ? null // This will disable the server from trying to log consistent operations where it shouldnt.
                                         : req.criteria.index }) : undefined;
+                            if (unsyncedProps && (criteria === null || criteria === void 0 ? void 0 : criteria.index)) {
+                                const keyPaths = (_a = schema.indexes.find((idx) => idx.name === criteria.index)) === null || _a === void 0 ? void 0 : _a.keyPath;
+                                const involvedProps = keyPaths
+                                    ? typeof keyPaths === 'string'
+                                        ? [keyPaths]
+                                        : keyPaths
+                                    : [];
+                                if (involvedProps.some((p) => unsyncedProps === null || unsyncedProps === void 0 ? void 0 : unsyncedProps.includes(p))) {
+                                    // Don't log criteria on unsynced properties as the server could not test them.
+                                    criteria = undefined;
+                                }
+                            }
                             const mut = req.type === 'delete'
                                 ? {
                                     type: 'delete',
@@ -6426,7 +6555,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                                         userId,
                                         values,
                                     }
-                                    : criteria && req.changeSpec
+                                    : criteria && changeSpec
                                         ? {
                                             // Common changeSpec for all keys
                                             type: 'modify',
@@ -6434,37 +6563,51 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                                             opNo,
                                             keys,
                                             criteria,
-                                            changeSpec: req.changeSpec,
+                                            changeSpec,
                                             txid,
                                             userId,
                                         }
-                                        : updates
+                                        : changeSpec
                                             ? {
-                                                // One changeSpec per key
+                                                // In case criteria involved an unsynced property, we go for keys instead.
                                                 type: 'update',
                                                 ts,
                                                 opNo,
-                                                keys: updates.keys,
-                                                changeSpecs: updates.changeSpecs,
-                                                txid,
-                                                userId,
-                                            }
-                                            : {
-                                                type: 'upsert',
-                                                ts,
-                                                opNo,
                                                 keys,
-                                                values,
+                                                changeSpecs: keys.map(() => changeSpec),
                                                 txid,
                                                 userId,
-                                            };
+                                            }
+                                            : updates
+                                                ? {
+                                                    // One changeSpec per key
+                                                    type: 'update',
+                                                    ts,
+                                                    opNo,
+                                                    keys: updates.keys,
+                                                    changeSpecs: updates.changeSpecs,
+                                                    txid,
+                                                    userId,
+                                                }
+                                                : {
+                                                    type: 'upsert',
+                                                    ts,
+                                                    opNo,
+                                                    keys,
+                                                    values,
+                                                    txid,
+                                                    userId,
+                                                };
                             if ('isAdditionalChunk' in req && req.isAdditionalChunk) {
                                 mut.isAdditionalChunk = true;
                             }
                             return keys.length > 0 || criteria
                                 ? mutsTable
                                     .mutate({ type: 'add', trans, values: [mut] }) // Log entry
-                                    .then(() => res) // Return original response
+                                    .then(() => {
+                                    trans.mutationsAdded = true; // Mark transaction as having added mutations to trigger eager sync
+                                    return res; // Return original response
+                                })
                                 : res;
                         });
                     }
@@ -6548,10 +6691,18 @@ function overrideParseStoresSpec(origFunc, dexie) {
     };
 }
 
+function performGuardedJob(db, jobName, job) {
+    if (typeof navigator === 'undefined' || !navigator.locks) {
+        // No support for guarding jobs. IE11, node.js, etc.
+        return job();
+    }
+    return navigator.locks.request(db.name + '|' + jobName, () => job());
+}
+
 function performInitialSync(db, cloudOptions, cloudSchema) {
     return __awaiter(this, void 0, void 0, function* () {
         console.debug('Performing initial sync');
-        yield sync(db, cloudOptions, cloudSchema, { isInitialSync: true });
+        yield performGuardedJob(db, CURRENT_SYNC_WORKER, () => sync(db, cloudOptions, cloudSchema, { isInitialSync: true }));
         console.debug('Done initial sync');
     });
 }
@@ -6638,29 +6789,35 @@ function createYClientUpdateObservable(db) {
         updatesTable: p.updatesTable,
     }))));
     return merge(...yTableRecords.map(({ table, ydocProp, updatesTable }) => {
-        let currentUnsentFrom = 1;
-        return liveQuery(() => __awaiter(this, void 0, void 0, function* () {
-            const yTbl = db.table(updatesTable);
-            const unsentFrom = yield yTbl
-                .where({ i: DEXIE_CLOUD_SYNCER_ID })
-                .first()
-                .then((syncer) => (syncer === null || syncer === void 0 ? void 0 : syncer.unsentFrom) || 1);
-            currentUnsentFrom = Math.max(currentUnsentFrom, unsentFrom);
-            const addedUpdates = yield listUpdatesSince(yTbl, currentUnsentFrom);
-            // Update currentUnsentFrom to only listen for updates that will be newer than the ones we emitted.
-            currentUnsentFrom = Math.max(currentUnsentFrom, ...addedUpdates.map((update) => update.i + 1));
-            return addedUpdates
-                .filter((update) => update.f && update.f & 1) // Only include local updates
-                .map((update) => {
-                return {
-                    type: 'u-c',
-                    table,
-                    prop: ydocProp,
-                    k: update.k,
-                    u: update.u,
-                    i: update.i,
-                };
-            });
+        // Per updates table (table+prop combo), we first read syncer.unsentFrom,
+        // and then start listening for updates since that number.
+        const yTbl = db.table(updatesTable);
+        return from$1(yTbl.get(DEXIE_CLOUD_SYNCER_ID)).pipe(switchMap$1((syncer) => {
+            let currentUnsentFrom = (syncer === null || syncer === void 0 ? void 0 : syncer.unsentFrom) || 1;
+            return from$1(liveQuery(() => __awaiter(this, void 0, void 0, function* () {
+                const addedUpdates = yield listUpdatesSince(yTbl, currentUnsentFrom);
+                return addedUpdates
+                    .filter((update) => update.f && update.f & 1) // Only include local updates
+                    .map((update) => {
+                    return {
+                        type: 'u-c',
+                        table,
+                        prop: ydocProp,
+                        k: update.k,
+                        u: update.u,
+                        i: update.i,
+                    };
+                });
+            }))).pipe(tap$1((addedUpdates) => {
+                // Update currentUnsentFrom to only listen for updates that will be newer than the ones we emitted.
+                // (Before, we did this within the liveQuery, but that caused a bug because
+                // a cancelled emittion of a liveQuery would update the currentUnsentFrom without
+                // emitting anything, leading to that we jumped over some updates. Here we update it
+                // after the liveQuery has emitted its updates)
+                if (addedUpdates.length > 0) {
+                    currentUnsentFrom = addedUpdates.at(-1).i + 1;
+                }
+            }));
         }));
     })).pipe(
     // Flatten the array of messages.
@@ -6680,6 +6837,23 @@ function getAwarenessLibrary(db) {
 const awarenessWeakMap = new WeakMap();
 const getDocAwareness = (doc) => awarenessWeakMap.get(doc);
 
+const wm = new WeakMap();
+/** A property (package-private) on Y.Doc that is used
+ * to signal that the server wants us to send a 'doc-open' message
+ * to the server for this document.
+ *
+ * @param doc
+ * @returns
+ */
+function getOpenDocSignal(doc) {
+    let signal = wm.get(doc);
+    if (!signal) {
+        signal = new Subject();
+        wm.set(doc, signal);
+    }
+    return signal;
+}
+
 const SERVER_PING_TIMEOUT = 20000;
 const CLIENT_PING_INTERVAL = 30000;
 const FAIL_RETRY_WAIT_TIME = 60000;
@@ -6842,9 +7016,6 @@ class WSConnection extends Subscription$1 {
                     if (msg.type === 'error') {
                         throw new Error(`Error message from dexie-cloud: ${msg.error}`);
                     }
-                    else if (msg.type === 'rev') {
-                        this.rev = msg.rev; // No meaning but seems reasonable.
-                    }
                     else if (msg.type === 'aware') {
                         const docCache = DexieYProvider.getDocCache(this.db.dx);
                         const doc = docCache.find(msg.table, msg.k, msg.prop);
@@ -6859,7 +7030,19 @@ class WSConnection extends Subscription$1 {
                     else if (msg.type === 'u-ack' || msg.type === 'u-reject' || msg.type === 'u-s' || msg.type === 'in-sync') {
                         applyYServerMessages([msg], this.db);
                     }
+                    else if (msg.type === 'doc-open') {
+                        const docCache = DexieYProvider.getDocCache(this.db.dx);
+                        const doc = docCache.find(msg.table, msg.k, msg.prop);
+                        if (doc) {
+                            getOpenDocSignal(doc).next(); // Make yHandler reopen the document on server.
+                        }
+                    }
+                    else if (msg.type === 'outdated-server-rev' || msg.type === 'y-complete-sync-done') {
+                        // Won't happen but need this for typing.
+                        throw new Error('Outdated server revision or y-complete-sync-done not expected over WebSocket - only in sync using fetch()');
+                    }
                     else if (msg.type !== 'pong') {
+                        // Forward the request to our subscriber, wich is in messageFromServerQueue.ts (via connectWebSocket's subscribe() at the end!)
                         this.subscriber.next(msg);
                     }
                 }
@@ -6896,6 +7079,10 @@ class WSConnection extends Subscription$1 {
                         }
                         console.debug('dexie-cloud WebSocket send', msg.type, msg);
                         if (msg.type === 'ready') {
+                            // Ok, we are certain to have stored everything up until revision msg.rev.
+                            // Update this.rev in case of reconnect - remember where we were and don't just start over!
+                            this.rev = msg.rev;
+                            // ... and then send along the request to the server so it would also be updated!
                             (_a = this.ws) === null || _a === void 0 ? void 0 : _a.send(TSON.stringify(msg));
                         }
                         else {
@@ -6977,7 +7164,7 @@ function connectWebSocket(db) {
                 return db.cloud.persistedSyncState.pipe(filter((syncState) => (syncState === null || syncState === void 0 ? void 0 : syncState.realms.includes(userLogin.userId)) || false), take(1), map((syncState) => [userLogin, syncState]));
             }
             return new BehaviorSubject([userLogin, syncState]);
-        }), switchMap(([userLogin, syncState]) => __awaiter(this, void 0, void 0, function* () { return [userLogin, yield computeRealmSetHash(syncState)]; })), distinctUntilChanged(([prevUser, prevHash], [currUser, currHash]) => prevUser === currUser && prevHash === currHash), switchMap(([userLogin, realmSetHash]) => {
+        }), switchMap((_a) => __awaiter(this, [_a], void 0, function* ([userLogin, syncState]) { return [userLogin, yield computeRealmSetHash(syncState)]; })), distinctUntilChanged(([prevUser, prevHash], [currUser, currHash]) => prevUser === currUser && prevHash === currHash), switchMap(([userLogin, realmSetHash]) => {
             var _a;
             if (!((_a = db.cloud.persistedSyncState) === null || _a === void 0 ? void 0 : _a.value)) {
                 // Restart the flow if persistedSyncState is not yet available.
@@ -7038,22 +7225,14 @@ function connectWebSocket(db) {
 }
 
 function isSyncNeeded(db) {
-    var _a;
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         return ((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.databaseUrl) && db.cloud.schema
             ? yield sync(db, db.cloud.options, db.cloud.schema, { justCheckIfNeeded: true })
             : false;
     });
 }
 
-function performGuardedJob(db, jobName, job) {
-    if (typeof navigator === 'undefined' || !navigator.locks) {
-        // No support for guarding jobs. IE11, node.js, etc.
-        return job();
-    }
-    return navigator.locks.request(db.name + '|' + jobName, () => job());
-}
-
 const ongoingSyncs = new WeakMap();
 function syncIfPossible(db, cloudOptions, cloudSchema, options) {
     const ongoing = ongoingSyncs.get(db);
@@ -7107,20 +7286,7 @@ function syncIfPossible(db, cloudOptions, cloudSchema, options) {
             try {
                 // Check if should delay sync due to ratelimit:
                 yield checkSyncRateLimitDelay(db);
-                // Check if we need to lock the sync job. Not needed if we are the service worker.
-                if (db.cloud.isServiceWorkerDB) {
-                    // We are the dedicated sync SW:
-                    yield sync(db, cloudOptions, cloudSchema, options);
-                }
-                else if (!db.cloud.usingServiceWorker) {
-                    // We use a flow that is better suited for the case when multiple workers want to
-                    // do the same thing.
-                    yield performGuardedJob(db, CURRENT_SYNC_WORKER, () => sync(db, cloudOptions, cloudSchema, options));
-                }
-                else {
-                    assert(false);
-                    throw new Error('Internal _syncIfPossible() - invalid precondition - should not have been called.');
-                }
+                yield performGuardedJob(db, CURRENT_SYNC_WORKER, () => sync(db, cloudOptions, cloudSchema, options));
                 ongoingSyncs.delete(db);
                 console.debug('Done sync');
             }
@@ -7723,6 +7889,7 @@ class PermissionChecker {
         // If user can update any prop in any table in this realm, return true unless
         // it regards to ownership change:
         if (this.permissions.update === '*') {
+            // @ts-ignore
             return props.every((prop) => prop !== 'owner');
         }
         const tablePermissions = (_b = this.permissions.update) === null || _b === void 0 ? void 0 : _b[this.tableName];
@@ -7796,125 +7963,151 @@ const getInvitesObservable = associate((db) => {
 function createYHandler(db) {
     return (provider) => {
         var _a;
-        const awap = getAwarenessLibrary(db);
         const doc = provider.doc;
-        const { parentTable, parentId, parentProp, updatesTable } = doc.meta;
+        const { parentTable } = doc.meta || {};
         if (!((_a = db.cloud.schema) === null || _a === void 0 ? void 0 : _a[parentTable].markedForSync)) {
             return; // The table that holds the doc is not marked for sync - leave it to dexie. No syncing, no awareness.
         }
-        let awareness = new awap.Awareness(doc);
-        awarenessWeakMap.set(doc, awareness);
-        provider.awareness = awareness;
-        awareness.on('update', ({ added, updated, removed }, origin) => {
-            // Send the update
-            const changedClients = added.concat(updated).concat(removed);
-            const user = db.cloud.currentUser.value;
-            if (origin !== 'server' && user.isLoggedIn && !isEagerSyncDisabled(db)) {
-                const update = awap.encodeAwarenessUpdate(awareness, changedClients);
+        let awareness;
+        Object.defineProperty(provider, 'awareness', {
+            get() {
+                if (awareness)
+                    return awareness;
+                awareness = createAwareness(db, doc, provider);
+                awarenessWeakMap.set(doc, awareness);
+                return awareness;
+            },
+        });
+    };
+}
+function createAwareness(db, doc, provider) {
+    const { parentTable, parentId, parentProp, updatesTable } = doc.meta;
+    const awap = getAwarenessLibrary(db);
+    const awareness = new awap.Awareness(doc);
+    const reopenDocSignal = getOpenDocSignal(doc);
+    awareness.on('update', ({ added, updated, removed }, origin) => {
+        // Send the update
+        const changedClients = added.concat(updated).concat(removed);
+        const user = db.cloud.currentUser.value;
+        if (origin !== 'server' && user.isLoggedIn && !isEagerSyncDisabled(db)) {
+            const update = awap.encodeAwarenessUpdate(awareness, changedClients);
+            db.messageProducer.next({
+                type: 'aware',
+                table: parentTable,
+                prop: parentProp,
+                k: doc.meta.parentId,
+                u: update,
+            });
+            if (provider.destroyed) {
+                // We're called from awareness.on('destroy') that did
+                // removeAwarenessStates.
+                // It's time to also send the doc-close message that dexie-cloud understands
+                // and uses to stop subscribing for updates and awareness updates and brings
+                // down the cached information in memory on the WS connection for this.
                 db.messageProducer.next({
-                    type: 'aware',
+                    type: 'doc-close',
                     table: parentTable,
                     prop: parentProp,
                     k: doc.meta.parentId,
-                    u: update,
                 });
-                if (provider.destroyed) {
-                    // We're called from awareness.on('destroy') that did
-                    // removeAwarenessStates. 
-                    // It's time to also send the doc-close message that dexie-cloud understands
-                    // and uses to stop subscribing for updates and awareness updates and brings
-                    // down the cached information in memory on the WS connection for this.
-                    db.messageProducer.next({
-                        type: 'doc-close',
-                        table: parentTable,
-                        prop: parentProp,
-                        k: doc.meta.parentId
-                    });
-                }
             }
-        });
-        awareness.on('destroy', () => {
-            // Signal to server that this provider is destroyed (the update event will be triggered, which
-            // in turn will trigger db.messageProducer that will send the message to the server if WS is connected)
-            awap.removeAwarenessStates(awareness, [doc.clientID], 'provider destroyed');
-        });
-        // Now wait til document is loaded and then open the document on the server
-        provider.on('load', () => __awaiter(this, void 0, void 0, function* () {
+        }
+    });
+    awareness.on('destroy', () => {
+        // Signal to server that this provider is destroyed (the update event will be triggered, which
+        // in turn will trigger db.messageProducer that will send the message to the server if WS is connected)
+        awap.removeAwarenessStates(awareness, [doc.clientID], 'provider destroyed');
+    });
+    // Open the document on the server
+    (() => __awaiter(this, void 0, void 0, function* () {
+        if (provider.destroyed)
+            return;
+        let connected = false;
+        let currentFlowId = 1;
+        const subscription = combineLatest([
+            db.cloud.webSocketStatus, // Wake up when webSocket status changes
+            reopenDocSignal.pipe(startWith$1(null)), // Wake up when reopenDocSignal emits
+        ]).subscribe(([wsStatus]) => {
             if (provider.destroyed)
                 return;
-            let connected = false;
-            let currentFlowId = 1;
-            const subscription = db.cloud.webSocketStatus.subscribe((wsStatus) => {
-                if (provider.destroyed)
+            // Keep "connected" state in a variable so we can check it after async operations
+            connected = wsStatus === 'connected';
+            // We are or got connected. Open the document on the server.
+            const user = db.cloud.currentUser.value;
+            if (wsStatus === 'connected' &&
+                user.isLoggedIn &&
+                !isEagerSyncDisabled(db)) {
+                ++currentFlowId;
+                openDocumentOnServer().catch((error) => {
+                    console.warn(`Error catched in createYHandler.ts: ${error}`);
+                });
+            }
+        });
+        // Wait until WebSocket is connected
+        provider.addCleanupHandler(subscription);
+        /** Sends an 'doc-open' message to server whenever websocket becomes
+         * connected, or if it is already connected.
+         * The flow is aborted in case websocket is disconnected while querying
+         * information required to compute the state vector. Flow is also
+         * aborted in case document or provider has been destroyed during
+         * the async parts of the task.
+         *
+         * The state vector is only computed from the updates that have occured
+         * after the last full sync - which could very often be zero - in which
+         * case no state vector is sent (then the server already knows us by
+         * revision)
+         *
+         * When server gets the doc-open message, it will authorize us for
+         * whether we are allowed to read / write to this document, and then
+         * keep the cached information in memory on the WS connection for this
+         * particular document, as well as subscribe to updates and awareness updates
+         * from other clients on the document.
+         */
+        function openDocumentOnServer() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const myFlow = currentFlowId; // So we can abort when a new flow is started
+                const yTbl = db.table(updatesTable);
+                const syncStateTbl = db.$syncState;
+                const [receivedUntil, yServerRev] = yield db.transaction('r', syncStateTbl, yTbl, () => __awaiter(this, void 0, void 0, function* () {
+                    const syncState = yield yTbl.get(DEXIE_CLOUD_SYNCER_ID);
+                    const persistedSyncState = yield syncStateTbl.get('syncState');
+                    return [
+                        (syncState === null || syncState === void 0 ? void 0 : syncState.receivedUntil) || 0,
+                        (persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.yServerRevision) ||
+                            (persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.serverRevision),
+                    ];
+                }));
+                // After every await, check if we still should be working on this task.
+                if (provider.destroyed || currentFlowId !== myFlow || !connected)
                     return;
-                // Keep "connected" state in a variable so we can check it after async operations
-                connected = wsStatus === 'connected';
-                // We are or got connected. Open the document on the server.
-                const user = db.cloud.currentUser.value;
-                if (wsStatus === "connected" && user.isLoggedIn && !isEagerSyncDisabled(db)) {
-                    ++currentFlowId;
-                    openDocumentOnServer().catch(error => {
-                        console.warn(`Error catched in createYHandler.ts: ${error}`);
-                    });
+                const docOpenMsg = {
+                    type: 'doc-open',
+                    table: parentTable,
+                    prop: parentProp,
+                    k: parentId,
+                    serverRev: yServerRev,
+                };
+                const serverUpdatesSinceLastSync = yield yTbl
+                    .where('i')
+                    .between(receivedUntil, Infinity, false)
+                    .filter((update) => cmp(update.k, parentId) === 0 && // Only updates for this document
+                    ((update.f || 0) & 1) === 0 // Don't include local changes
+                )
+                    .toArray();
+                // After every await, check if we still should be working on this task.
+                if (provider.destroyed || currentFlowId !== myFlow || !connected)
+                    return;
+                if (serverUpdatesSinceLastSync.length > 0) {
+                    const Y = $Y$1(db); // Get the Yjs library from Dexie constructor options
+                    const mergedUpdate = Y.mergeUpdatesV2(serverUpdatesSinceLastSync.map((update) => update.u));
+                    const stateVector = Y.encodeStateVectorFromUpdateV2(mergedUpdate);
+                    docOpenMsg.sv = stateVector;
                 }
+                db.messageProducer.next(docOpenMsg);
             });
-            // Wait until WebSocket is connected
-            provider.addCleanupHandler(subscription);
-            /** Sends an 'doc-open' message to server whenever websocket becomes
-             * connected, or if it is already connected.
-             * The flow is aborted in case websocket is disconnected while querying
-             * information required to compute the state vector. Flow is also
-             * aborted in case document or provider has been destroyed during
-             * the async parts of the task.
-             *
-             * The state vector is only computed from the updates that have occured
-             * after the last full sync - which could very often be zero - in which
-             * case no state vector is sent (then the server already knows us by
-             * revision)
-             *
-             * When server gets the doc-open message, it will authorized us for
-             * whether we are allowed to read / write to this document, and then
-             * keep the cached information in memory on the WS connection for this
-             * particular document, as well as subscribe to updates and awareness updates
-             * from other clients on the document.
-             */
-            function openDocumentOnServer(wsStatus) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    const myFlow = currentFlowId; // So we can abort when a new flow is started
-                    const yTbl = db.table(updatesTable);
-                    const syncState = yield yTbl.get(DEXIE_CLOUD_SYNCER_ID);
-                    // After every await, check if we still should be working on this task.
-                    if (provider.destroyed || currentFlowId !== myFlow || !connected)
-                        return;
-                    const receivedUntil = (syncState === null || syncState === void 0 ? void 0 : syncState.receivedUntil) || 0;
-                    const docOpenMsg = {
-                        type: 'doc-open',
-                        table: parentTable,
-                        prop: parentProp,
-                        k: parentId,
-                        serverRev: syncState === null || syncState === void 0 ? void 0 : syncState.serverRev,
-                    };
-                    const serverUpdatesSinceLastSync = yield yTbl
-                        .where('i')
-                        .between(receivedUntil, Infinity, false)
-                        .filter((update) => cmp(update.k, parentId) === 0 && // Only updates for this document
-                        ((update.f || 0) & 1) === 0 // Don't include local changes
-                    )
-                        .toArray();
-                    // After every await, check if we still should be working on this task.
-                    if (provider.destroyed || currentFlowId !== myFlow || !connected)
-                        return;
-                    if (serverUpdatesSinceLastSync.length > 0) {
-                        const Y = $Y(db); // Get the Yjs library from Dexie constructor options
-                        const mergedUpdate = Y.mergeUpdatesV2(serverUpdatesSinceLastSync.map((update) => update.u));
-                        const stateVector = Y.encodeStateVectorFromUpdateV2(mergedUpdate);
-                        docOpenMsg.sv = stateVector;
-                    }
-                    db.messageProducer.next(docOpenMsg);
-                });
-            }
-        }));
-    };
+        }
+    }))();
+    return awareness;
 }
 
 function getTiedRealmId(objectId) {
@@ -7964,7 +8157,7 @@ function dexieCloud(dexie) {
     const syncComplete = new Subject();
     dexie.cloud = {
         // @ts-ignore
-        version: "4.1.0-alpha.8",
+        version: "4.1.0-beta.25",
         options: Object.assign({}, DEFAULT_OPTIONS),
         schema: null,
         get currentUserId() {
@@ -8000,16 +8193,16 @@ function dexieCloud(dexie) {
             }
             updateSchemaFromOptions(dexie.cloud.schema, dexie.cloud.options);
         },
-        logout({ force } = {}) {
-            return __awaiter(this, void 0, void 0, function* () {
+        logout() {
+            return __awaiter(this, arguments, void 0, function* ({ force } = {}) {
                 force
                     ? yield _logout(DexieCloudDB(dexie), { deleteUnsyncedData: true })
                     : yield logout(DexieCloudDB(dexie));
             });
         },
-        sync({ wait, purpose } = { wait: true, purpose: 'push' }) {
-            var _a;
-            return __awaiter(this, void 0, void 0, function* () {
+        sync() {
+            return __awaiter(this, arguments, void 0, function* ({ wait, purpose } = { wait: true, purpose: 'push' }) {
+                var _a;
                 if (wait === undefined)
                     wait = true;
                 const db = DexieCloudDB(dexie);
@@ -8067,8 +8260,8 @@ function dexieCloud(dexie) {
     dexie.use(createImplicitPropSetterMiddleware(DexieCloudDB(dexie)));
     dexie.use(createIdGenerationMiddleware(DexieCloudDB(dexie)));
     function onDbReady(dexie) {
-        var _a, _b, _c, _d, _e, _f, _g;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g;
             closed = false; // As Dexie calls us, we are not closed anymore. Maybe reopened? Remember db.ready event is registered with sticky flag!
             const db = DexieCloudDB(dexie);
             // Setup default GUI:
@@ -8091,7 +8284,7 @@ function dexieCloud(dexie) {
                 ? yield navigator.serviceWorker.getRegistrations()
                 : [];
             const [initiallySynced, lastSyncedRealms] = yield db.transaction('rw', db.$syncState, () => __awaiter(this, void 0, void 0, function* () {
-                var _h, _j;
+                var _a, _b;
                 const { options, schema } = db.cloud;
                 const [persistedOptions, persistedSchema, persistedSyncState] = yield Promise.all([
                     db.getOptions(),
@@ -8113,7 +8306,7 @@ function dexieCloud(dexie) {
                     delete newPersistedOptions.awarenessProtocol;
                     yield db.$syncState.put(newPersistedOptions, 'options');
                 }
-                if (((_h = db.cloud.options) === null || _h === void 0 ? void 0 : _h.tryUseServiceWorker) &&
+                if (((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.tryUseServiceWorker) &&
                     'serviceWorker' in navigator &&
                     swRegistrations.length > 0 &&
                     !DISABLE_SERVICEWORKER_STRATEGY) {
@@ -8127,7 +8320,7 @@ function dexieCloud(dexie) {
                     // Not configured for using service worker or no service worker
                     // registration exists. Don't rely on service worker to do any job.
                     // Use LocalSyncWorker instead.
-                    if (((_j = db.cloud.options) === null || _j === void 0 ? void 0 : _j.tryUseServiceWorker) &&
+                    if (((_b = db.cloud.options) === null || _b === void 0 ? void 0 : _b.tryUseServiceWorker) &&
                         !db.cloud.isServiceWorkerDB) {
                         console.debug('dexie-cloud-addon: Not using service worker.', swRegistrations.length === 0
                             ? 'No SW registrations found.'
@@ -8170,10 +8363,6 @@ function dexieCloud(dexie) {
                 db.setInitiallySynced(true);
             }
             verifySchema(db);
-            if (((_b = db.cloud.options) === null || _b === void 0 ? void 0 : _b.databaseUrl) && !initiallySynced) {
-                yield performInitialSync(db, db.cloud.options, db.cloud.schema);
-                db.setInitiallySynced(true);
-            }
             // Manage CurrentUser observable:
             throwIfClosed();
             if (!db.cloud.isServiceWorkerDB) {
@@ -8198,20 +8387,29 @@ function dexieCloud(dexie) {
             // HERE: If requireAuth, do athentication now.
             let changedUser = false;
             const user = yield db.getCurrentUser();
-            const requireAuth = (_c = db.cloud.options) === null || _c === void 0 ? void 0 : _c.requireAuth;
+            const requireAuth = (_b = db.cloud.options) === null || _b === void 0 ? void 0 : _b.requireAuth;
             if (requireAuth) {
-                if (typeof requireAuth === 'object') {
-                    // requireAuth contains login hints. Check if we already fulfil it:
-                    if (!user.isLoggedIn ||
-                        (requireAuth.userId && user.userId !== requireAuth.userId) ||
-                        (requireAuth.email && user.email !== requireAuth.email)) {
-                        // If not, login the configured user:
-                        changedUser = yield login(db, requireAuth);
-                    }
+                if (db.cloud.isServiceWorkerDB) {
+                    // If this is a service worker DB, we can't do authentication here,
+                    // we just wait until the application has done it.
+                    console.debug('Dexie Cloud Service worker. Waiting for application to authenticate.');
+                    yield firstValueFrom(currentUserEmitter.pipe(filter((user) => !!user.isLoggedIn), take(1)));
+                    console.debug('Dexie Cloud Service worker. Application has authenticated.');
                 }
-                else if (!user.isLoggedIn) {
-                    // requireAuth is true and user is not logged in
-                    changedUser = yield login(db);
+                else {
+                    if (typeof requireAuth === 'object') {
+                        // requireAuth contains login hints. Check if we already fulfil it:
+                        if (!user.isLoggedIn ||
+                            (requireAuth.userId && user.userId !== requireAuth.userId) ||
+                            (requireAuth.email && user.email !== requireAuth.email)) {
+                            // If not, login the configured user:
+                            changedUser = yield login(db, requireAuth);
+                        }
+                    }
+                    else if (!user.isLoggedIn) {
+                        // requireAuth is true and user is not logged in
+                        changedUser = yield login(db);
+                    }
                 }
             }
             if (user.isLoggedIn && (!lastSyncedRealms || !lastSyncedRealms.includes(user.userId))) {
@@ -8226,8 +8424,17 @@ function dexieCloud(dexie) {
                 localSyncWorker.stop();
             localSyncWorker = null;
             throwIfClosed();
+            const doInitialSync = ((_c = db.cloud.options) === null || _c === void 0 ? void 0 : _c.databaseUrl) && (!initiallySynced || changedUser);
+            if (doInitialSync) {
+                // Do the initial sync directly in the browser thread no matter if we are using service worker or not.
+                yield performInitialSync(db, db.cloud.options, db.cloud.schema);
+                db.setInitiallySynced(true);
+            }
+            throwIfClosed();
             if (db.cloud.usingServiceWorker && ((_d = db.cloud.options) === null || _d === void 0 ? void 0 : _d.databaseUrl)) {
-                registerSyncEvent(db, changedUser ? 'pull' : 'push').catch(() => { });
+                if (!doInitialSync) {
+                    registerSyncEvent(db, 'push').catch(() => { });
+                }
                 registerPeriodicSyncEvent(db).catch(() => { });
             }
             else if (((_e = db.cloud.options) === null || _e === void 0 ? void 0 : _e.databaseUrl) &&
@@ -8236,7 +8443,9 @@ function dexieCloud(dexie) {
                 // There's no SW. Start SyncWorker instead.
                 localSyncWorker = LocalSyncWorker(db, db.cloud.options, db.cloud.schema);
                 localSyncWorker.start();
-                triggerSync(db, changedUser ? 'pull' : 'push');
+                if (!doInitialSync) {
+                    triggerSync(db, 'push');
+                }
             }
             // Listen to online event and do sync.
             throwIfClosed();
@@ -8256,7 +8465,7 @@ function dexieCloud(dexie) {
                     });
                 }));
             }
-            // Connect WebSocket unless we
+            // Connect WebSocket unless we are in a service worker or websocket is disabled.
             if (((_f = db.cloud.options) === null || _f === void 0 ? void 0 : _f.databaseUrl) &&
                 !((_g = db.cloud.options) === null || _g === void 0 ? void 0 : _g.disableWebSocket) &&
                 !IS_SERVICE_WORKER) {
@@ -8266,8 +8475,164 @@ function dexieCloud(dexie) {
     }
 }
 // @ts-ignore
-dexieCloud.version = "4.1.0-alpha.8";
+dexieCloud.version = "4.1.0-beta.25";
 Dexie.Cloud = dexieCloud;
 
-export { dexieCloud as default, dexieCloud, getTiedObjectId, getTiedRealmId, resolveText };
+const ydocTriggers = {};
+const docIsAlreadyHooked = new WeakSet();
+const middlewares = new WeakMap();
+const createMiddleware = (db) => ({
+    stack: 'dbcore',
+    level: 10,
+    name: 'yTriggerMiddleware',
+    create: (down) => {
+        return Object.assign(Object.assign({}, down), { transaction: (stores, mode, options) => {
+                const idbtrans = down.transaction(stores, mode, options);
+                idbtrans.addEventListener('complete', onTransactionCommitted);
+                return idbtrans;
+            }, table: (tblName) => {
+                const coreTable = down.table(tblName);
+                const triggerSpec = ydocTriggers[tblName];
+                if (!triggerSpec)
+                    return coreTable;
+                const { trigger, parentTable, prop } = triggerSpec;
+                return Object.assign(Object.assign({}, coreTable), { mutate(req) {
+                        switch (req.type) {
+                            case 'add': {
+                                for (const yUpdateRow of req.values) {
+                                    if (yUpdateRow.k == undefined)
+                                        continue; // A syncer or garbage collection state does not point to a key
+                                    const primaryKey = yUpdateRow.k;
+                                    const doc = DexieYProvider.getDocCache(db).find(parentTable, primaryKey, prop);
+                                    if (doc) {
+                                        if (!docIsAlreadyHooked.has(doc)) {
+                                            hookToDoc(doc, primaryKey, trigger);
+                                            docIsAlreadyHooked.add(doc);
+                                        }
+                                    }
+                                    else {
+                                        enqueueTrigger(db, tblName, primaryKey, trigger);
+                                    }
+                                }
+                                break;
+                            }
+                            case 'delete':
+                                // @ts-ignore
+                                if (req.trans._rejecting_y_ypdate) {
+                                    // The deletion came from a rejection, not garbage collection.
+                                    // When that happens, let the triggers run to compute new values
+                                    // based on the deleted updates.
+                                    coreTable
+                                        .getMany({
+                                        keys: req.keys,
+                                        trans: req.trans,
+                                        cache: 'immutable',
+                                    })
+                                        .then((updates) => {
+                                        const keySet = new RangeSet();
+                                        for (const { k } of updates) {
+                                            if (k != undefined)
+                                                keySet.addKey(k);
+                                        }
+                                        for (const interval of keySet) {
+                                            enqueueTrigger(db, tblName, interval.from, trigger);
+                                        }
+                                    });
+                                }
+                                break;
+                        }
+                        return coreTable.mutate(req);
+                    } });
+            } });
+    },
+});
+let triggerExecPromise = null;
+let triggerScheduled = false;
+let scheduledTriggers = [];
+function $Y(db) {
+    const $Y = db._options.Y;
+    if (!$Y)
+        throw new Error('Y library not supplied to Dexie constructor');
+    return $Y;
+}
+function executeTriggers(triggersToRun) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const { db, parentId, trigger, updatesTable } of triggersToRun) {
+            // Load entire document into an Y.Doc instance:
+            const updates = yield db
+                .table(updatesTable)
+                .where({ k: parentId })
+                .toArray();
+            const Y = $Y(db);
+            const yDoc = new Y.Doc();
+            for (const update of updates) {
+                Y.applyUpdateV2(yDoc, update.u);
+            }
+            try {
+                yield trigger(yDoc, parentId);
+            }
+            catch (error) {
+                console.error(`Error in YDocTrigger ${error}`);
+            }
+        }
+    });
+}
+function enqueueTrigger(db, updatesTable, parentId, trigger) {
+    scheduledTriggers.push({
+        db,
+        updatesTable,
+        parentId,
+        trigger,
+    });
+}
+function onTransactionCommitted() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!triggerScheduled && scheduledTriggers.length > 0) {
+            triggerScheduled = true;
+            if (triggerExecPromise)
+                yield triggerExecPromise.catch(() => { });
+            setTimeout(() => {
+                // setTimeout() is to escape from Promise.PSD zones and never run within liveQueries or transaction scopes
+                triggerScheduled = false;
+                const triggersToRun = scheduledTriggers;
+                scheduledTriggers = [];
+                triggerExecPromise = executeTriggers(triggersToRun).finally(() => (triggerExecPromise = null));
+            }, 0);
+        }
+    });
+}
+function hookToDoc(doc, parentId, trigger) {
+    // From now on, keep listening to doc updates and execute the trigger when it happens there instead
+    doc.on('updateV2', (update, origin) => {
+        //Dexie.ignoreTransaction(()=>{
+        trigger(doc, parentId);
+        //});
+    });
+    /*
+      NOT NEEDED because DexieYProvider's docCache will also listen to destroy and remove it from its cache:
+      doc.on('destroy', ()=>{
+      docIsAlreadyHooked.delete(doc);
+    })
+    */
+}
+function defineYDocTrigger(table, prop, trigger) {
+    var _a, _b;
+    const updatesTable = (_b = (_a = table.schema.yProps) === null || _a === void 0 ? void 0 : _a.find((p) => p.prop === prop)) === null || _b === void 0 ? void 0 : _b.updatesTable;
+    if (!updatesTable)
+        throw new Error(`Table ${table.name} does not have a Yjs property named ${prop}`);
+    ydocTriggers[updatesTable] = {
+        trigger,
+        parentTable: table.name,
+        prop,
+    };
+    const db = table.db._novip;
+    let mw = middlewares.get(db);
+    if (!mw) {
+        mw = createMiddleware(db);
+        middlewares.set(db, mw);
+    }
+    db.use(mw);
+}
+
+export { dexieCloud as default, defineYDocTrigger, dexieCloud, getTiedObjectId, getTiedRealmId, resolveText };
 //# sourceMappingURL=dexie-cloud-addon.js.map