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

package/dist/modern/service-worker.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 { Observable as Observable$1, BehaviorSubject, firstValueFrom, Subject, from as from$1, filter as filter$1, 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 { Observable as Observable$1, BehaviorSubject, firstValueFrom, Subject, from as from$1, filter as filter$1, 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.
@@ -1765,8 +1765,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
@@ -1831,8 +1831,8 @@ const b64encode = typeof Buffer !== "undefined"
         return btoa(strs.join(""));
     };
 
-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 })),
@@ -1868,8 +1868,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];
@@ -2754,13 +2754,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) {
@@ -3104,6 +3111,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) {
@@ -3516,8 +3529,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)
@@ -4347,8 +4360,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`);
@@ -4409,6 +4422,7 @@ function syncWithServer(changes, y, syncState, baseRevs, db, databaseUrl, schema
             lastPull: syncState
                 ? {
                     serverRevision: syncState.serverRevision,
+                    yServerRevision: syncState.yServerRevision,
                     realms: syncState.realms,
                     inviteRealms: syncState.inviteRealms,
                 }
@@ -4753,12 +4767,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,
                     });
@@ -4783,7 +4800,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': {
@@ -4793,15 +4827,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,
@@ -4848,14 +4893,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);
                 }
             }));
@@ -4866,8 +4909,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] === '*')) {
@@ -4982,8 +5025,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({
@@ -5025,11 +5067,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 });
         }
@@ -5046,7 +5088,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)
             : [];
@@ -5071,7 +5113,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) {
@@ -5191,6 +5233,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);
@@ -5202,11 +5245,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
@@ -5340,8 +5389,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 {
@@ -5499,7 +5548,7 @@ function MessagesFromServerConsumer(db) {
     };
 }
 
-const wm$1 = new WeakMap();
+const wm$2 = new WeakMap();
 const DEXIE_CLOUD_SCHEMA = {
     members: '@id, [userId+realmId], [email+realmId], realmId',
     roles: '[realmId+name]',
@@ -5513,7 +5562,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$1.get(dx.cloud);
+    let db = wm$2.get(dx.cloud);
     if (!db) {
         const localSyncEvent = new Subject();
         let syncStateChangedEvent = new BroadcastedAndLocalEvent(`syncstatechanged-${dx.name}`);
@@ -5601,7 +5650,7 @@ function DexieCloudDB(dx) {
         Object.assign(db, helperMethods);
         db.messageConsumer = MessagesFromServerConsumer(db);
         db.messageProducer = new Subject();
-        wm$1.set(dx.cloud, db);
+        wm$2.set(dx.cloud, db);
     }
     return db;
 }
@@ -5612,10 +5661,10 @@ function nameFromKeyPath(keyPath) {
 }
 
 // Emulate true-private property db. Why? So it's not stored in DB.
-const wm = new WeakMap();
+const wm$1 = new WeakMap();
 class AuthPersistedContext {
     constructor(db, userLogin) {
-        wm.set(this, db);
+        wm$1.set(this, db);
         Object.assign(this, userLogin);
     }
     static load(db, userId) {
@@ -5632,7 +5681,7 @@ class AuthPersistedContext {
     }
     save() {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = wm.get(this);
+            const db = wm$1.get(this);
             db.table("$logins").put(this);
         });
     }
@@ -5656,8 +5705,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
@@ -5695,11 +5744,11 @@ function _logout(db, { deleteUnsyncedData = false } = {}) {
 
 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') {
@@ -5865,8 +5914,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))) {
@@ -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(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;
 }
 
 const DEFAULT_OPTIONS = {
@@ -7957,7 +8150,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() {
@@ -7993,16 +8186,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);
@@ -8060,8 +8253,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:
@@ -8084,7 +8277,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(),
@@ -8106,7 +8299,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) {
@@ -8120,7 +8313,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.'
@@ -8163,10 +8356,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) {
@@ -8191,20 +8380,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))) {
@@ -8219,8 +8417,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) &&
@@ -8229,7 +8436,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();
@@ -8249,7 +8458,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) {
@@ -8259,7 +8468,7 @@ function dexieCloud(dexie) {
     }
 }
 // @ts-ignore
-dexieCloud.version = "4.1.0-alpha.8";
+dexieCloud.version = "4.1.0-beta.25";
 Dexie.Cloud = dexieCloud;
 
 // In case the SW lives for a while, let it reuse already opened connections:
@@ -8289,8 +8498,8 @@ function syncDB(dbName, purpose) {
     }
     return promise;
     function _syncDB(dbName, purpose) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             let db = managedDBs.get(dbName);
             if (!db) {
                 console.debug('Dexie Cloud SW: Creating new Dexie instance for', dbName);