dexie-cloud-addon 4.1.0-alpha.2 → 4.1.0-alpha.21

package/dist/umd/service-worker.js

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.1.0-alpha.2, Mon Oct 07 2024
+ * Version 4.1.0-alpha.21, Mon Nov 18 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,17 @@
     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;
             default:
                 writeAny(encoder, msg.k);
                 switch (msg.type) {
@@ -3107,6 +3111,9 @@
     function decodeYMessage(a) {
         const decoder = new Decoder(a);
         const type = readVarString(decoder);
+        if (type === 'outdated-server-rev') {
+            return { type };
+        }
         const table = readVarString(decoder);
         const prop = readVarString(decoder);
         switch (type) {
@@ -3519,8 +3526,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 +4357,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`);
@@ -4664,13 +4671,12 @@
      * @param db
      * @returns
      */
-    function listYClientMessagesAndStateVector(db) {
-        var _a;
+    function listYClientMessagesAndStateVector(db, tablesToSync) {
         return __awaiter(this, void 0, void 0, function* () {
             const result = [];
             const lastUpdateIds = {};
-            for (const table of db.tables) {
-                if (table.schema.yProps && ((_a = db.cloud.schema) === null || _a === void 0 ? void 0 : _a[table.name].markedForSync)) {
+            for (const table of tablesToSync) {
+                if (table.schema.yProps) {
                     for (const yProp of table.schema.yProps) {
                         const Y = $Y(db); // This is how we retrieve the user-provided Y library
                         const yTable = db.table(yProp.updatesTable); // the updates-table for this combo of table+propName
@@ -4757,12 +4763,14 @@
 
     function applyYServerMessages(yMessages, db) {
         return __awaiter(this, void 0, void 0, function* () {
-            const result = {};
+            var _a;
+            const receivedUntils = {};
+            let resyncNeeded = false;
             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,
                         });
@@ -4787,7 +4795,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': {
@@ -4797,22 +4822,28 @@
                         }
                         break;
                     }
+                    case 'outdated-server-rev':
+                        resyncNeeded = true;
+                        break;
                 }
             }
-            return result;
+            return {
+                receivedUntils,
+                resyncNeeded,
+            };
         });
     }
 
     function updateYSyncStates(lastUpdateIdsBeforeSync, receivedUntilsAfterSync, db, serverRevision) {
-        var _a, _b;
         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,
             //  we can safely store unsentFrom to a value of the last update + 1 here.
             // We also want to update receivedUntil for each yTable to the value specified in the second argument,
             //  because that contains the highest resulted id of each update from server after storing it.
-            // We could do these two tasks separately, but that would require two update calls on the same YSyncState, so 
+            // We could do these two tasks separately, but that would require two update calls on the same YSyncState, so
             // to optimize the dexie calls, we merge these two maps into a single one so we can do a single update request
             // per yTable.
             const mergedSpec = {};
@@ -4824,28 +4855,42 @@
                 (_b = mergedSpec[yTable]) !== null && _b !== void 0 ? _b : (mergedSpec[yTable] = {});
                 mergedSpec[yTable].receivedUntil = lastUpdateId;
             }
-            // Now go through the merged map and update YSyncStates accordingly:
-            for (const [yTable, { unsentFrom, receivedUntil }] of Object.entries(mergedSpec)) {
+            // Now go through all yTables and update their YSyncStates:
+            const allYTables = Object.values(db.dx._dbSchema)
+                .filter((tblSchema) => tblSchema.yProps)
+                .map((tblSchema) => tblSchema.yProps.map((yProp) => yProp.updatesTable))
+                .flat();
+            for (const yTable of allYTables) {
+                const mergedEntry = mergedSpec[yTable];
+                const unsentFrom = (_c = mergedEntry === null || mergedEntry === void 0 ? void 0 : mergedEntry.unsentFrom) !== null && _c !== void 0 ? _c : 1;
+                const receivedUntil = (_e = (_d = mergedEntry === null || mergedEntry === void 0 ? void 0 : mergedEntry.receivedUntil) !== null && _d !== void 0 ? _d : 
+                // from local because we are in the same parent transaction (in sync.ts) that
+                // applied all updates from the server
+                (yield db
+                    .table(yTable)
+                    .where('i')
+                    .between(1, Infinity) // Because i might be string DEXIE_CLOUD_SYNCER_ID if not a number.
+                    .reverse()
+                    .limit(1)
+                    .primaryKeys())[0]) !== null && _e !== void 0 ? _e : 0;
                 // We're already in a transaction, but for the sake of
                 // code readability and correctness, let's launch an atomic sub transaction:
                 yield db.transaction('rw', yTable, () => __awaiter(this, void 0, void 0, function* () {
-                    const state = yield db.table(yTable).get(DEXIE_CLOUD_SYNCER_ID);
+                    const state = yield db
+                        .table(yTable)
+                        .get(DEXIE_CLOUD_SYNCER_ID);
                     if (!state) {
                         yield db.table(yTable).add({
                             i: DEXIE_CLOUD_SYNCER_ID,
-                            unsentFrom: unsentFrom || 1,
-                            receivedUntil: receivedUntil || 0,
+                            unsentFrom,
+                            receivedUntil,
                             serverRev: serverRevision,
                         });
                     }
                     else {
-                        if (unsentFrom) {
-                            state.unsentFrom = Math.max(unsentFrom, state.unsentFrom || 1);
-                        }
-                        if (receivedUntil) {
-                            state.receivedUntil = Math.max(receivedUntil, state.receivedUntil || 0);
-                            state.serverRev = serverRevision;
-                        }
+                        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);
                     }
                 }));
@@ -4856,9 +4901,11 @@
     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* () {
-            if (yDownloadedRealms && realms && realms.every(realmId => yDownloadedRealms[realmId] === '*')) {
+    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] === '*')) {
                 return; // Already done!
             }
             console.debug('Downloading Y.Docs from added realms');
@@ -4898,16 +4945,19 @@
                                 yield yTable.bulkAdd(docsToInsert);
                                 docsToInsert = [];
                             }
-                            if (currentRealmId && currentTable && currentProp && (lastDoc || completedRealm)) {
-                                yield db.$syncState.update('syncState', completedRealm
-                                    ? '*'
-                                    : {
-                                        [`yDownloadedRealms.${currentRealmId}`]: {
+                            if (currentRealmId &&
+                                ((currentTable && currentProp && lastDoc) || completedRealm)) {
+                                yield db.$syncState.update('syncState', (syncState) => {
+                                    const yDownloadedRealms = syncState.yDownloadedRealms || {};
+                                    yDownloadedRealms[currentRealmId] = completedRealm
+                                        ? '*'
+                                        : {
                                             tbl: currentTable,
                                             prop: currentProp,
                                             key: lastDoc.k,
-                                        },
-                                    });
+                                        };
+                                    syncState.yDownloadedRealms = yDownloadedRealms;
+                                });
                             }
                         });
                     }
@@ -5010,11 +5060,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 });
             }
@@ -5056,8 +5106,8 @@
             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);
-                const yResults = yield listYClientMessagesAndStateVector(db);
+                let clientChanges = yield listClientChanges(mutationTables, db);
+                const yResults = yield listYClientMessagesAndStateVector(db, tablesToSync);
                 throwIfCancelled(cancelToken);
                 if (doSyncify) {
                     const alreadySyncedRealms = [
@@ -5187,11 +5237,14 @@
                     //
                     // apply yMessages
                     //
-                    const receivedUntils = yield applyYServerMessages(res.yMessages, db);
+                    const { receivedUntils, resyncNeeded } = yield applyYServerMessages(res.yMessages, db);
                     //
                     // update Y SyncStates
                     //
                     yield updateYSyncStates(lastUpdateIds, receivedUntils, db, res.serverRevision);
+                    if (resyncNeeded) {
+                        newSyncState.yDownloadedRealms = {}; // Will trigger a full download of Y-documents below...
+                    }
                 }
                 //
                 // Update regular syncState
@@ -5325,8 +5378,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 {
@@ -5641,8 +5694,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
@@ -5680,11 +5733,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') {
@@ -5850,8 +5903,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))) {
@@ -6288,8 +6341,7 @@
                                 outstandingTransactions.next(outstandingTransactions.value);
                             };
                             const txComplete = () => {
-                                if (tx.mutationsAdded &&
-                                    !isEagerSyncDisabled(db)) {
+                                if (tx.mutationsAdded && !isEagerSyncDisabled(db)) {
                                     triggerSync(db, 'push');
                                 }
                                 removeTransaction();
@@ -6371,26 +6423,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',
@@ -6411,7 +6544,7 @@
                                             userId,
                                             values,
                                         }
-                                        : criteria && req.changeSpec
+                                        : criteria && changeSpec
                                             ? {
                                                 // Common changeSpec for all keys
                                                 type: 'modify',
@@ -6419,37 +6552,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;
                             });
                         }
@@ -6616,38 +6763,51 @@
 
     function createYClientUpdateObservable(db) {
         const yTableRecords = flatten(db.tables
-            .filter((table) => { var _a; return ((_a = db.cloud.schema) === null || _a === void 0 ? void 0 : _a[table.name].markedForSync) && table.schema.yProps; })
+            .filter((table) => { var _a, _b; return ((_b = (_a = db.cloud.schema) === null || _a === void 0 ? void 0 : _a[table.name]) === null || _b === void 0 ? void 0 : _b.markedForSync) && table.schema.yProps; })
             .map((table) => table.schema.yProps.map((p) => ({
             table: table.name,
             ydocProp: p.prop,
             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(rxjs.mergeMap((messages) => messages)); // Flattens 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.
+        })).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);
+        }));
     }
 
     function getAwarenessLibrary(db) {
@@ -6664,25 +6824,24 @@
     const CLIENT_PING_INTERVAL = 30000;
     const FAIL_RETRY_WAIT_TIME = 60000;
     class WSObservable extends rxjs.Observable {
-        constructor(db, rev, realmSetHash, clientIdentity, messageProducer, webSocketStatus, token, tokenExpiration) {
-            super((subscriber) => new WSConnection(db, rev, realmSetHash, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus));
+        constructor(db, rev, realmSetHash, clientIdentity, messageProducer, webSocketStatus, user) {
+            super((subscriber) => new WSConnection(db, rev, realmSetHash, clientIdentity, user, subscriber, messageProducer, webSocketStatus));
         }
     }
     let counter = 0;
     class WSConnection extends rxjs.Subscription {
-        constructor(db, rev, realmSetHash, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus) {
+        constructor(db, rev, realmSetHash, clientIdentity, user, subscriber, messageProducer, webSocketStatus) {
             super(() => this.teardown());
             this.id = ++counter;
             this.subscriptions = new Set();
             this.reconnecting = false;
-            console.debug('New WebSocket Connection', this.id, token ? 'authorized' : 'unauthorized');
+            console.debug('New WebSocket Connection', this.id, user.accessToken ? 'authorized' : 'unauthorized');
             this.db = db;
             this.databaseUrl = db.cloud.options.databaseUrl;
             this.rev = rev;
             this.realmSetHash = realmSetHash;
             this.clientIdentity = clientIdentity;
-            this.token = token;
-            this.tokenExpiration = tokenExpiration;
+            this.user = user;
             this.subscriber = subscriber;
             this.lastUserActivity = new Date();
             this.messageProducer = messageProducer;
@@ -6742,7 +6901,8 @@
                     //console.debug('SyncStatus: DUBB: Ooops it was closed!');
                     return;
                 }
-                if (this.tokenExpiration && this.tokenExpiration < new Date()) {
+                const tokenExpiration = this.user.accessTokenExpiration;
+                if (tokenExpiration && tokenExpiration < new Date()) {
                     this.subscriber.error(new TokenExpiredError()); // Will be handled in connectWebSocket.ts.
                     return;
                 }
@@ -6797,8 +6957,8 @@
                 searchParams.set('rev', this.rev);
                 searchParams.set('realmsHash', this.realmSetHash);
                 searchParams.set('clientId', this.clientIdentity);
-                if (this.token) {
-                    searchParams.set('token', this.token);
+                if (this.user.accessToken) {
+                    searchParams.set('token', this.user.accessToken);
                 }
                 // Connect the WebSocket to given url:
                 console.debug('dexie-cloud WebSocket create');
@@ -6813,12 +6973,12 @@
                 ws.onmessage = (event) => {
                     if (!this.pinger)
                         return;
-                    console.debug('dexie-cloud WebSocket onmessage', event.data);
                     this.lastServerActivity = new Date();
                     try {
                         const msg = typeof event.data === 'string'
                             ? TSON.parse(event.data)
                             : decodeYMessage(new Uint8Array(event.data));
+                        console.debug('dexie-cloud WebSocket onmessage', msg.type, msg);
                         if (msg.type === 'error') {
                             throw new Error(`Error message from dexie-cloud: ${msg.error}`);
                         }
@@ -6839,6 +6999,10 @@
                         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 === 'outdated-server-rev') {
+                            // Won't happen but need this for typing.
+                            throw new Error('Outdated server revision not expected over WebSocket - only in sync using fetch()');
+                        }
                         else if (msg.type !== 'pong') {
                             this.subscriber.next(msg);
                         }
@@ -6874,17 +7038,27 @@
                                 this.webSocketStatus.value !== 'connected') {
                                 this.webSocketStatus.next('connected');
                             }
+                            console.debug('dexie-cloud WebSocket send', msg.type, msg);
                             if (msg.type === 'ready') {
                                 (_a = this.ws) === null || _a === void 0 ? void 0 : _a.send(TSON.stringify(msg));
                             }
                             else {
                                 // If it's not a "ready" message, it's an YMessage.
                                 // YMessages can be sent binary encoded.
+                                if (msg.type === 'u-c') {
+                                    console.log("u-c:B", ++gotClientUpdateB);
+                                }
                                 (_b = this.ws) === null || _b === void 0 ? void 0 : _b.send(encodeYMessage(msg));
                             }
                         }
                     }));
-                    this.subscriptions.add(createYClientUpdateObservable(this.db).subscribe(this.db.messageProducer));
+                    if (this.user.isLoggedIn && !isEagerSyncDisabled(this.db)) {
+                        this.subscriptions.add(createYClientUpdateObservable(this.db).pipe(rxjs.tap((msg) => {
+                            if (msg.type === 'u-c') {
+                                console.log("u-c:A", ++gotClientUpdateA, msg.i);
+                            }
+                        })).subscribe(this.db.messageProducer));
+                    }
                 }
                 catch (error) {
                     this.pauseUntil = new Date(Date.now() + FAIL_RETRY_WAIT_TIME);
@@ -6892,6 +7066,8 @@
             });
         }
     }
+    let gotClientUpdateA = 0;
+    let gotClientUpdateB = 0;
 
     class InvalidLicenseError extends Error {
         constructor(license) {
@@ -6954,7 +7130,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.
@@ -6964,7 +7140,7 @@
                 // If no new entries, server won't bother the client. If new entries, server sends only those
                 // and the baseRev of the last from same client-ID.
                 if (userLogin) {
-                    return new WSObservable(db, db.cloud.persistedSyncState.value.serverRevision, realmSetHash, db.cloud.persistedSyncState.value.clientIdentity, messageProducer, db.cloud.webSocketStatus, userLogin.accessToken, userLogin.accessTokenExpiration);
+                    return new WSObservable(db, db.cloud.persistedSyncState.value.serverRevision, realmSetHash, db.cloud.persistedSyncState.value.clientIdentity, messageProducer, db.cloud.webSocketStatus, userLogin);
                 }
                 else {
                     return rxjs.from([]);
@@ -7015,8 +7191,8 @@
     }
 
     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;
@@ -7700,6 +7876,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];
@@ -7771,125 +7948,139 @@
     });
 
     function createYHandler(db) {
-        const awap = getAwarenessLibrary(db);
         return (provider) => {
             var _a;
             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);
-                if (origin !== 'server') {
-                    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);
+        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,
+                        k: doc.meta.parentId
                     });
-                    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 = db.cloud.webSocketStatus.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 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;
-                    // 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.
-                    if (wsStatus === "connected") {
-                        ++currentFlowId;
-                        openDocumentOnServer().catch(error => {
-                            console.warn(`Error catched in createYHandler.ts: ${error}`);
-                        });
+                    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);
                 });
-                // 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 = {
@@ -7932,7 +8123,7 @@
         const syncComplete = new rxjs.Subject();
         dexie.cloud = {
             // @ts-ignore
-            version: "4.1.0-alpha.2",
+            version: "4.1.0-alpha.21",
             options: Object.assign({}, DEFAULT_OPTIONS),
             schema: null,
             get currentUserId() {
@@ -7968,16 +8159,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);
@@ -8035,8 +8226,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:
@@ -8059,7 +8250,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(),
@@ -8081,7 +8272,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) {
@@ -8095,7 +8286,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.'
@@ -8234,7 +8425,7 @@
         }
     }
     // @ts-ignore
-    dexieCloud.version = "4.1.0-alpha.2";
+    dexieCloud.version = "4.1.0-alpha.21";
     Dexie.Cloud = dexieCloud;
 
     // In case the SW lives for a while, let it reuse already opened connections:
@@ -8264,8 +8455,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);