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

package/dist/modern/service-worker.js

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.1.0-alpha.2, Mon Oct 07 2024
+ * Version 4.1.0-alpha.20, Wed Oct 23 2024
  *
  * https://dexie.org
  *
@@ -16,8 +16,8 @@
  * 
  */
 
-import Dexie, { PropModification, cmp, DexieYProvider, liveQuery } from 'dexie';
-import { Observable as Observable$1, BehaviorSubject, firstValueFrom, Subject, from as from$1, filter as filter$1, fromEvent, of, merge, mergeMap as mergeMap$1, Subscription as Subscription$1, throwError, combineLatest, map as map$1, share, timer as timer$1 } from 'rxjs';
+import Dexie, { PropModification, cmp, DexieYProvider, RangeSet, liveQuery } from 'dexie';
+import { Observable as Observable$1, BehaviorSubject, firstValueFrom, Subject, from as from$1, filter as filter$1, fromEvent, of, merge, switchMap as switchMap$1, tap as tap$1, mergeMap as mergeMap$1, Subscription as Subscription$1, throwError, combineLatest, map as map$1, share, timer as timer$1 } from 'rxjs';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -1765,8 +1765,8 @@ function registerSyncEvent(db, purpose) {
     });
 }
 function registerPeriodicSyncEvent(db) {
-    var _a;
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         try {
             // Register periodicSync event to SW:
             // @ts-ignore
@@ -1831,8 +1831,8 @@ const b64encode = typeof Buffer !== "undefined"
         return btoa(strs.join(""));
     };
 
-function computeRealmSetHash({ realms, inviteRealms, }) {
-    return __awaiter(this, void 0, void 0, function* () {
+function computeRealmSetHash(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ realms, inviteRealms, }) {
         const data = JSON.stringify([
             ...realms.map((realmId) => ({ realmId, accepted: true })),
             ...inviteRealms.map((realmId) => ({ realmId, accepted: false })),
@@ -1868,8 +1868,8 @@ function flatten(a) {
     return concat.apply([], a);
 }
 
-function listClientChanges(mutationTables, db, { since = {}, limit = Infinity } = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
+function listClientChanges(mutationTables_1, db_1) {
+    return __awaiter(this, arguments, void 0, function* (mutationTables, db, { since = {}, limit = Infinity } = {}) {
         const allMutsOnTables = yield Promise.all(mutationTables.map((mutationTable) => __awaiter(this, void 0, void 0, function* () {
             const tableName = getTableFromMutationTable(mutationTable.name);
             const lastRevision = since[tableName];
@@ -3516,8 +3516,8 @@ function confirmLogout(userInteraction, currentUserId, numUnsyncedChanges) {
 }
 
 function loadAccessToken(db) {
-    var _a, _b, _c;
     return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
         const currentUser = yield db.getCurrentUser();
         const { accessToken, accessTokenExpiration, refreshToken, refreshTokenExpiration, claims, } = currentUser;
         if (!accessToken)
@@ -4347,8 +4347,8 @@ function cloneChange(change, rewriteValues) {
 // seconds (given that there is a Ratelimit-Reset header).
 let syncRatelimitDelays = new WeakMap();
 function checkSyncRateLimitDelay(db) {
-    var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
         const delatMilliseconds = ((_b = (_a = syncRatelimitDelays.get(db)) === null || _a === void 0 ? void 0 : _a.getTime()) !== null && _b !== void 0 ? _b : 0) - Date.now();
         if (delatMilliseconds > 0) {
             console.debug(`Stalling sync request ${delatMilliseconds} ms to spare ratelimits`);
@@ -4661,13 +4661,12 @@ function $Y(db) {
  * @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
@@ -4754,6 +4753,7 @@ function getUpdatesTable(db, table, ydocProp) {
 
 function applyYServerMessages(yMessages, db) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         const result = {};
         for (const m of yMessages) {
             switch (m.type) {
@@ -4784,7 +4784,24 @@ function applyYServerMessages(yMessages, db) {
                     // See my question in https://discuss.yjs.dev/t/generate-an-inverse-update/2765
                     console.debug(`Y update rejected. Deleting it.`);
                     const utbl = getUpdatesTable(db, m.table, m.prop);
-                    yield utbl.delete(m.i);
+                    // Delete the rejected update and all local updates since (avoid holes in the CRDT)
+                    // and destroy it's open document if there is one.
+                    const primaryKey = (_a = (yield utbl.get(m.i))) === null || _a === void 0 ? void 0 : _a.k;
+                    if (primaryKey != null) {
+                        yield db.transaction('rw', utbl, tx => {
+                            // @ts-ignore
+                            tx.idbtrans._rejecting_y_ypdate = true; // Inform ydoc triggers that we delete because of a rejection and not GC
+                            return utbl
+                                .where('i')
+                                .aboveOrEqual(m.i)
+                                .filter(u => cmp(u.k, primaryKey) === 0 && ((u.f || 0) & 1) === 1)
+                                .delete();
+                        });
+                        // Destroy active doc
+                        const activeDoc = DexieYProvider.getDocCache(db.dx).find(m.table, primaryKey, m.prop);
+                        if (activeDoc)
+                            activeDoc.destroy(); // Destroy the document so that editors don't continue to work on it
+                    }
                     break;
                 }
                 case 'in-sync': {
@@ -4801,15 +4818,15 @@ function applyYServerMessages(yMessages, db) {
 }
 
 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 = {};
@@ -4821,28 +4838,42 @@ function updateYSyncStates(lastUpdateIdsBeforeSync, receivedUntilsAfterSync, db,
             (_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);
                 }
             }));
@@ -4853,9 +4884,11 @@ function updateYSyncStates(lastUpdateIdsBeforeSync, receivedUntilsAfterSync, db,
 const BINSTREAM_TYPE_REALMID = 1;
 const BINSTREAM_TYPE_TABLE_AND_PROP = 2;
 const BINSTREAM_TYPE_DOCUMENT = 3;
-function downloadYDocsFromServer(db, databaseUrl, { yDownloadedRealms, realms }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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');
@@ -4895,16 +4928,19 @@ function downloadYDocsFromServer(db, databaseUrl, { yDownloadedRealms, realms })
                             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;
+                            });
                         }
                     });
                 }
@@ -5007,11 +5043,11 @@ function sync(db, options, schema, syncOptions) {
         return Promise.reject(error);
     }));
 }
-function _sync(db, options, schema, { isInitialSync, cancelToken, justCheckIfNeeded, purpose } = {
-    isInitialSync: false,
-}) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function* () {
+function _sync(db_1, options_1, schema_1) {
+    return __awaiter(this, arguments, void 0, function* (db, options, schema, { isInitialSync, cancelToken, justCheckIfNeeded, purpose } = {
+        isInitialSync: false,
+    }) {
+        var _a;
         if (!justCheckIfNeeded) {
             console.debug('SYNC STARTED', { isInitialSync, purpose });
         }
@@ -5053,8 +5089,8 @@ function _sync(db, options, schema, { isInitialSync, cancelToken, justCheckIfNee
         const [clientChangeSet, syncState, baseRevs, { yMessages, lastUpdateIds }] = yield db.transaction('r', db.tables, () => __awaiter(this, void 0, void 0, function* () {
             const syncState = yield db.getPersistedSyncState();
             const baseRevs = yield db.$baseRevs.toArray();
-            let clientChanges = yield listClientChanges(mutationTables);
-            const yResults = yield listYClientMessagesAndStateVector(db);
+            let clientChanges = yield listClientChanges(mutationTables, db);
+            const yResults = yield listYClientMessagesAndStateVector(db, tablesToSync);
             throwIfCancelled(cancelToken);
             if (doSyncify) {
                 const alreadySyncedRealms = [
@@ -5322,8 +5358,8 @@ function MessagesFromServerConsumer(db) {
         event.next(null);
     }
     function consumeQueue() {
-        var _a, _b, _c, _d, _e, _f;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
             while (queue.length > 0) {
                 const msg = queue.shift();
                 try {
@@ -5638,8 +5674,8 @@ function logout(db) {
         }
     });
 }
-function _logout(db, { deleteUnsyncedData = false } = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
+function _logout(db_1) {
+    return __awaiter(this, arguments, void 0, function* (db, { deleteUnsyncedData = false } = {}) {
         // Clear the database without emptying configuration options.
         const [numUnsynced, loggedOut] = yield db.dx.transaction('rw', db.dx.tables, (tx) => __awaiter(this, void 0, void 0, function* () {
             // @ts-ignore
@@ -5677,11 +5713,11 @@ function _logout(db, { deleteUnsyncedData = false } = {}) {
 
 function otpFetchTokenCallback(db) {
     const { userInteraction } = db.cloud;
-    return function otpAuthenticate({ public_key, hints }) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
+    return function otpAuthenticate(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ public_key, hints }) {
+            var _b;
             let tokenRequest;
-            const url = (_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.databaseUrl;
+            const url = (_b = db.cloud.options) === null || _b === void 0 ? void 0 : _b.databaseUrl;
             if (!url)
                 throw new Error(`No database URL given.`);
             if ((hints === null || hints === void 0 ? void 0 : hints.grant_type) === 'demo') {
@@ -5847,8 +5883,8 @@ function setCurrentUser(db, user) {
 }
 
 function login(db, hints) {
-    var _a;
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         const currentUser = yield db.getCurrentUser();
         const origUserId = currentUser.userId;
         if (currentUser.isLoggedIn && (!hints || (!hints.email && !hints.userId))) {
@@ -6285,8 +6321,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                             outstandingTransactions.next(outstandingTransactions.value);
                         };
                         const txComplete = () => {
-                            if (tx.mutationsAdded &&
-                                !isEagerSyncDisabled(db)) {
+                            if (tx.mutationsAdded && !isEagerSyncDisabled(db)) {
                                 triggerSync(db, 'push');
                             }
                             removeTransaction();
@@ -6368,26 +6403,107 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                                 : mutateAndLog(req);
                         } }));
                     function mutateAndLog(req) {
+                        var _a, _b;
                         const trans = req.trans;
-                        trans.mutationsAdded = true;
+                        const unsyncedProps = (_b = (_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.unsyncedProperties) === null || _b === void 0 ? void 0 : _b[tableName];
                         const { txid, currentUser: { userId }, } = trans;
                         const { type } = req;
                         const opNo = ++trans.opCount;
+                        function stripChangeSpec(changeSpec) {
+                            if (!unsyncedProps)
+                                return changeSpec;
+                            let rv = changeSpec;
+                            for (const keyPath of Object.keys(changeSpec)) {
+                                if (unsyncedProps.some((p) => keyPath === p || keyPath.startsWith(p + '.'))) {
+                                    if (rv === changeSpec)
+                                        rv = Object.assign({}, changeSpec); // clone on demand
+                                    delete rv[keyPath];
+                                }
+                            }
+                            return rv;
+                        }
                         return table.mutate(req).then((res) => {
+                            var _a;
                             const { numFailures: hasFailures, failures } = res;
                             let keys = type === 'delete' ? req.keys : res.results;
                             let values = 'values' in req ? req.values : [];
-                            let updates = 'updates' in req && req.updates;
+                            let changeSpec = 'changeSpec' in req ? req.changeSpec : undefined;
+                            let updates = 'updates' in req ? req.updates : undefined;
                             if (hasFailures) {
                                 keys = keys.filter((_, idx) => !failures[idx]);
                                 values = values.filter((_, idx) => !failures[idx]);
                             }
+                            if (unsyncedProps) {
+                                // Filter out unsynced properties
+                                values = values.map((value) => {
+                                    const newValue = Object.assign({}, value);
+                                    for (const prop of unsyncedProps) {
+                                        delete newValue[prop];
+                                    }
+                                    return newValue;
+                                });
+                                if (changeSpec) {
+                                    // modify operation with criteria and changeSpec.
+                                    // We must strip out unsynced properties from changeSpec.
+                                    // We deal with criteria later.
+                                    changeSpec = stripChangeSpec(changeSpec);
+                                    if (Object.keys(changeSpec).length === 0) {
+                                        // Nothing to change on server
+                                        return res;
+                                    }
+                                }
+                                if (updates) {
+                                    let strippedChangeSpecs = updates.changeSpecs.map(stripChangeSpec);
+                                    let newUpdates = {
+                                        keys: [],
+                                        changeSpecs: [],
+                                    };
+                                    const validKeys = new RangeSet();
+                                    let anyChangeSpecBecameEmpty = false;
+                                    for (let i = 0, l = strippedChangeSpecs.length; i < l; ++i) {
+                                        if (Object.keys(strippedChangeSpecs[i]).length > 0) {
+                                            newUpdates.keys.push(updates.keys[i]);
+                                            newUpdates.changeSpecs.push(strippedChangeSpecs[i]);
+                                            validKeys.addKey(updates.keys[i]);
+                                        }
+                                        else {
+                                            anyChangeSpecBecameEmpty = true;
+                                        }
+                                    }
+                                    updates = newUpdates;
+                                    if (anyChangeSpecBecameEmpty) {
+                                        // Some keys were stripped. We must also strip them from keys and values
+                                        let newKeys = [];
+                                        let newValues = [];
+                                        for (let i = 0, l = keys.length; i < l; ++i) {
+                                            if (validKeys.hasKey(keys[i])) {
+                                                newKeys.push(keys[i]);
+                                                newValues.push(values[i]);
+                                            }
+                                        }
+                                        keys = newKeys;
+                                        values = newValues;
+                                    }
+                                }
+                            }
                             const ts = Date.now();
                             // Canonicalize req.criteria.index to null if it's on the primary key.
-                            const criteria = 'criteria' in req && req.criteria
+                            let criteria = 'criteria' in req && req.criteria
                                 ? Object.assign(Object.assign({}, req.criteria), { index: req.criteria.index === schema.primaryKey.keyPath // Use null to inform server that criteria is on primary key
                                         ? null // This will disable the server from trying to log consistent operations where it shouldnt.
                                         : req.criteria.index }) : undefined;
+                            if (unsyncedProps && (criteria === null || criteria === void 0 ? void 0 : criteria.index)) {
+                                const keyPaths = (_a = schema.indexes.find((idx) => idx.name === criteria.index)) === null || _a === void 0 ? void 0 : _a.keyPath;
+                                const involvedProps = keyPaths
+                                    ? typeof keyPaths === 'string'
+                                        ? [keyPaths]
+                                        : keyPaths
+                                    : [];
+                                if (involvedProps.some((p) => unsyncedProps === null || unsyncedProps === void 0 ? void 0 : unsyncedProps.includes(p))) {
+                                    // Don't log criteria on unsynced properties as the server could not test them.
+                                    criteria = undefined;
+                                }
+                            }
                             const mut = req.type === 'delete'
                                 ? {
                                     type: 'delete',
@@ -6408,7 +6524,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                                         userId,
                                         values,
                                     }
-                                    : criteria && req.changeSpec
+                                    : criteria && changeSpec
                                         ? {
                                             // Common changeSpec for all keys
                                             type: 'modify',
@@ -6416,37 +6532,51 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                                             opNo,
                                             keys,
                                             criteria,
-                                            changeSpec: req.changeSpec,
+                                            changeSpec,
                                             txid,
                                             userId,
                                         }
-                                        : updates
+                                        : changeSpec
                                             ? {
-                                                // One changeSpec per key
+                                                // In case criteria involved an unsynced property, we go for keys instead.
                                                 type: 'update',
                                                 ts,
                                                 opNo,
-                                                keys: updates.keys,
-                                                changeSpecs: updates.changeSpecs,
-                                                txid,
-                                                userId,
-                                            }
-                                            : {
-                                                type: 'upsert',
-                                                ts,
-                                                opNo,
                                                 keys,
-                                                values,
+                                                changeSpecs: keys.map(() => changeSpec),
                                                 txid,
                                                 userId,
-                                            };
+                                            }
+                                            : updates
+                                                ? {
+                                                    // One changeSpec per key
+                                                    type: 'update',
+                                                    ts,
+                                                    opNo,
+                                                    keys: updates.keys,
+                                                    changeSpecs: updates.changeSpecs,
+                                                    txid,
+                                                    userId,
+                                                }
+                                                : {
+                                                    type: 'upsert',
+                                                    ts,
+                                                    opNo,
+                                                    keys,
+                                                    values,
+                                                    txid,
+                                                    userId,
+                                                };
                             if ('isAdditionalChunk' in req && req.isAdditionalChunk) {
                                 mut.isAdditionalChunk = true;
                             }
                             return keys.length > 0 || criteria
                                 ? mutsTable
                                     .mutate({ type: 'add', trans, values: [mut] }) // Log entry
-                                    .then(() => res) // Return original response
+                                    .then(() => {
+                                    trans.mutationsAdded = true; // Mark transaction as having added mutations to trigger eager sync
+                                    return res; // Return original response
+                                })
                                 : res;
                         });
                     }
@@ -6613,38 +6743,51 @@ class TokenExpiredError extends Error {
 
 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 merge(...yTableRecords.map(({ table, ydocProp, updatesTable }) => {
-        let currentUnsentFrom = 1;
-        return liveQuery(() => __awaiter(this, void 0, void 0, function* () {
-            const yTbl = db.table(updatesTable);
-            const unsentFrom = yield yTbl
-                .where({ i: DEXIE_CLOUD_SYNCER_ID })
-                .first()
-                .then((syncer) => (syncer === null || syncer === void 0 ? void 0 : syncer.unsentFrom) || 1);
-            currentUnsentFrom = Math.max(currentUnsentFrom, unsentFrom);
-            const addedUpdates = yield listUpdatesSince(yTbl, currentUnsentFrom);
-            // Update currentUnsentFrom to only listen for updates that will be newer than the ones we emitted.
-            currentUnsentFrom = Math.max(currentUnsentFrom, ...addedUpdates.map((update) => update.i + 1));
-            return addedUpdates
-                .filter((update) => update.f && update.f & 1) // Only include local updates
-                .map((update) => {
-                return {
-                    type: 'u-c',
-                    table,
-                    prop: ydocProp,
-                    k: update.k,
-                    u: update.u,
-                    i: update.i,
-                };
-            });
+        // Per updates table (table+prop combo), we first read syncer.unsentFrom,
+        // and then start listening for updates since that number.
+        const yTbl = db.table(updatesTable);
+        return from$1(yTbl.get(DEXIE_CLOUD_SYNCER_ID)).pipe(switchMap$1((syncer) => {
+            let currentUnsentFrom = (syncer === null || syncer === void 0 ? void 0 : syncer.unsentFrom) || 1;
+            return from$1(liveQuery(() => __awaiter(this, void 0, void 0, function* () {
+                const addedUpdates = yield listUpdatesSince(yTbl, currentUnsentFrom);
+                return addedUpdates
+                    .filter((update) => update.f && update.f & 1) // Only include local updates
+                    .map((update) => {
+                    return {
+                        type: 'u-c',
+                        table,
+                        prop: ydocProp,
+                        k: update.k,
+                        u: update.u,
+                        i: update.i,
+                    };
+                });
+            }))).pipe(tap$1((addedUpdates) => {
+                // Update currentUnsentFrom to only listen for updates that will be newer than the ones we emitted.
+                // (Before, we did this within the liveQuery, but that caused a bug because
+                // a cancelled emittion of a liveQuery would update the currentUnsentFrom without
+                // emitting anything, leading to that we jumped over some updates. Here we update it
+                // after the liveQuery has emitted its updates)
+                if (addedUpdates.length > 0) {
+                    currentUnsentFrom = addedUpdates.at(-1).i + 1;
+                }
+            }));
         }));
-    })).pipe(mergeMap$1((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.
+    mergeMap$1((messages) => messages), tap$1((message) => {
+        console.debug('dexie-cloud emitting y-c', message);
+    }));
 }
 
 function getAwarenessLibrary(db) {
@@ -6661,25 +6804,24 @@ const SERVER_PING_TIMEOUT = 20000;
 const CLIENT_PING_INTERVAL = 30000;
 const FAIL_RETRY_WAIT_TIME = 60000;
 class WSObservable extends Observable$1 {
-    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 Subscription$1 {
-    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;
@@ -6739,7 +6881,8 @@ class WSConnection extends Subscription$1 {
                 //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;
             }
@@ -6794,8 +6937,8 @@ class WSConnection extends Subscription$1 {
             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');
@@ -6810,12 +6953,12 @@ class WSConnection extends Subscription$1 {
             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}`);
                     }
@@ -6871,6 +7014,7 @@ class WSConnection extends Subscription$1 {
                             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));
                         }
@@ -6881,7 +7025,9 @@ class WSConnection extends Subscription$1 {
                         }
                     }
                 }));
-                this.subscriptions.add(createYClientUpdateObservable(this.db).subscribe(this.db.messageProducer));
+                if (this.user.isLoggedIn && !isEagerSyncDisabled(this.db)) {
+                    this.subscriptions.add(createYClientUpdateObservable(this.db).subscribe(this.db.messageProducer));
+                }
             }
             catch (error) {
                 this.pauseUntil = new Date(Date.now() + FAIL_RETRY_WAIT_TIME);
@@ -6951,7 +7097,7 @@ function connectWebSocket(db) {
                 return db.cloud.persistedSyncState.pipe(filter((syncState) => (syncState === null || syncState === void 0 ? void 0 : syncState.realms.includes(userLogin.userId)) || false), take(1), map((syncState) => [userLogin, syncState]));
             }
             return new BehaviorSubject([userLogin, syncState]);
-        }), switchMap(([userLogin, syncState]) => __awaiter(this, void 0, void 0, function* () { return [userLogin, yield computeRealmSetHash(syncState)]; })), distinctUntilChanged(([prevUser, prevHash], [currUser, currHash]) => prevUser === currUser && prevHash === currHash), switchMap(([userLogin, realmSetHash]) => {
+        }), switchMap((_a) => __awaiter(this, [_a], void 0, function* ([userLogin, syncState]) { return [userLogin, yield computeRealmSetHash(syncState)]; })), distinctUntilChanged(([prevUser, prevHash], [currUser, currHash]) => prevUser === currUser && prevHash === currHash), switchMap(([userLogin, realmSetHash]) => {
             var _a;
             if (!((_a = db.cloud.persistedSyncState) === null || _a === void 0 ? void 0 : _a.value)) {
                 // Restart the flow if persistedSyncState is not yet available.
@@ -6961,7 +7107,7 @@ function connectWebSocket(db) {
             // 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 from$1([]);
@@ -7012,8 +7158,8 @@ function connectWebSocket(db) {
 }
 
 function isSyncNeeded(db) {
-    var _a;
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         return ((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.databaseUrl) && db.cloud.schema
             ? yield sync(db, db.cloud.options, db.cloud.schema, { justCheckIfNeeded: true })
             : false;
@@ -7697,6 +7843,7 @@ class PermissionChecker {
         // If user can update any prop in any table in this realm, return true unless
         // it regards to ownership change:
         if (this.permissions.update === '*') {
+            // @ts-ignore
             return props.every((prop) => prop !== 'owner');
         }
         const tablePermissions = (_b = this.permissions.update) === null || _b === void 0 ? void 0 : _b[this.tableName];
@@ -7768,125 +7915,139 @@ const getInvitesObservable = associate((db) => {
 });
 
 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) => cmp(update.k, parentId) === 0 && // Only updates for this document
+                    ((update.f || 0) & 1) === 0 // Don't include local changes
+                )
+                    .toArray();
+                // After every await, check if we still should be working on this task.
+                if (provider.destroyed || currentFlowId !== myFlow || !connected)
+                    return;
+                if (serverUpdatesSinceLastSync.length > 0) {
+                    const Y = $Y(db); // Get the Yjs library from Dexie constructor options
+                    const mergedUpdate = Y.mergeUpdatesV2(serverUpdatesSinceLastSync.map((update) => update.u));
+                    const stateVector = Y.encodeStateVectorFromUpdateV2(mergedUpdate);
+                    docOpenMsg.sv = stateVector;
                 }
+                db.messageProducer.next(docOpenMsg);
             });
-            // Wait until WebSocket is connected
-            provider.addCleanupHandler(subscription);
-            /** Sends an 'doc-open' message to server whenever websocket becomes
-             * connected, or if it is already connected.
-             * The flow is aborted in case websocket is disconnected while querying
-             * information required to compute the state vector. Flow is also
-             * aborted in case document or provider has been destroyed during
-             * the async parts of the task.
-             *
-             * The state vector is only computed from the updates that have occured
-             * after the last full sync - which could very often be zero - in which
-             * case no state vector is sent (then the server already knows us by
-             * revision)
-             *
-             * When server gets the doc-open message, it will authorized us for
-             * whether we are allowed to read / write to this document, and then
-             * keep the cached information in memory on the WS connection for this
-             * particular document, as well as subscribe to updates and awareness updates
-             * from other clients on the document.
-             */
-            function openDocumentOnServer(wsStatus) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    const myFlow = currentFlowId; // So we can abort when a new flow is started
-                    const yTbl = db.table(updatesTable);
-                    const syncState = yield yTbl.get(DEXIE_CLOUD_SYNCER_ID);
-                    // After every await, check if we still should be working on this task.
-                    if (provider.destroyed || currentFlowId !== myFlow || !connected)
-                        return;
-                    const receivedUntil = (syncState === null || syncState === void 0 ? void 0 : syncState.receivedUntil) || 0;
-                    const docOpenMsg = {
-                        type: 'doc-open',
-                        table: parentTable,
-                        prop: parentProp,
-                        k: parentId,
-                        serverRev: syncState === null || syncState === void 0 ? void 0 : syncState.serverRev,
-                    };
-                    const serverUpdatesSinceLastSync = yield yTbl
-                        .where('i')
-                        .between(receivedUntil, Infinity, false)
-                        .filter((update) => cmp(update.k, parentId) === 0 && // Only updates for this document
-                        ((update.f || 0) & 1) === 0 // Don't include local changes
-                    )
-                        .toArray();
-                    // After every await, check if we still should be working on this task.
-                    if (provider.destroyed || currentFlowId !== myFlow || !connected)
-                        return;
-                    if (serverUpdatesSinceLastSync.length > 0) {
-                        const Y = $Y(db); // Get the Yjs library from Dexie constructor options
-                        const mergedUpdate = Y.mergeUpdatesV2(serverUpdatesSinceLastSync.map((update) => update.u));
-                        const stateVector = Y.encodeStateVectorFromUpdateV2(mergedUpdate);
-                        docOpenMsg.sv = stateVector;
-                    }
-                    db.messageProducer.next(docOpenMsg);
-                });
-            }
-        }));
-    };
+        }
+    }))();
+    return awareness;
 }
 
 const DEFAULT_OPTIONS = {
@@ -7929,7 +8090,7 @@ function dexieCloud(dexie) {
     const syncComplete = new Subject();
     dexie.cloud = {
         // @ts-ignore
-        version: "4.1.0-alpha.2",
+        version: "4.1.0-alpha.20",
         options: Object.assign({}, DEFAULT_OPTIONS),
         schema: null,
         get currentUserId() {
@@ -7965,16 +8126,16 @@ function dexieCloud(dexie) {
             }
             updateSchemaFromOptions(dexie.cloud.schema, dexie.cloud.options);
         },
-        logout({ force } = {}) {
-            return __awaiter(this, void 0, void 0, function* () {
+        logout() {
+            return __awaiter(this, arguments, void 0, function* ({ force } = {}) {
                 force
                     ? yield _logout(DexieCloudDB(dexie), { deleteUnsyncedData: true })
                     : yield logout(DexieCloudDB(dexie));
             });
         },
-        sync({ wait, purpose } = { wait: true, purpose: 'push' }) {
-            var _a;
-            return __awaiter(this, void 0, void 0, function* () {
+        sync() {
+            return __awaiter(this, arguments, void 0, function* ({ wait, purpose } = { wait: true, purpose: 'push' }) {
+                var _a;
                 if (wait === undefined)
                     wait = true;
                 const db = DexieCloudDB(dexie);
@@ -8032,8 +8193,8 @@ function dexieCloud(dexie) {
     dexie.use(createImplicitPropSetterMiddleware(DexieCloudDB(dexie)));
     dexie.use(createIdGenerationMiddleware(DexieCloudDB(dexie)));
     function onDbReady(dexie) {
-        var _a, _b, _c, _d, _e, _f, _g;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g;
             closed = false; // As Dexie calls us, we are not closed anymore. Maybe reopened? Remember db.ready event is registered with sticky flag!
             const db = DexieCloudDB(dexie);
             // Setup default GUI:
@@ -8056,7 +8217,7 @@ function dexieCloud(dexie) {
                 ? yield navigator.serviceWorker.getRegistrations()
                 : [];
             const [initiallySynced, lastSyncedRealms] = yield db.transaction('rw', db.$syncState, () => __awaiter(this, void 0, void 0, function* () {
-                var _h, _j;
+                var _a, _b;
                 const { options, schema } = db.cloud;
                 const [persistedOptions, persistedSchema, persistedSyncState] = yield Promise.all([
                     db.getOptions(),
@@ -8078,7 +8239,7 @@ function dexieCloud(dexie) {
                     delete newPersistedOptions.awarenessProtocol;
                     yield db.$syncState.put(newPersistedOptions, 'options');
                 }
-                if (((_h = db.cloud.options) === null || _h === void 0 ? void 0 : _h.tryUseServiceWorker) &&
+                if (((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.tryUseServiceWorker) &&
                     'serviceWorker' in navigator &&
                     swRegistrations.length > 0 &&
                     !DISABLE_SERVICEWORKER_STRATEGY) {
@@ -8092,7 +8253,7 @@ function dexieCloud(dexie) {
                     // Not configured for using service worker or no service worker
                     // registration exists. Don't rely on service worker to do any job.
                     // Use LocalSyncWorker instead.
-                    if (((_j = db.cloud.options) === null || _j === void 0 ? void 0 : _j.tryUseServiceWorker) &&
+                    if (((_b = db.cloud.options) === null || _b === void 0 ? void 0 : _b.tryUseServiceWorker) &&
                         !db.cloud.isServiceWorkerDB) {
                         console.debug('dexie-cloud-addon: Not using service worker.', swRegistrations.length === 0
                             ? 'No SW registrations found.'
@@ -8231,7 +8392,7 @@ function dexieCloud(dexie) {
     }
 }
 // @ts-ignore
-dexieCloud.version = "4.1.0-alpha.2";
+dexieCloud.version = "4.1.0-alpha.20";
 Dexie.Cloud = dexieCloud;
 
 // In case the SW lives for a while, let it reuse already opened connections:
@@ -8261,8 +8422,8 @@ function syncDB(dbName, purpose) {
     }
     return promise;
     function _syncDB(dbName, purpose) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             let db = managedDBs.get(dbName);
             if (!db) {
                 console.debug('Dexie Cloud SW: Creating new Dexie instance for', dbName);