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

package/dist/umd/service-worker.js

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.1.0-alpha.9, Tue Oct 15 2024
+ * Version 4.1.0-beta.25, Wed Dec 04 2024
  *
  * https://dexie.org
  *
@@ -1768,8 +1768,8 @@
         });
     }
     function registerPeriodicSyncEvent(db) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             try {
                 // Register periodicSync event to SW:
                 // @ts-ignore
@@ -1834,8 +1834,8 @@
             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 })),
@@ -1871,8 +1871,8 @@
         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];
@@ -2757,13 +2757,20 @@
     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) {
@@ -3107,6 +3114,12 @@
     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) {
@@ -3519,8 +3532,8 @@
     }
 
     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)
@@ -4350,8 +4363,8 @@
     // 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`);
@@ -4412,6 +4425,7 @@
                 lastPull: syncState
                     ? {
                         serverRevision: syncState.serverRevision,
+                        yServerRevision: syncState.yServerRevision,
                         realms: syncState.realms,
                         inviteRealms: syncState.inviteRealms,
                     }
@@ -4756,12 +4770,15 @@
 
     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,
                         });
@@ -4786,7 +4803,24 @@
                         // 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) => Dexie.cmp(u.k, primaryKey) === 0 && ((u.f || 0) & 1) === 1)
+                                    .delete();
+                            });
+                            // Destroy active doc
+                            const activeDoc = Dexie.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': {
@@ -4796,15 +4830,26 @@
                         }
                         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,
@@ -4851,14 +4896,12 @@
                         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);
                     }
                 }));
@@ -4869,8 +4912,8 @@
     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] === '*')) {
@@ -4985,8 +5028,7 @@
 
     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({
@@ -5028,11 +5070,11 @@
             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 });
             }
@@ -5049,7 +5091,7 @@
             // 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)
                 : [];
@@ -5074,7 +5116,7 @@
             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) {
@@ -5194,6 +5236,7 @@
                 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);
@@ -5205,11 +5248,17 @@
                     //
                     // 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
@@ -5343,8 +5392,8 @@
             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 {
@@ -5502,7 +5551,7 @@
         };
     }
 
-    const wm$1 = new WeakMap();
+    const wm$2 = new WeakMap();
     const DEXIE_CLOUD_SCHEMA = {
         members: '@id, [userId+realmId], [email+realmId], realmId',
         roles: '[realmId+name]',
@@ -5516,7 +5565,7 @@
     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 rxjs.Subject();
             let syncStateChangedEvent = new BroadcastedAndLocalEvent(`syncstatechanged-${dx.name}`);
@@ -5604,7 +5653,7 @@
             Object.assign(db, helperMethods);
             db.messageConsumer = MessagesFromServerConsumer(db);
             db.messageProducer = new rxjs.Subject();
-            wm$1.set(dx.cloud, db);
+            wm$2.set(dx.cloud, db);
         }
         return db;
     }
@@ -5615,10 +5664,10 @@
     }
 
     // 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) {
@@ -5635,7 +5684,7 @@
         }
         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);
             });
         }
@@ -5659,8 +5708,8 @@
             }
         });
     }
-    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
@@ -5698,11 +5747,11 @@
 
     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') {
@@ -5868,8 +5917,8 @@
     }
 
     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))) {
@@ -6306,8 +6355,7 @@
                                 outstandingTransactions.next(outstandingTransactions.value);
                             };
                             const txComplete = () => {
-                                if (tx.mutationsAdded &&
-                                    !isEagerSyncDisabled(db)) {
+                                if (tx.mutationsAdded && !isEagerSyncDisabled(db)) {
                                     triggerSync(db, 'push');
                                 }
                                 removeTransaction();
@@ -6389,26 +6437,107 @@
                                     : 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 Dexie.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',
@@ -6429,7 +6558,7 @@
                                             userId,
                                             values,
                                         }
-                                        : criteria && req.changeSpec
+                                        : criteria && changeSpec
                                             ? {
                                                 // Common changeSpec for all keys
                                                 type: 'modify',
@@ -6437,37 +6566,51 @@
                                                 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;
                             });
                         }
@@ -6551,10 +6694,18 @@
         };
     }
 
+    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');
         });
     }
@@ -6641,38 +6792,42 @@
             updatesTable: p.updatesTable,
         }))));
         return rxjs.merge(...yTableRecords.map(({ table, ydocProp, updatesTable }) => {
-            let currentUnsentFrom = 1;
-            return Dexie.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 rxjs.from(yTbl.get(DEXIE_CLOUD_SYNCER_ID)).pipe(rxjs.switchMap((syncer) => {
+                let currentUnsentFrom = (syncer === null || syncer === void 0 ? void 0 : syncer.unsentFrom) || 1;
+                return rxjs.from(Dexie.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(rxjs.tap((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.
         // If messageProducer emits empty array, nothing is emitted
         // but if messageProducer emits array of messages, they are
         // emitted one by one.
-        rxjs.mergeMap((messages) => messages), rxjs.tap(message => {
-            console.debug('dexie-cloud emitting y-c', message);
-        }));
+        rxjs.mergeMap((messages) => messages));
     }
 
     function getAwarenessLibrary(db) {
@@ -6685,6 +6840,23 @@
     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 rxjs.Subject();
+            wm.set(doc, signal);
+        }
+        return signal;
+    }
+
     const SERVER_PING_TIMEOUT = 20000;
     const CLIENT_PING_INTERVAL = 30000;
     const FAIL_RETRY_WAIT_TIME = 60000;
@@ -6847,9 +7019,6 @@
                         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 = Dexie.DexieYProvider.getDocCache(this.db.dx);
                             const doc = docCache.find(msg.table, msg.k, msg.prop);
@@ -6864,7 +7033,19 @@
                         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 = Dexie.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);
                         }
                     }
@@ -6901,6 +7082,10 @@
                             }
                             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 {
@@ -6982,7 +7167,7 @@
                     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 rxjs.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.
@@ -7043,22 +7228,14 @@
     }
 
     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);
@@ -7112,20 +7289,7 @@
                 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');
                 }
@@ -7728,6 +7892,7 @@
             // 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];
@@ -7801,125 +7966,151 @@
     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 = rxjs.combineLatest([
+                db.cloud.webSocketStatus, // Wake up when webSocket status changes
+                reopenDocSignal.pipe(rxjs.startWith(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) => Dexie.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) => Dexie.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 = {
@@ -7962,7 +8153,7 @@
         const syncComplete = new rxjs.Subject();
         dexie.cloud = {
             // @ts-ignore
-            version: "4.1.0-alpha.9",
+            version: "4.1.0-beta.25",
             options: Object.assign({}, DEFAULT_OPTIONS),
             schema: null,
             get currentUserId() {
@@ -7998,16 +8189,16 @@
                 }
                 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);
@@ -8065,8 +8256,8 @@
         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:
@@ -8089,7 +8280,7 @@
                     ? 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(),
@@ -8111,7 +8302,7 @@
                         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) {
@@ -8125,7 +8316,7 @@
                         // 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.'
@@ -8168,10 +8359,6 @@
                     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) {
@@ -8196,20 +8383,29 @@
                 // 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 rxjs.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))) {
@@ -8224,8 +8420,17 @@
                     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) &&
@@ -8234,7 +8439,9 @@
                     // 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();
@@ -8254,7 +8461,7 @@
                         });
                     }));
                 }
-                // 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) {
@@ -8264,7 +8471,7 @@
         }
     }
     // @ts-ignore
-    dexieCloud.version = "4.1.0-alpha.9";
+    dexieCloud.version = "4.1.0-beta.25";
     Dexie.Cloud = dexieCloud;
 
     // In case the SW lives for a while, let it reuse already opened connections:
@@ -8294,8 +8501,8 @@
         }
         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);