dexie-cloud-addon 4.0.0-beta.16 → 4.0.0-beta.19

package/dist/modern/service-worker.js

@@ -1,5 +1,30 @@
 import Dexie, { cmp, liveQuery } from 'dexie';
-import { Observable as Observable$1, BehaviorSubject, Subject, from as from$1, fromEvent, of, merge, Subscription as Subscription$1, throwError, combineLatest, map as map$1, share, timer as timer$1, switchMap as switchMap$1 } from 'rxjs';
+import { Observable as Observable$1, BehaviorSubject, Subject, fromEvent, of, merge, Subscription as Subscription$1, from as from$1, throwError, combineLatest, map as map$1, share, timer as timer$1, switchMap as switchMap$1 } from 'rxjs';
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter$1(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
 
 const UNAUTHORIZED_USER = {
     userId: "unauthorized",
@@ -13,7 +38,7 @@ try {
     Object.freeze(UNAUTHORIZED_USER);
     Object.freeze(UNAUTHORIZED_USER.claims);
 }
-catch { }
+catch (_a) { }
 
 const swHolder = {};
 const swContainer = self.document && navigator.serviceWorker; // self.document is to verify we're not the SW ourself
@@ -22,8 +47,9 @@ if (swContainer)
 if (typeof self !== 'undefined' && 'clients' in self && !self.document) {
     // We are the service worker. Propagate messages to all our clients.
     addEventListener('message', (ev) => {
-        if (ev.data?.type?.startsWith('sw-broadcast-')) {
-            [...self['clients'].matchAll({ includeUncontrolled: true })].forEach((client) => client.id !== ev.source?.id && client.postMessage(ev.data));
+        var _a, _b;
+        if ((_b = (_a = ev.data) === null || _a === void 0 ? void 0 : _a.type) === null || _b === void 0 ? void 0 : _b.startsWith('sw-broadcast-')) {
+            [...self['clients'].matchAll({ includeUncontrolled: true })].forEach((client) => { var _a; return client.id !== ((_a = ev.source) === null || _a === void 0 ? void 0 : _a.id) && client.postMessage(ev.data); });
         }
     });
 }
@@ -35,7 +61,8 @@ class SWBroadcastChannel {
         if (!swContainer)
             return () => { };
         const forwarder = (ev) => {
-            if (ev.data?.type === `sw-broadcast-${this.name}`) {
+            var _a;
+            if (((_a = ev.data) === null || _a === void 0 ? void 0 : _a.type) === `sw-broadcast-${this.name}`) {
                 listener(ev.data.message);
             }
         };
@@ -43,6 +70,7 @@ class SWBroadcastChannel {
         return () => swContainer.removeEventListener('message', forwarder);
     }
     postMessage(message) {
+        var _a;
         if (typeof self['clients'] === 'object') {
             // We're a service worker. Propagate to our browser clients.
             [...self['clients'].matchAll({ includeUncontrolled: true })].forEach((client) => client.postMessage({
@@ -53,7 +81,7 @@ class SWBroadcastChannel {
         else if (swHolder.registration) {
             // We're a client (browser window or other worker)
             // Post to SW so it can repost to all its clients and to itself
-            swHolder.registration.active?.postMessage({
+            (_a = swHolder.registration.active) === null || _a === void 0 ? void 0 : _a.postMessage({
                 type: `sw-broadcast-${this.name}`,
                 message
             });
@@ -96,7 +124,7 @@ class BroadcastedAndLocalEvent extends Observable$1 {
         this.bc = bc;
     }
     next(message) {
-        console.debug("BroadcastedAndLocalEvent: bc.postMessage()", { ...message }, "bc is a", this.bc);
+        console.debug("BroadcastedAndLocalEvent: bc.postMessage()", Object.assign({}, message), "bc is a", this.bc);
         this.bc.postMessage(message);
         const ev = new CustomEvent(`lbc-${this.name}`, { detail: message });
         self.dispatchEvent(ev);
@@ -1689,55 +1717,60 @@ function timeoutErrorFactory(info) {
 
 //const hasSW = 'serviceWorker' in navigator;
 let hasComplainedAboutSyncEvent = false;
-async function registerSyncEvent(db, purpose) {
-    try {
-        // Send sync event to SW:
-        const sw = await navigator.serviceWorker.ready;
-        if (purpose === "push" && sw.sync) {
-            await sw.sync.register(`dexie-cloud:${db.name}`);
-        }
-        if (sw.active) {
-            // Use postMessage for pull syncs and for browsers not supporting sync event (Firefox, Safari).
-            // Also chromium based browsers with sw.sync as a fallback for sleepy sync events not taking action for a while.
-            sw.active.postMessage({
-                type: 'dexie-cloud-sync',
-                dbName: db.name,
-                purpose
-            });
-        }
-        else {
-            throw new Error(`Failed to trigger sync - there's no active service worker`);
+function registerSyncEvent(db, purpose) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        try {
+            // Send sync event to SW:
+            const sw = yield navigator.serviceWorker.ready;
+            if (purpose === "push" && sw.sync) {
+                yield sw.sync.register(`dexie-cloud:${db.name}`);
+            }
+            if (sw.active) {
+                // Use postMessage for pull syncs and for browsers not supporting sync event (Firefox, Safari).
+                // Also chromium based browsers with sw.sync as a fallback for sleepy sync events not taking action for a while.
+                sw.active.postMessage({
+                    type: 'dexie-cloud-sync',
+                    dbName: db.name,
+                    purpose
+                });
+            }
+            else {
+                throw new Error(`Failed to trigger sync - there's no active service worker`);
+            }
+            return;
         }
-        return;
-    }
-    catch (e) {
-        if (!hasComplainedAboutSyncEvent) {
-            console.debug(`Dexie Cloud: Could not register sync event`, e);
-            hasComplainedAboutSyncEvent = true;
+        catch (e) {
+            if (!hasComplainedAboutSyncEvent) {
+                console.debug(`Dexie Cloud: Could not register sync event`, e);
+                hasComplainedAboutSyncEvent = true;
+            }
         }
-    }
+    });
 }
-async function registerPeriodicSyncEvent(db) {
-    try {
-        // Register periodicSync event to SW:
-        // @ts-ignore
-        const { periodicSync } = await navigator.serviceWorker.ready;
-        if (periodicSync) {
-            try {
-                await periodicSync.register(`dexie-cloud:${db.name}`, db.cloud.options?.periodicSync);
-                console.debug(`Dexie Cloud: Successfully registered periodicsync event for ${db.name}`);
+function registerPeriodicSyncEvent(db) {
+    var _a;
+    return __awaiter$1(this, void 0, void 0, function* () {
+        try {
+            // Register periodicSync event to SW:
+            // @ts-ignore
+            const { periodicSync } = yield navigator.serviceWorker.ready;
+            if (periodicSync) {
+                try {
+                    yield periodicSync.register(`dexie-cloud:${db.name}`, (_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.periodicSync);
+                    console.debug(`Dexie Cloud: Successfully registered periodicsync event for ${db.name}`);
+                }
+                catch (e) {
+                    console.debug(`Dexie Cloud: Failed to register periodic sync. Your PWA must be installed to allow background sync.`, e);
+                }
             }
-            catch (e) {
-                console.debug(`Dexie Cloud: Failed to register periodic sync. Your PWA must be installed to allow background sync.`, e);
+            else {
+                console.debug(`Dexie Cloud: periodicSync not supported.`);
             }
         }
-        else {
-            console.debug(`Dexie Cloud: periodicSync not supported.`);
+        catch (e) {
+            console.debug(`Dexie Cloud: Could not register periodicSync for ${db.name}`, e);
         }
-    }
-    catch (e) {
-        console.debug(`Dexie Cloud: Could not register periodicSync for ${db.name}`, e);
-    }
+    });
 }
 
 function triggerSync(db, purpose) {
@@ -1766,15 +1799,17 @@ const b64encode = typeof Buffer !== "undefined"
         : Buffer.from(b).toString("base64")
     : (b) => btoa(String.fromCharCode.apply(null, b));
 
-async function computeRealmSetHash({ realms, inviteRealms, }) {
-    const data = JSON.stringify([
-        ...realms.map((realmId) => ({ realmId, accepted: true })),
-        ...inviteRealms.map((realmId) => ({ realmId, accepted: false })),
-    ].sort((a, b) => a.realmId < b.realmId ? -1 : a.realmId > b.realmId ? 1 : 0));
-    const byteArray = new TextEncoder().encode(data);
-    const digestBytes = await crypto.subtle.digest('SHA-1', byteArray);
-    const base64 = b64encode(digestBytes);
-    return base64;
+function computeRealmSetHash({ realms, inviteRealms, }) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        const data = JSON.stringify([
+            ...realms.map((realmId) => ({ realmId, accepted: true })),
+            ...inviteRealms.map((realmId) => ({ realmId, accepted: false })),
+        ].sort((a, b) => a.realmId < b.realmId ? -1 : a.realmId > b.realmId ? 1 : 0));
+        const byteArray = new TextEncoder().encode(data);
+        const digestBytes = yield crypto.subtle.digest('SHA-1', byteArray);
+        const base64 = b64encode(digestBytes);
+        return base64;
+    });
 }
 
 function getSyncableTables(db) {
@@ -1789,7 +1824,8 @@ function getMutationTable(tableName) {
 }
 
 function getTableFromMutationTable(mutationTable) {
-    const tableName = /^\$(.*)_mutations$/.exec(mutationTable)?.[1];
+    var _a;
+    const tableName = (_a = /^\$(.*)_mutations$/.exec(mutationTable)) === null || _a === void 0 ? void 0 : _a[1];
     if (!tableName)
         throw new Error(`Given mutationTable ${mutationTable} is not correct`);
     return tableName;
@@ -1800,49 +1836,51 @@ function flatten(a) {
     return concat.apply([], a);
 }
 
-async function listClientChanges(mutationTables, db, { since = {}, limit = Infinity } = {}) {
-    const allMutsOnTables = await Promise.all(mutationTables.map(async (mutationTable) => {
-        const tableName = getTableFromMutationTable(mutationTable.name);
-        const lastRevision = since[tableName];
-        let query = lastRevision
-            ? mutationTable.where('rev').above(lastRevision)
-            : mutationTable;
-        if (limit < Infinity)
-            query = query.limit(limit);
-        const muts = await query.toArray();
-        //const objTable = db.table(tableName);
-        /*for (const mut of muts) {
-          if (mut.type === "insert" || mut.type === "upsert") {
-            mut.values = await objTable.bulkGet(mut.keys);
-          }
-        }*/
-        return muts.map((mut) => ({
-            table: tableName,
-            mut,
-        }));
-    }));
-    // Sort by time to get a true order of the operations (between tables)
-    const sorted = flatten(allMutsOnTables).sort((a, b) => a.mut.ts - b.mut.ts);
-    const result = [];
-    let currentEntry = null;
-    let currentTxid = null;
-    for (const { table, mut } of sorted) {
-        if (currentEntry &&
-            currentEntry.table === table &&
-            currentTxid === mut.txid) {
-            currentEntry.muts.push(mut);
-        }
-        else {
-            currentEntry = {
-                table,
-                muts: [mut],
-            };
-            currentTxid = mut.txid;
-            result.push(currentEntry);
+function listClientChanges(mutationTables, db, { since = {}, limit = Infinity } = {}) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        const allMutsOnTables = yield Promise.all(mutationTables.map((mutationTable) => __awaiter$1(this, void 0, void 0, function* () {
+            const tableName = getTableFromMutationTable(mutationTable.name);
+            const lastRevision = since[tableName];
+            let query = lastRevision
+                ? mutationTable.where('rev').above(lastRevision)
+                : mutationTable;
+            if (limit < Infinity)
+                query = query.limit(limit);
+            const muts = yield query.toArray();
+            //const objTable = db.table(tableName);
+            /*for (const mut of muts) {
+              if (mut.type === "insert" || mut.type === "upsert") {
+                mut.values = await objTable.bulkGet(mut.keys);
+              }
+            }*/
+            return muts.map((mut) => ({
+                table: tableName,
+                mut,
+            }));
+        })));
+        // Sort by time to get a true order of the operations (between tables)
+        const sorted = flatten(allMutsOnTables).sort((a, b) => a.mut.ts - b.mut.ts);
+        const result = [];
+        let currentEntry = null;
+        let currentTxid = null;
+        for (const { table, mut } of sorted) {
+            if (currentEntry &&
+                currentEntry.table === table &&
+                currentTxid === mut.txid) {
+                currentEntry.muts.push(mut);
+            }
+            else {
+                currentEntry = {
+                    table,
+                    muts: [mut],
+                };
+                currentTxid = mut.txid;
+                result.push(currentEntry);
+            }
         }
-    }
-    // Filter out those tables that doesn't have any mutations:
-    return result;
+        // Filter out those tables that doesn't have any mutations:
+        return result;
+    });
 }
 
 function randomString$1(bytes) {
@@ -2148,58 +2186,60 @@ function getDbNameFromDbUrl(dbUrl) {
         : url.pathname.split('/')[1];
 }
 
-async function listSyncifiedChanges(tablesToSyncify, currentUser, schema, alreadySyncedRealms) {
-    const txid = `upload-${randomString$1(8)}`;
-    if (currentUser.isLoggedIn) {
-        if (tablesToSyncify.length > 0) {
-            const ignoredRealms = new Set(alreadySyncedRealms || []);
-            const upserts = await Promise.all(tablesToSyncify.map(async (table) => {
-                const { extractKey } = table.core.schema.primaryKey;
-                if (!extractKey)
-                    return { table: table.name, muts: [] }; // Outbound tables are not synced.
-                const dexieCloudTableSchema = schema[table.name];
-                const query = dexieCloudTableSchema?.generatedGlobalId
-                    ? table.filter((item) => {
-                        const id = extractKey(item);
-                        return (!ignoredRealms.has(item.realmId || '') &&
-                            //(id[0] !== '#' || !!item.$ts) && // Private obj need no sync if not changed
-                            isValidSyncableID(id));
-                    })
-                    : table.filter((item) => {
-                        extractKey(item);
-                        return (!ignoredRealms.has(item.realmId || '') &&
-                            //(id[0] !== '#' || !!item.$ts) && // Private obj need no sync if not changed
-                            isValidAtID(extractKey(item), dexieCloudTableSchema?.idPrefix));
-                    });
-                const unsyncedObjects = await query.toArray();
-                if (unsyncedObjects.length > 0) {
-                    const mut = {
-                        type: 'upsert',
-                        values: unsyncedObjects,
-                        keys: unsyncedObjects.map(extractKey),
-                        userId: currentUser.userId,
-                        txid,
-                    };
-                    return {
-                        table: table.name,
-                        muts: [mut],
-                    };
-                }
-                else {
-                    return {
-                        table: table.name,
-                        muts: [],
-                    };
-                }
-            }));
-            return upserts.filter((op) => op.muts.length > 0);
+function listSyncifiedChanges(tablesToSyncify, currentUser, schema, alreadySyncedRealms) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        const txid = `upload-${randomString$1(8)}`;
+        if (currentUser.isLoggedIn) {
+            if (tablesToSyncify.length > 0) {
+                const ignoredRealms = new Set(alreadySyncedRealms || []);
+                const upserts = yield Promise.all(tablesToSyncify.map((table) => __awaiter$1(this, void 0, void 0, function* () {
+                    const { extractKey } = table.core.schema.primaryKey;
+                    if (!extractKey)
+                        return { table: table.name, muts: [] }; // Outbound tables are not synced.
+                    const dexieCloudTableSchema = schema[table.name];
+                    const query = (dexieCloudTableSchema === null || dexieCloudTableSchema === void 0 ? void 0 : dexieCloudTableSchema.generatedGlobalId)
+                        ? table.filter((item) => {
+                            const id = extractKey(item);
+                            return (!ignoredRealms.has(item.realmId || '') &&
+                                //(id[0] !== '#' || !!item.$ts) && // Private obj need no sync if not changed
+                                isValidSyncableID(id));
+                        })
+                        : table.filter((item) => {
+                            extractKey(item);
+                            return (!ignoredRealms.has(item.realmId || '') &&
+                                //(id[0] !== '#' || !!item.$ts) && // Private obj need no sync if not changed
+                                isValidAtID(extractKey(item), dexieCloudTableSchema === null || dexieCloudTableSchema === void 0 ? void 0 : dexieCloudTableSchema.idPrefix));
+                        });
+                    const unsyncedObjects = yield query.toArray();
+                    if (unsyncedObjects.length > 0) {
+                        const mut = {
+                            type: 'upsert',
+                            values: unsyncedObjects,
+                            keys: unsyncedObjects.map(extractKey),
+                            userId: currentUser.userId,
+                            txid,
+                        };
+                        return {
+                            table: table.name,
+                            muts: [mut],
+                        };
+                    }
+                    else {
+                        return {
+                            table: table.name,
+                            muts: [],
+                        };
+                    }
+                })));
+                return upserts.filter((op) => op.muts.length > 0);
+            }
         }
-    }
-    return [];
+        return [];
+    });
 }
 
 function getTablesToSyncify(db, syncState) {
-    const syncedTables = syncState?.syncedTables || [];
+    const syncedTables = (syncState === null || syncState === void 0 ? void 0 : syncState.syncedTables) || [];
     const syncableTables = getSyncableTables(db);
     const tablesToSyncify = syncableTables.filter((tbl) => !syncedTables.includes(tbl.name));
     return tablesToSyncify;
@@ -2208,19 +2248,15 @@ function getTablesToSyncify(db, syncState) {
 function interactWithUser(userInteraction, req) {
     let done = false;
     return new Promise((resolve, reject) => {
-        const interactionProps = {
-            ...req,
-            onSubmit: (res) => {
+        const interactionProps = Object.assign(Object.assign({}, req), { onSubmit: (res) => {
                 userInteraction.next(undefined);
                 done = true;
                 resolve(res);
-            },
-            onCancel: () => {
+            }, onCancel: () => {
                 userInteraction.next(undefined);
                 done = true;
                 reject(new Dexie.AbortError("User cancelled"));
-            },
-        };
+            } });
         userInteraction.next(interactionProps);
         // Start subscribing for external updates to db.cloud.userInteraction, and if so, cancel this request.
         /*const subscription = userInteraction.subscribe((currentInteractionProps) => {
@@ -2241,180 +2277,193 @@ function alertUser(userInteraction, title, ...alerts) {
         fields: {}
     });
 }
-async function promptForEmail(userInteraction, title, emailHint) {
-    let email = emailHint || '';
-    while (!email || !/^[\w-\.]+@([\w-]+\.)+[\w-]{2,10}$/.test(email)) {
-        email = (await interactWithUser(userInteraction, {
-            type: 'email',
-            title,
-            alerts: email
-                ? [
-                    {
-                        type: 'error',
-                        messageCode: 'INVALID_EMAIL',
-                        message: 'Please enter a valid email address',
-                        messageParams: {},
+function promptForEmail(userInteraction, title, emailHint) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        let email = emailHint || '';
+        while (!email || !/^[\w-\.]+@([\w-]+\.)+[\w-]{2,10}$/.test(email)) {
+            email = (yield interactWithUser(userInteraction, {
+                type: 'email',
+                title,
+                alerts: email
+                    ? [
+                        {
+                            type: 'error',
+                            messageCode: 'INVALID_EMAIL',
+                            message: 'Please enter a valid email address',
+                            messageParams: {},
+                        },
+                    ]
+                    : [],
+                fields: {
+                    email: {
+                        type: 'email',
+                        placeholder: 'you@somedomain.com',
                     },
-                ]
-                : [],
-            fields: {
-                email: {
-                    type: 'email',
-                    placeholder: 'you@somedomain.com',
                 },
-            },
-        })).email;
-    }
-    return email;
+            })).email;
+        }
+        return email;
+    });
 }
-async function promptForOTP(userInteraction, email, alert) {
-    const alerts = [
-        {
-            type: 'info',
-            messageCode: 'OTP_SENT',
-            message: `A One-Time password has been sent to {email}`,
-            messageParams: { email },
-        },
-    ];
-    if (alert) {
-        alerts.push(alert);
-    }
-    const { otp } = await interactWithUser(userInteraction, {
-        type: 'otp',
-        title: 'Enter OTP',
-        alerts,
-        fields: {
-            otp: {
-                type: 'otp',
-                label: 'OTP',
-                placeholder: 'Paste OTP here',
+function promptForOTP(userInteraction, email, alert) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        const alerts = [
+            {
+                type: 'info',
+                messageCode: 'OTP_SENT',
+                message: `A One-Time password has been sent to {email}`,
+                messageParams: { email },
             },
-        },
+        ];
+        if (alert) {
+            alerts.push(alert);
+        }
+        const { otp } = yield interactWithUser(userInteraction, {
+            type: 'otp',
+            title: 'Enter OTP',
+            alerts,
+            fields: {
+                otp: {
+                    type: 'otp',
+                    label: 'OTP',
+                    placeholder: 'Paste OTP here',
+                },
+            },
+        });
+        return otp;
     });
-    return otp;
 }
 
-async function loadAccessToken(db) {
-    const currentUser = await db.getCurrentUser();
-    const { accessToken, accessTokenExpiration, refreshToken, refreshTokenExpiration, claims, } = currentUser;
-    if (!accessToken)
-        return;
-    const expTime = accessTokenExpiration?.getTime() ?? Infinity;
-    if (expTime > Date.now()) {
-        return accessToken;
-    }
-    if (!refreshToken) {
-        throw new Error(`Refresh token missing`);
-    }
-    const refreshExpTime = refreshTokenExpiration?.getTime() ?? Infinity;
-    if (refreshExpTime <= Date.now()) {
-        throw new Error(`Refresh token has expired`);
-    }
-    const refreshedLogin = await refreshAccessToken(db.cloud.options.databaseUrl, currentUser);
-    await db.table('$logins').update(claims.sub, {
-        accessToken: refreshedLogin.accessToken,
-        accessTokenExpiration: refreshedLogin.accessTokenExpiration,
+function loadAccessToken(db) {
+    var _a, _b;
+    return __awaiter$1(this, void 0, void 0, function* () {
+        const currentUser = yield db.getCurrentUser();
+        const { accessToken, accessTokenExpiration, refreshToken, refreshTokenExpiration, claims, } = currentUser;
+        if (!accessToken)
+            return;
+        const expTime = (_a = accessTokenExpiration === null || accessTokenExpiration === void 0 ? void 0 : accessTokenExpiration.getTime()) !== null && _a !== void 0 ? _a : Infinity;
+        if (expTime > Date.now()) {
+            return accessToken;
+        }
+        if (!refreshToken) {
+            throw new Error(`Refresh token missing`);
+        }
+        const refreshExpTime = (_b = refreshTokenExpiration === null || refreshTokenExpiration === void 0 ? void 0 : refreshTokenExpiration.getTime()) !== null && _b !== void 0 ? _b : Infinity;
+        if (refreshExpTime <= Date.now()) {
+            throw new Error(`Refresh token has expired`);
+        }
+        const refreshedLogin = yield refreshAccessToken(db.cloud.options.databaseUrl, currentUser);
+        yield db.table('$logins').update(claims.sub, {
+            accessToken: refreshedLogin.accessToken,
+            accessTokenExpiration: refreshedLogin.accessTokenExpiration,
+        });
+        return refreshedLogin.accessToken;
     });
-    return refreshedLogin.accessToken;
-}
-async function authenticate(url, context, fetchToken, userInteraction, hints) {
-    if (context.accessToken &&
-        context.accessTokenExpiration.getTime() > Date.now()) {
-        return context;
-    }
-    else if (context.refreshToken &&
-        (!context.refreshTokenExpiration ||
-            context.refreshTokenExpiration.getTime() > Date.now())) {
-        return await refreshAccessToken(url, context);
-    }
-    else {
-        return await userAuthenticate(context, fetchToken, userInteraction, hints);
-    }
 }
-async function refreshAccessToken(url, login) {
-    if (!login.refreshToken)
-        throw new Error(`Cannot refresh token - refresh token is missing.`);
-    if (!login.nonExportablePrivateKey)
-        throw new Error(`login.nonExportablePrivateKey is missing - cannot sign refresh token without a private key.`);
-    const time_stamp = Date.now();
-    const signing_algorithm = 'RSASSA-PKCS1-v1_5';
-    const textEncoder = new TextEncoder();
-    const data = textEncoder.encode(login.refreshToken + time_stamp);
-    const binarySignature = await crypto.subtle.sign(signing_algorithm, login.nonExportablePrivateKey, data);
-    const signature = b64encode(binarySignature);
-    const tokenRequest = {
-        grant_type: 'refresh_token',
-        refresh_token: login.refreshToken,
-        scopes: ['ACCESS_DB'],
-        signature,
-        signing_algorithm,
-        time_stamp,
-    };
-    const res = await fetch(`${url}/token`, {
-        body: JSON.stringify(tokenRequest),
-        method: 'post',
-        headers: { 'Content-Type': 'application/json' },
-        mode: 'cors',
+function authenticate(url, context, fetchToken, userInteraction, hints) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        if (context.accessToken &&
+            context.accessTokenExpiration.getTime() > Date.now()) {
+            return context;
+        }
+        else if (context.refreshToken &&
+            (!context.refreshTokenExpiration ||
+                context.refreshTokenExpiration.getTime() > Date.now())) {
+            return yield refreshAccessToken(url, context);
+        }
+        else {
+            return yield userAuthenticate(context, fetchToken, userInteraction, hints);
+        }
     });
-    if (res.status !== 200)
-        throw new Error(`RefreshToken: Status ${res.status} from ${url}/token`);
-    const response = await res.json();
-    login.accessToken = response.accessToken;
-    login.accessTokenExpiration = response.accessTokenExpiration
-        ? new Date(response.accessTokenExpiration)
-        : undefined;
-    return login;
-}
-async function userAuthenticate(context, fetchToken, userInteraction, hints) {
-    const { privateKey, publicKey } = await crypto.subtle.generateKey({
-        name: 'RSASSA-PKCS1-v1_5',
-        modulusLength: 2048,
-        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
-        hash: { name: 'SHA-256' },
-    }, false, // Non-exportable...
-    ['sign', 'verify']);
-    if (!privateKey || !publicKey)
-        throw new Error(`Could not generate RSA keypair`); // Typings suggest these can be undefined...
-    context.nonExportablePrivateKey = privateKey; //...but storable!
-    const publicKeySPKI = await crypto.subtle.exportKey('spki', publicKey);
-    const publicKeyPEM = spkiToPEM(publicKeySPKI);
-    context.publicKey = publicKey;
-    try {
-        const response2 = await fetchToken({
-            public_key: publicKeyPEM,
-            hints,
+}
+function refreshAccessToken(url, login) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        if (!login.refreshToken)
+            throw new Error(`Cannot refresh token - refresh token is missing.`);
+        if (!login.nonExportablePrivateKey)
+            throw new Error(`login.nonExportablePrivateKey is missing - cannot sign refresh token without a private key.`);
+        const time_stamp = Date.now();
+        const signing_algorithm = 'RSASSA-PKCS1-v1_5';
+        const textEncoder = new TextEncoder();
+        const data = textEncoder.encode(login.refreshToken + time_stamp);
+        const binarySignature = yield crypto.subtle.sign(signing_algorithm, login.nonExportablePrivateKey, data);
+        const signature = b64encode(binarySignature);
+        const tokenRequest = {
+            grant_type: 'refresh_token',
+            refresh_token: login.refreshToken,
+            scopes: ['ACCESS_DB'],
+            signature,
+            signing_algorithm,
+            time_stamp,
+        };
+        const res = yield fetch(`${url}/token`, {
+            body: JSON.stringify(tokenRequest),
+            method: 'post',
+            headers: { 'Content-Type': 'application/json' },
+            mode: 'cors',
         });
-        if (response2.type !== 'tokens')
-            throw new Error(`Unexpected response type from token endpoint: ${response2.type}`);
-        context.accessToken = response2.accessToken;
-        context.accessTokenExpiration = new Date(response2.accessTokenExpiration);
-        context.refreshToken = response2.refreshToken;
-        if (response2.refreshTokenExpiration) {
-            context.refreshTokenExpiration = new Date(response2.refreshTokenExpiration);
-        }
-        context.userId = response2.claims.sub;
-        context.email = response2.claims.email;
-        context.name = response2.claims.name;
-        context.claims = response2.claims;
-        if (response2.alerts && response2.alerts.length > 0) {
-            await interactWithUser(userInteraction, {
-                type: 'message-alert',
-                title: 'Authentication Alert',
-                fields: {},
-                alerts: response2.alerts,
+        if (res.status !== 200)
+            throw new Error(`RefreshToken: Status ${res.status} from ${url}/token`);
+        const response = yield res.json();
+        login.accessToken = response.accessToken;
+        login.accessTokenExpiration = response.accessTokenExpiration
+            ? new Date(response.accessTokenExpiration)
+            : undefined;
+        return login;
+    });
+}
+function userAuthenticate(context, fetchToken, userInteraction, hints) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        const { privateKey, publicKey } = yield crypto.subtle.generateKey({
+            name: 'RSASSA-PKCS1-v1_5',
+            modulusLength: 2048,
+            publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+            hash: { name: 'SHA-256' },
+        }, false, // Non-exportable...
+        ['sign', 'verify']);
+        if (!privateKey || !publicKey)
+            throw new Error(`Could not generate RSA keypair`); // Typings suggest these can be undefined...
+        context.nonExportablePrivateKey = privateKey; //...but storable!
+        const publicKeySPKI = yield crypto.subtle.exportKey('spki', publicKey);
+        const publicKeyPEM = spkiToPEM(publicKeySPKI);
+        context.publicKey = publicKey;
+        try {
+            const response2 = yield fetchToken({
+                public_key: publicKeyPEM,
+                hints,
             });
+            if (response2.type !== 'tokens')
+                throw new Error(`Unexpected response type from token endpoint: ${response2.type}`);
+            context.accessToken = response2.accessToken;
+            context.accessTokenExpiration = new Date(response2.accessTokenExpiration);
+            context.refreshToken = response2.refreshToken;
+            if (response2.refreshTokenExpiration) {
+                context.refreshTokenExpiration = new Date(response2.refreshTokenExpiration);
+            }
+            context.userId = response2.claims.sub;
+            context.email = response2.claims.email;
+            context.name = response2.claims.name;
+            context.claims = response2.claims;
+            if (response2.alerts && response2.alerts.length > 0) {
+                yield interactWithUser(userInteraction, {
+                    type: 'message-alert',
+                    title: 'Authentication Alert',
+                    fields: {},
+                    alerts: response2.alerts,
+                });
+            }
+            return context;
         }
-        return context;
-    }
-    catch (error) {
-        await alertUser(userInteraction, 'Authentication Failed', {
-            type: 'error',
-            messageCode: 'GENERIC_ERROR',
-            message: `We're having a problem authenticating right now.`,
-            messageParams: {}
-        }).catch(() => { });
-        throw error;
-    }
+        catch (error) {
+            yield alertUser(userInteraction, 'Authentication Failed', {
+                type: 'error',
+                messageCode: 'GENERIC_ERROR',
+                message: `We're having a problem authenticating right now.`,
+                messageParams: {}
+            }).catch(() => { });
+            throw error;
+        }
+    });
 }
 function spkiToPEM(keydata) {
     const keydataB64 = b64encode(keydata);
@@ -2947,23 +2996,17 @@ class FakeBigInt {
         return this.v;
     }
 }
-const defs = {
-    ...undefinedDef,
-    ...(hasBigIntSupport
-        ? {}
-        : {
-            bigint: {
-                test: (val) => val instanceof FakeBigInt,
-                replace: (fakeBigInt) => {
-                    return {
-                        $t: 'bigint',
-                        ...fakeBigInt
-                    };
-                },
-                revive: ({ v, }) => new FakeBigInt(v)
-            }
-        })
-};
+const defs = Object.assign(Object.assign({}, undefinedDef), (hasBigIntSupport
+    ? {}
+    : {
+        bigint: {
+            test: (val) => val instanceof FakeBigInt,
+            replace: (fakeBigInt) => {
+                return Object.assign({ $t: 'bigint' }, fakeBigInt);
+            },
+            revive: ({ v, }) => new FakeBigInt(v)
+        }
+    }));
 const TSON = TypesonSimplified(builtin, defs);
 const BISON = Bison(defs);
 
@@ -3022,110 +3065,107 @@ function encodeIdsForServer(schema, currentUser, changes) {
 }
 function cloneChange(change, rewriteValues) {
     // clone on demand:
-    return {
-        ...change,
-        muts: rewriteValues
-            ? change.muts.map((m) => ({
-                ...m,
-                keys: m.keys.slice(),
-                values: m.values.slice(),
-            }))
-            : change.muts.map((m) => ({ ...m, keys: m.keys.slice() })),
-    };
+    return Object.assign(Object.assign({}, change), { muts: rewriteValues
+            ? change.muts.map((m) => (Object.assign(Object.assign({}, m), { keys: m.keys.slice(), values: m.values.slice() })))
+            : change.muts.map((m) => (Object.assign(Object.assign({}, m), { keys: m.keys.slice() }))) });
 }
 
 //import {BisonWebStreamReader} from "dreambase-library/dist/typeson-simplified/BisonWebStreamReader";
-async function syncWithServer(changes, syncState, baseRevs, db, databaseUrl, schema, clientIdentity, currentUser) {
-    //
-    // Push changes to server using fetch
-    //
-    const headers = {
-        Accept: 'application/json, application/x-bison, application/x-bison-stream',
-        'Content-Type': 'application/tson'
-    };
-    const accessToken = await loadAccessToken(db);
-    if (accessToken) {
-        headers.Authorization = `Bearer ${accessToken}`;
-    }
-    const syncRequest = {
-        v: 2,
-        dbID: syncState?.remoteDbId,
-        clientIdentity,
-        schema: schema || {},
-        lastPull: syncState ? {
-            serverRevision: syncState.serverRevision,
-            realms: syncState.realms,
-            inviteRealms: syncState.inviteRealms
-        } : undefined,
-        baseRevs,
-        changes: encodeIdsForServer(db.dx.core.schema, currentUser, changes)
-    };
-    console.debug("Sync request", syncRequest);
-    db.syncStateChangedEvent.next({
-        phase: 'pushing',
-    });
-    const res = await fetch(`${databaseUrl}/sync`, {
-        method: 'post',
-        headers,
-        body: TSON.stringify(syncRequest)
-    });
-    //const contentLength = Number(res.headers.get('content-length'));
-    db.syncStateChangedEvent.next({
-        phase: 'pulling'
-    });
-    if (!res.ok) {
-        throw new HttpError(res);
-    }
-    switch (res.headers.get('content-type')) {
-        case 'application/x-bison':
-            return BISON.fromBinary(await res.blob());
-        case 'application/x-bison-stream': //return BisonWebStreamReader(BISON, res);
-        default:
-        case 'application/json': {
-            const text = await res.text();
-            const syncRes = TSON.parse(text);
-            return syncRes;
+function syncWithServer(changes, syncState, baseRevs, db, databaseUrl, schema, clientIdentity, currentUser) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        //
+        // Push changes to server using fetch
+        //
+        const headers = {
+            Accept: 'application/json, application/x-bison, application/x-bison-stream',
+            'Content-Type': 'application/tson'
+        };
+        const accessToken = yield loadAccessToken(db);
+        if (accessToken) {
+            headers.Authorization = `Bearer ${accessToken}`;
         }
-    }
-}
-
-async function modifyLocalObjectsWithNewUserId(syncifiedTables, currentUser, alreadySyncedRealms) {
-    const ignoredRealms = new Set(alreadySyncedRealms || []);
-    for (const table of syncifiedTables) {
-        if (table.name === "members") {
-            // members
-            await table.toCollection().modify((member) => {
-                if (!ignoredRealms.has(member.realmId) && (!member.userId || member.userId === UNAUTHORIZED_USER.userId)) {
-                    member.userId = currentUser.userId;
-                }
-            });
+        const syncRequest = {
+            v: 2,
+            dbID: syncState === null || syncState === void 0 ? void 0 : syncState.remoteDbId,
+            clientIdentity,
+            schema: schema || {},
+            lastPull: syncState ? {
+                serverRevision: syncState.serverRevision,
+                realms: syncState.realms,
+                inviteRealms: syncState.inviteRealms
+            } : undefined,
+            baseRevs,
+            changes: encodeIdsForServer(db.dx.core.schema, currentUser, changes)
+        };
+        console.debug("Sync request", syncRequest);
+        db.syncStateChangedEvent.next({
+            phase: 'pushing',
+        });
+        const res = yield fetch(`${databaseUrl}/sync`, {
+            method: 'post',
+            headers,
+            body: TSON.stringify(syncRequest)
+        });
+        //const contentLength = Number(res.headers.get('content-length'));
+        db.syncStateChangedEvent.next({
+            phase: 'pulling'
+        });
+        if (!res.ok) {
+            throw new HttpError(res);
         }
-        else if (table.name === "roles") ;
-        else if (table.name === "realms") {
-            // realms
-            await table.toCollection().modify((realm) => {
-                if (!ignoredRealms.has(realm.realmId) && (realm.owner === undefined || realm.owner === UNAUTHORIZED_USER.userId)) {
-                    realm.owner = currentUser.userId;
-                }
-            });
+        switch (res.headers.get('content-type')) {
+            case 'application/x-bison':
+                return BISON.fromBinary(yield res.blob());
+            case 'application/x-bison-stream': //return BisonWebStreamReader(BISON, res);
+            default:
+            case 'application/json': {
+                const text = yield res.text();
+                const syncRes = TSON.parse(text);
+                return syncRes;
+            }
         }
-        else {
-            // application entities
-            await table.toCollection().modify((obj) => {
-                if (!obj.realmId || !ignoredRealms.has(obj.realmId)) {
-                    if (!obj.owner || obj.owner === UNAUTHORIZED_USER.userId)
-                        obj.owner = currentUser.userId;
-                    if (!obj.realmId || obj.realmId === UNAUTHORIZED_USER.userId) {
-                        obj.realmId = currentUser.userId;
+    });
+}
+
+function modifyLocalObjectsWithNewUserId(syncifiedTables, currentUser, alreadySyncedRealms) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        const ignoredRealms = new Set(alreadySyncedRealms || []);
+        for (const table of syncifiedTables) {
+            if (table.name === "members") {
+                // members
+                yield table.toCollection().modify((member) => {
+                    if (!ignoredRealms.has(member.realmId) && (!member.userId || member.userId === UNAUTHORIZED_USER.userId)) {
+                        member.userId = currentUser.userId;
                     }
-                }
-            });
+                });
+            }
+            else if (table.name === "roles") ;
+            else if (table.name === "realms") {
+                // realms
+                yield table.toCollection().modify((realm) => {
+                    if (!ignoredRealms.has(realm.realmId) && (realm.owner === undefined || realm.owner === UNAUTHORIZED_USER.userId)) {
+                        realm.owner = currentUser.userId;
+                    }
+                });
+            }
+            else {
+                // application entities
+                yield table.toCollection().modify((obj) => {
+                    if (!obj.realmId || !ignoredRealms.has(obj.realmId)) {
+                        if (!obj.owner || obj.owner === UNAUTHORIZED_USER.userId)
+                            obj.owner = currentUser.userId;
+                        if (!obj.realmId || obj.realmId === UNAUTHORIZED_USER.userId) {
+                            obj.realmId = currentUser.userId;
+                        }
+                    }
+                });
+            }
         }
-    }
+    });
 }
 
 function throwIfCancelled(cancelToken) {
-    if (cancelToken?.cancelled)
+    if (cancelToken === null || cancelToken === void 0 ? void 0 : cancelToken.cancelled)
         throw new Dexie.AbortError(`Operation was cancelled`);
 }
 
@@ -3137,17 +3177,19 @@ let isOnline = navigator.onLine;
 self.addEventListener('online', () => isOnline = true);
 self.addEventListener('offline', () => isOnline = false);
 
-async function updateBaseRevs(db, schema, latestRevisions, serverRev) {
-    await db.$baseRevs.bulkPut(Object.keys(schema)
-        .filter((table) => schema[table].markedForSync)
-        .map((tableName) => {
-        const lastClientRevOnPreviousServerRev = latestRevisions[tableName] || 0;
-        return {
-            tableName,
-            clientRev: lastClientRevOnPreviousServerRev + 1,
-            serverRev,
-        };
-    }));
+function updateBaseRevs(db, schema, latestRevisions, serverRev) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        yield db.$baseRevs.bulkPut(Object.keys(schema)
+            .filter((table) => schema[table].markedForSync)
+            .map((tableName) => {
+            const lastClientRevOnPreviousServerRev = latestRevisions[tableName] || 0;
+            return {
+                tableName,
+                clientRev: lastClientRevOnPreviousServerRev + 1,
+                serverRev,
+            };
+        }));
+    });
 }
 
 function getLatestRevisionsPerTable(clientChangeSet, lastRevisions = {}) {
@@ -3158,119 +3200,123 @@ function getLatestRevisionsPerTable(clientChangeSet, lastRevisions = {}) {
     return lastRevisions;
 }
 
-async function bulkUpdate(table, keys, changeSpecs) {
-    const objs = await table.bulkGet(keys);
-    const resultKeys = [];
-    const resultObjs = [];
-    keys.forEach((key, idx) => {
-        const obj = objs[idx];
-        if (obj) {
-            for (const [keyPath, value] of Object.entries(changeSpecs[idx])) {
-                if (keyPath === table.schema.primKey.keyPath) {
-                    if (cmp(value, key) !== 0) {
-                        throw new Error(`Cannot change primary key`);
-                    }
-                }
-                else {
-                    Dexie.setByKeyPath(obj, keyPath, value);
-                }
-            }
-            resultKeys.push(key);
-            resultObjs.push(obj);
-        }
-    });
-    await (table.schema.primKey.keyPath == null
-        ? table.bulkPut(resultObjs, resultKeys)
-        : table.bulkPut(resultObjs));
-}
-
-async function applyServerChanges(changes, db) {
-    console.debug('Applying server changes', changes, Dexie.currentTransaction);
-    for (const { table: tableName, muts } of changes) {
-        const table = db.table(tableName);
-        if (!table)
-            continue; // If server sends changes on a table we don't have, ignore it.
-        const { primaryKey } = table.core.schema;
-        const keyDecoder = (key) => {
-            switch (key[0]) {
-                case '[':
-                    // Decode JSON array
-                    if (key.endsWith(']'))
-                        try {
-                            // On server, array keys are transformed to JSON string representation
-                            return JSON.parse(key);
+function bulkUpdate(table, keys, changeSpecs) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        const objs = yield table.bulkGet(keys);
+        const resultKeys = [];
+        const resultObjs = [];
+        keys.forEach((key, idx) => {
+            const obj = objs[idx];
+            if (obj) {
+                for (const [keyPath, value] of Object.entries(changeSpecs[idx])) {
+                    if (keyPath === table.schema.primKey.keyPath) {
+                        if (cmp(value, key) !== 0) {
+                            throw new Error(`Cannot change primary key`);
                         }
-                        catch { }
-                    return key;
-                case '#':
-                    // Decode private ID (do the opposite from what's done in encodeIdsForServer())
-                    if (key.endsWith(':' + db.cloud.currentUserId)) {
-                        return key.substr(0, key.length - db.cloud.currentUserId.length - 1);
-                    }
-                    return key;
-                default:
-                    return key;
-            }
-        };
-        for (const mut of muts) {
-            const keys = mut.keys.map(keyDecoder);
-            switch (mut.type) {
-                case 'insert':
-                    if (primaryKey.outbound) {
-                        await table.bulkAdd(mut.values, keys);
-                    }
-                    else {
-                        keys.forEach((key, i) => {
-                            // Make sure inbound keys are consistent
-                            Dexie.setByKeyPath(mut.values[i], primaryKey.keyPath, key);
-                        });
-                        await table.bulkAdd(mut.values);
-                    }
-                    break;
-                case 'upsert':
-                    if (primaryKey.outbound) {
-                        await table.bulkPut(mut.values, keys);
-                    }
-                    else {
-                        keys.forEach((key, i) => {
-                            // Make sure inbound keys are consistent
-                            Dexie.setByKeyPath(mut.values[i], primaryKey.keyPath, key);
-                        });
-                        await table.bulkPut(mut.values);
-                    }
-                    break;
-                case 'modify':
-                    if (keys.length === 1) {
-                        await table.update(keys[0], mut.changeSpec);
                     }
                     else {
-                        await table.where(':id').anyOf(keys).modify(mut.changeSpec);
+                        Dexie.setByKeyPath(obj, keyPath, value);
                     }
-                    break;
-                case 'update':
-                    await bulkUpdate(table, keys, mut.changeSpecs);
-                    break;
-                case 'delete':
-                    await table.bulkDelete(keys);
-                    break;
+                }
+                resultKeys.push(key);
+                resultObjs.push(obj);
             }
-        }
-    }
+        });
+        yield (table.schema.primKey.keyPath == null
+            ? table.bulkPut(resultObjs, resultKeys)
+            : table.bulkPut(resultObjs));
+    });
 }
 
-const CURRENT_SYNC_WORKER = 'currentSyncWorker';
-function sync(db, options, schema, syncOptions) {
-    return _sync
-        .apply(this, arguments)
-        .then(() => {
-        if (!syncOptions?.justCheckIfNeeded) {
-            db.syncStateChangedEvent.next({
+function applyServerChanges(changes, db) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        console.debug('Applying server changes', changes, Dexie.currentTransaction);
+        for (const { table: tableName, muts } of changes) {
+            const table = db.table(tableName);
+            if (!table)
+                continue; // If server sends changes on a table we don't have, ignore it.
+            const { primaryKey } = table.core.schema;
+            const keyDecoder = (key) => {
+                switch (key[0]) {
+                    case '[':
+                        // Decode JSON array
+                        if (key.endsWith(']'))
+                            try {
+                                // On server, array keys are transformed to JSON string representation
+                                return JSON.parse(key);
+                            }
+                            catch (_a) { }
+                        return key;
+                    case '#':
+                        // Decode private ID (do the opposite from what's done in encodeIdsForServer())
+                        if (key.endsWith(':' + db.cloud.currentUserId)) {
+                            return key.substr(0, key.length - db.cloud.currentUserId.length - 1);
+                        }
+                        return key;
+                    default:
+                        return key;
+                }
+            };
+            for (const mut of muts) {
+                const keys = mut.keys.map(keyDecoder);
+                switch (mut.type) {
+                    case 'insert':
+                        if (primaryKey.outbound) {
+                            yield table.bulkAdd(mut.values, keys);
+                        }
+                        else {
+                            keys.forEach((key, i) => {
+                                // Make sure inbound keys are consistent
+                                Dexie.setByKeyPath(mut.values[i], primaryKey.keyPath, key);
+                            });
+                            yield table.bulkAdd(mut.values);
+                        }
+                        break;
+                    case 'upsert':
+                        if (primaryKey.outbound) {
+                            yield table.bulkPut(mut.values, keys);
+                        }
+                        else {
+                            keys.forEach((key, i) => {
+                                // Make sure inbound keys are consistent
+                                Dexie.setByKeyPath(mut.values[i], primaryKey.keyPath, key);
+                            });
+                            yield table.bulkPut(mut.values);
+                        }
+                        break;
+                    case 'modify':
+                        if (keys.length === 1) {
+                            yield table.update(keys[0], mut.changeSpec);
+                        }
+                        else {
+                            yield table.where(':id').anyOf(keys).modify(mut.changeSpec);
+                        }
+                        break;
+                    case 'update':
+                        yield bulkUpdate(table, keys, mut.changeSpecs);
+                        break;
+                    case 'delete':
+                        yield table.bulkDelete(keys);
+                        break;
+                }
+            }
+        }
+    });
+}
+
+const CURRENT_SYNC_WORKER = 'currentSyncWorker';
+function sync(db, options, schema, syncOptions) {
+    return _sync
+        .apply(this, arguments)
+        .then(() => {
+        if (!(syncOptions === null || syncOptions === void 0 ? void 0 : syncOptions.justCheckIfNeeded)) {
+            db.syncStateChangedEvent.next({
                 phase: 'in-sync',
             });
         }
     })
-        .catch(async (error) => {
-        if (syncOptions?.justCheckIfNeeded)
+        .catch((error) => __awaiter$1(this, void 0, void 0, function* () {
+        if (syncOptions === null || syncOptions === void 0 ? void 0 : syncOptions.justCheckIfNeeded)
             return Promise.reject(error); // Just rethrow.
         console.debug('Error from _sync', {
             isOnline,
@@ -3278,23 +3324,20 @@ function sync(db, options, schema, syncOptions) {
             error,
         });
         if (isOnline &&
-            syncOptions?.retryImmediatelyOnFetchError &&
-            error?.name === 'TypeError' &&
-            /fetch/.test(error?.message)) {
+            (syncOptions === null || syncOptions === void 0 ? void 0 : syncOptions.retryImmediatelyOnFetchError) &&
+            (error === null || error === void 0 ? void 0 : error.name) === 'TypeError' &&
+            /fetch/.test(error === null || error === void 0 ? void 0 : error.message)) {
             db.syncStateChangedEvent.next({
                 phase: 'error',
                 error,
             });
             // Retry again in 500 ms but if it fails again, don't retry.
-            await new Promise((resolve) => setTimeout(resolve, 500));
-            return await sync(db, options, schema, {
-                ...syncOptions,
-                retryImmediatelyOnFetchError: false,
-            });
+            yield new Promise((resolve) => setTimeout(resolve, 500));
+            return yield sync(db, options, schema, Object.assign(Object.assign({}, syncOptions), { retryImmediatelyOnFetchError: false }));
         }
         // Make sure that no matter whether sync() explodes or not,
         // always update the timestamp. Also store the error.
-        await db.$syncState.update('syncState', {
+        yield db.$syncState.update('syncState', {
             timestamp: new Date(),
             error: '' + error,
         });
@@ -3303,234 +3346,239 @@ function sync(db, options, schema, syncOptions) {
             error,
         });
         return Promise.reject(error);
-    });
+    }));
 }
-async function _sync(db, options, schema, { isInitialSync, cancelToken, justCheckIfNeeded, purpose } = {
+function _sync(db, options, schema, { isInitialSync, cancelToken, justCheckIfNeeded, purpose } = {
     isInitialSync: false,
 }) {
-    if (!justCheckIfNeeded) {
-        console.debug('SYNC STARTED', { isInitialSync, purpose });
-    }
-    if (!db.cloud.options?.databaseUrl)
-        throw new Error(`Internal error: sync must not be called when no databaseUrl is configured`);
-    const { databaseUrl } = options;
-    const currentUser = await db.getCurrentUser(); // Keep same value across entire sync flow:
-    const tablesToSync = currentUser.isLoggedIn ? getSyncableTables(db) : [];
-    const mutationTables = tablesToSync.map((tbl) => db.table(getMutationTable(tbl.name)));
-    // If this is not the initial sync,
-    // go through tables that were previously not synced but should now be according to
-    // logged in state and the sync table whitelist in db.cloud.options.
-    //
-    // Prepare for syncification by modifying locally unauthorized objects:
-    //
-    const persistedSyncState = await db.getPersistedSyncState();
-    const tablesToSyncify = !isInitialSync && currentUser.isLoggedIn
-        ? getTablesToSyncify(db, persistedSyncState)
-        : [];
-    throwIfCancelled(cancelToken);
-    const doSyncify = tablesToSyncify.length > 0;
-    if (doSyncify) {
-        if (justCheckIfNeeded)
-            return true;
-        //console.debug('sync doSyncify is true');
-        await db.transaction('rw', tablesToSyncify, async (tx) => {
-            // @ts-ignore
-            tx.idbtrans.disableChangeTracking = true;
-            // @ts-ignore
-            tx.idbtrans.disableAccessControl = true; // TODO: Take care of this flag in access control middleware!
-            await modifyLocalObjectsWithNewUserId(tablesToSyncify, currentUser, persistedSyncState?.realms);
-        });
-        throwIfCancelled(cancelToken);
-    }
-    //
-    // List changes to sync
-    //
-    const [clientChangeSet, syncState, baseRevs] = await db.transaction('r', db.tables, async () => {
-        const syncState = await db.getPersistedSyncState();
-        const baseRevs = await db.$baseRevs.toArray();
-        let clientChanges = await listClientChanges(mutationTables);
+    var _a;
+    return __awaiter$1(this, void 0, void 0, function* () {
+        if (!justCheckIfNeeded) {
+            console.debug('SYNC STARTED', { isInitialSync, purpose });
+        }
+        if (!((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.databaseUrl))
+            throw new Error(`Internal error: sync must not be called when no databaseUrl is configured`);
+        const { databaseUrl } = options;
+        const currentUser = yield db.getCurrentUser(); // Keep same value across entire sync flow:
+        const tablesToSync = currentUser.isLoggedIn ? getSyncableTables(db) : [];
+        const mutationTables = tablesToSync.map((tbl) => db.table(getMutationTable(tbl.name)));
+        // If this is not the initial sync,
+        // go through tables that were previously not synced but should now be according to
+        // logged in state and the sync table whitelist in db.cloud.options.
+        //
+        // Prepare for syncification by modifying locally unauthorized objects:
+        //
+        const persistedSyncState = yield db.getPersistedSyncState();
+        const tablesToSyncify = !isInitialSync && currentUser.isLoggedIn
+            ? getTablesToSyncify(db, persistedSyncState)
+            : [];
         throwIfCancelled(cancelToken);
+        const doSyncify = tablesToSyncify.length > 0;
         if (doSyncify) {
-            const alreadySyncedRealms = [
-                ...(persistedSyncState?.realms || []),
-                ...(persistedSyncState?.inviteRealms || []),
-            ];
-            const syncificationInserts = await listSyncifiedChanges(tablesToSyncify, currentUser, schema, alreadySyncedRealms);
+            if (justCheckIfNeeded)
+                return true;
+            //console.debug('sync doSyncify is true');
+            yield db.transaction('rw', tablesToSyncify, (tx) => __awaiter$1(this, void 0, void 0, function* () {
+                // @ts-ignore
+                tx.idbtrans.disableChangeTracking = true;
+                // @ts-ignore
+                tx.idbtrans.disableAccessControl = true; // TODO: Take care of this flag in access control middleware!
+                yield modifyLocalObjectsWithNewUserId(tablesToSyncify, currentUser, persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.realms);
+            }));
             throwIfCancelled(cancelToken);
-            clientChanges = clientChanges.concat(syncificationInserts);
-            return [clientChanges, syncState, baseRevs];
         }
-        return [clientChanges, syncState, baseRevs];
-    });
-    const syncIsNeeded = clientChangeSet.some((set) => set.muts.some((mut) => mut.keys.length > 0));
-    if (justCheckIfNeeded) {
-        console.debug('Sync is needed:', syncIsNeeded);
-        return syncIsNeeded;
-    }
-    if (purpose === 'push' && !syncIsNeeded) {
-        // The purpose of this request was to push changes
-        return false;
-    }
-    const latestRevisions = getLatestRevisionsPerTable(clientChangeSet, syncState?.latestRevisions);
-    const clientIdentity = syncState?.clientIdentity || randomString(16);
-    //
-    // Push changes to server
-    //
-    throwIfCancelled(cancelToken);
-    const res = await syncWithServer(clientChangeSet, syncState, baseRevs, db, databaseUrl, schema, clientIdentity, currentUser);
-    console.debug('Sync response', res);
-    //
-    // Apply changes locally and clear old change entries:
-    //
-    const done = await db.transaction('rw', db.tables, async (tx) => {
-        // @ts-ignore
-        tx.idbtrans.disableChangeTracking = true;
-        // @ts-ignore
-        tx.idbtrans.disableAccessControl = true; // TODO: Take care of this flag in access control middleware!
-        // Update db.cloud.schema from server response.
-        // Local schema MAY include a subset of tables, so do not force all tables into local schema.
-        for (const tableName of Object.keys(schema)) {
-            if (res.schema[tableName]) {
-                // Write directly into configured schema. This code can only be executed alone.
-                schema[tableName] = res.schema[tableName];
-            }
-        }
-        await db.$syncState.put(schema, 'schema');
-        // List mutations that happened during our exchange with the server:
-        const addedClientChanges = await listClientChanges(mutationTables, db, {
-            since: latestRevisions,
-        });
         //
-        // Delete changes now as server has return success
-        // (but keep changes that haven't reached server yet)
+        // List changes to sync
         //
-        for (const mutTable of mutationTables) {
-            const tableName = getTableFromMutationTable(mutTable.name);
-            if (!addedClientChanges.some((ch) => ch.table === tableName && ch.muts.length > 0)) {
-                // No added mutations for this table during the time we sent changes
-                // to the server.
-                // It is therefore safe to clear all changes (which is faster than
-                // deleting a range)
-                await Promise.all([
-                    mutTable.clear(),
-                    db.$baseRevs.where({ tableName }).delete(),
-                ]);
-            }
-            else if (latestRevisions[tableName]) {
-                const latestRev = latestRevisions[tableName] || 0;
-                await Promise.all([
-                    mutTable.where('rev').belowOrEqual(latestRev).delete(),
-                    db.$baseRevs
-                        .where(':id')
-                        .between([tableName, -Infinity], [tableName, latestRev + 1], true, true)
-                        .reverse()
-                        .offset(1) // Keep one entry (the one mapping muts that came during fetch --> previous server revision)
-                        .delete(),
-                ]);
+        const [clientChangeSet, syncState, baseRevs] = yield db.transaction('r', db.tables, () => __awaiter$1(this, void 0, void 0, function* () {
+            const syncState = yield db.getPersistedSyncState();
+            const baseRevs = yield db.$baseRevs.toArray();
+            let clientChanges = yield listClientChanges(mutationTables);
+            throwIfCancelled(cancelToken);
+            if (doSyncify) {
+                const alreadySyncedRealms = [
+                    ...((persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.realms) || []),
+                    ...((persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.inviteRealms) || []),
+                ];
+                const syncificationInserts = yield listSyncifiedChanges(tablesToSyncify, currentUser, schema, alreadySyncedRealms);
+                throwIfCancelled(cancelToken);
+                clientChanges = clientChanges.concat(syncificationInserts);
+                return [clientChanges, syncState, baseRevs];
             }
-            else ;
-        }
-        // Update latestRevisions object according to additional changes:
-        getLatestRevisionsPerTable(addedClientChanges, latestRevisions);
-        // Update/add new entries into baseRevs map.
-        // * On tables without mutations since last serverRevision,
-        //   this will update existing entry.
-        // * On tables where mutations have been recorded since last
-        //   serverRevision, this will create a new entry.
-        // The purpose of this operation is to mark a start revision (per table)
-        // so that all client-mutations that come after this, will be mapped to current
-        // server revision.
-        await updateBaseRevs(db, schema, latestRevisions, res.serverRevision);
-        const syncState = await db.getPersistedSyncState();
-        //
-        // Delete objects from removed realms
-        //
-        await deleteObjectsFromRemovedRealms(db, res, syncState);
-        //
-        // Update syncState
-        //
-        const newSyncState = syncState || {
-            syncedTables: [],
-            latestRevisions: {},
-            realms: [],
-            inviteRealms: [],
-            clientIdentity,
-        };
-        newSyncState.syncedTables = tablesToSync
-            .map((tbl) => tbl.name)
-            .concat(tablesToSyncify.map((tbl) => tbl.name));
-        newSyncState.latestRevisions = latestRevisions;
-        newSyncState.remoteDbId = res.dbId;
-        newSyncState.initiallySynced = true;
-        newSyncState.realms = res.realms;
-        newSyncState.inviteRealms = res.inviteRealms;
-        newSyncState.serverRevision = res.serverRevision;
-        newSyncState.timestamp = new Date();
-        delete newSyncState.error;
-        const filteredChanges = filterServerChangesThroughAddedClientChanges(res.changes, addedClientChanges);
+            return [clientChanges, syncState, baseRevs];
+        }));
+        const syncIsNeeded = clientChangeSet.some((set) => set.muts.some((mut) => mut.keys.length > 0));
+        if (justCheckIfNeeded) {
+            console.debug('Sync is needed:', syncIsNeeded);
+            return syncIsNeeded;
+        }
+        if (purpose === 'push' && !syncIsNeeded) {
+            // The purpose of this request was to push changes
+            return false;
+        }
+        const latestRevisions = getLatestRevisionsPerTable(clientChangeSet, syncState === null || syncState === void 0 ? void 0 : syncState.latestRevisions);
+        const clientIdentity = (syncState === null || syncState === void 0 ? void 0 : syncState.clientIdentity) || randomString(16);
         //
-        // apply server changes
+        // Push changes to server
         //
-        await applyServerChanges(filteredChanges, db);
+        throwIfCancelled(cancelToken);
+        const res = yield syncWithServer(clientChangeSet, syncState, baseRevs, db, databaseUrl, schema, clientIdentity, currentUser);
+        console.debug('Sync response', res);
         //
-        // Update syncState
+        // Apply changes locally and clear old change entries:
         //
-        db.$syncState.put(newSyncState, 'syncState');
-        return addedClientChanges.length === 0;
+        const done = yield db.transaction('rw', db.tables, (tx) => __awaiter$1(this, void 0, void 0, function* () {
+            // @ts-ignore
+            tx.idbtrans.disableChangeTracking = true;
+            // @ts-ignore
+            tx.idbtrans.disableAccessControl = true; // TODO: Take care of this flag in access control middleware!
+            // Update db.cloud.schema from server response.
+            // Local schema MAY include a subset of tables, so do not force all tables into local schema.
+            for (const tableName of Object.keys(schema)) {
+                if (res.schema[tableName]) {
+                    // Write directly into configured schema. This code can only be executed alone.
+                    schema[tableName] = res.schema[tableName];
+                }
+            }
+            yield db.$syncState.put(schema, 'schema');
+            // List mutations that happened during our exchange with the server:
+            const addedClientChanges = yield listClientChanges(mutationTables, db, {
+                since: latestRevisions,
+            });
+            //
+            // Delete changes now as server has return success
+            // (but keep changes that haven't reached server yet)
+            //
+            for (const mutTable of mutationTables) {
+                const tableName = getTableFromMutationTable(mutTable.name);
+                if (!addedClientChanges.some((ch) => ch.table === tableName && ch.muts.length > 0)) {
+                    // No added mutations for this table during the time we sent changes
+                    // to the server.
+                    // It is therefore safe to clear all changes (which is faster than
+                    // deleting a range)
+                    yield Promise.all([
+                        mutTable.clear(),
+                        db.$baseRevs.where({ tableName }).delete(),
+                    ]);
+                }
+                else if (latestRevisions[tableName]) {
+                    const latestRev = latestRevisions[tableName] || 0;
+                    yield Promise.all([
+                        mutTable.where('rev').belowOrEqual(latestRev).delete(),
+                        db.$baseRevs
+                            .where(':id')
+                            .between([tableName, -Infinity], [tableName, latestRev + 1], true, true)
+                            .reverse()
+                            .offset(1) // Keep one entry (the one mapping muts that came during fetch --> previous server revision)
+                            .delete(),
+                    ]);
+                }
+                else ;
+            }
+            // Update latestRevisions object according to additional changes:
+            getLatestRevisionsPerTable(addedClientChanges, latestRevisions);
+            // Update/add new entries into baseRevs map.
+            // * On tables without mutations since last serverRevision,
+            //   this will update existing entry.
+            // * On tables where mutations have been recorded since last
+            //   serverRevision, this will create a new entry.
+            // The purpose of this operation is to mark a start revision (per table)
+            // so that all client-mutations that come after this, will be mapped to current
+            // server revision.
+            yield updateBaseRevs(db, schema, latestRevisions, res.serverRevision);
+            const syncState = yield db.getPersistedSyncState();
+            //
+            // Delete objects from removed realms
+            //
+            yield deleteObjectsFromRemovedRealms(db, res, syncState);
+            //
+            // Update syncState
+            //
+            const newSyncState = syncState || {
+                syncedTables: [],
+                latestRevisions: {},
+                realms: [],
+                inviteRealms: [],
+                clientIdentity,
+            };
+            newSyncState.syncedTables = tablesToSync
+                .map((tbl) => tbl.name)
+                .concat(tablesToSyncify.map((tbl) => tbl.name));
+            newSyncState.latestRevisions = latestRevisions;
+            newSyncState.remoteDbId = res.dbId;
+            newSyncState.initiallySynced = true;
+            newSyncState.realms = res.realms;
+            newSyncState.inviteRealms = res.inviteRealms;
+            newSyncState.serverRevision = res.serverRevision;
+            newSyncState.timestamp = new Date();
+            delete newSyncState.error;
+            const filteredChanges = filterServerChangesThroughAddedClientChanges(res.changes, addedClientChanges);
+            //
+            // apply server changes
+            //
+            yield applyServerChanges(filteredChanges, db);
+            //
+            // Update syncState
+            //
+            db.$syncState.put(newSyncState, 'syncState');
+            return addedClientChanges.length === 0;
+        }));
+        if (!done) {
+            console.debug('MORE SYNC NEEDED. Go for it again!');
+            return yield _sync(db, options, schema, { isInitialSync, cancelToken });
+        }
+        console.debug('SYNC DONE', { isInitialSync });
+        return false; // Not needed anymore
     });
-    if (!done) {
-        console.debug('MORE SYNC NEEDED. Go for it again!');
-        return await _sync(db, options, schema, { isInitialSync, cancelToken });
-    }
-    console.debug('SYNC DONE', { isInitialSync });
-    return false; // Not needed anymore
-}
-async function deleteObjectsFromRemovedRealms(db, res, prevState) {
-    const deletedRealms = new Set();
-    const rejectedRealms = new Set();
-    const previousRealmSet = prevState ? prevState.realms : [];
-    const previousInviteRealmSet = prevState ? prevState.inviteRealms : [];
-    const updatedRealmSet = new Set(res.realms);
-    const updatedTotalRealmSet = new Set(res.realms.concat(res.inviteRealms));
-    for (const realmId of previousRealmSet) {
-        if (!updatedRealmSet.has(realmId)) {
-            rejectedRealms.add(realmId);
+}
+function deleteObjectsFromRemovedRealms(db, res, prevState) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        const deletedRealms = new Set();
+        const rejectedRealms = new Set();
+        const previousRealmSet = prevState ? prevState.realms : [];
+        const previousInviteRealmSet = prevState ? prevState.inviteRealms : [];
+        const updatedRealmSet = new Set(res.realms);
+        const updatedTotalRealmSet = new Set(res.realms.concat(res.inviteRealms));
+        for (const realmId of previousRealmSet) {
+            if (!updatedRealmSet.has(realmId)) {
+                rejectedRealms.add(realmId);
+                if (!updatedTotalRealmSet.has(realmId)) {
+                    deletedRealms.add(realmId);
+                }
+            }
+        }
+        for (const realmId of previousInviteRealmSet.concat(previousRealmSet)) {
             if (!updatedTotalRealmSet.has(realmId)) {
                 deletedRealms.add(realmId);
             }
         }
-    }
-    for (const realmId of previousInviteRealmSet.concat(previousRealmSet)) {
-        if (!updatedTotalRealmSet.has(realmId)) {
-            deletedRealms.add(realmId);
-        }
-    }
-    if (deletedRealms.size > 0 || rejectedRealms.size > 0) {
-        const tables = getSyncableTables(db);
-        for (const table of tables) {
-            let realmsToDelete = ['realms', 'members', 'roles'].includes(table.name)
-                ? deletedRealms // These tables should spare rejected ones.
-                : rejectedRealms; // All other tables shoudl delete rejected+deleted ones
-            if (realmsToDelete.size === 0)
-                continue;
-            if (table.schema.indexes.some((idx) => idx.keyPath === 'realmId' ||
-                (Array.isArray(idx.keyPath) && idx.keyPath[0] === 'realmId'))) {
-                // There's an index to use:
-                //console.debug(`REMOVAL: deleting all ${table.name} where realmId anyOf `, JSON.stringify([...realmsToDelete]));
-                await table
-                    .where('realmId')
-                    .anyOf([...realmsToDelete])
-                    .delete();
-            }
-            else {
-                // No index to use:
-                //console.debug(`REMOVAL: deleting all ${table.name} where realmId is any of `, JSON.stringify([...realmsToDelete]), realmsToDelete.size);
-                await table
-                    .filter((obj) => !!obj?.realmId && realmsToDelete.has(obj.realmId))
-                    .delete();
+        if (deletedRealms.size > 0 || rejectedRealms.size > 0) {
+            const tables = getSyncableTables(db);
+            for (const table of tables) {
+                let realmsToDelete = ['realms', 'members', 'roles'].includes(table.name)
+                    ? deletedRealms // These tables should spare rejected ones.
+                    : rejectedRealms; // All other tables shoudl delete rejected+deleted ones
+                if (realmsToDelete.size === 0)
+                    continue;
+                if (table.schema.indexes.some((idx) => idx.keyPath === 'realmId' ||
+                    (Array.isArray(idx.keyPath) && idx.keyPath[0] === 'realmId'))) {
+                    // There's an index to use:
+                    //console.debug(`REMOVAL: deleting all ${table.name} where realmId anyOf `, JSON.stringify([...realmsToDelete]));
+                    yield table
+                        .where('realmId')
+                        .anyOf([...realmsToDelete])
+                        .delete();
+                }
+                else {
+                    // No index to use:
+                    //console.debug(`REMOVAL: deleting all ${table.name} where realmId is any of `, JSON.stringify([...realmsToDelete]), realmsToDelete.size);
+                    yield table
+                        .filter((obj) => !!(obj === null || obj === void 0 ? void 0 : obj.realmId) && realmsToDelete.has(obj.realmId))
+                        .delete();
+                }
             }
         }
-    }
+    });
 }
 function filterServerChangesThroughAddedClientChanges(serverChanges, addedClientChanges) {
     const changes = {};
@@ -3548,7 +3596,7 @@ function MessagesFromServerConsumer(db) {
     let isWorking = false;
     let loopWarning = 0;
     let loopDetection = [0, 0, 0, 0, 0, 0, 0, 0, 0, Date.now()];
-    event.subscribe(async () => {
+    event.subscribe(() => __awaiter$1(this, void 0, void 0, function* () {
         if (isWorking)
             return;
         if (queue.length > 0) {
@@ -3557,7 +3605,7 @@ function MessagesFromServerConsumer(db) {
             loopDetection.push(Date.now());
             readyToServe.next(false);
             try {
-                await consumeQueue();
+                yield consumeQueue();
             }
             finally {
                 if (loopDetection[loopDetection.length - 1] - loopDetection[0] <
@@ -3567,170 +3615,173 @@ function MessagesFromServerConsumer(db) {
                         // Last time we did this, we ended up here too. Wait for a minute.
                         console.warn(`Slowing down websocket loop for one minute`);
                         loopWarning = Date.now() + 60000;
-                        await new Promise((resolve) => setTimeout(resolve, 60000));
+                        yield new Promise((resolve) => setTimeout(resolve, 60000));
                     }
                     else {
                         // This is a one-time event. Just pause 10 seconds.
                         console.warn(`Slowing down websocket loop for 10 seconds`);
                         loopWarning = Date.now() + 10000;
-                        await new Promise((resolve) => setTimeout(resolve, 10000));
+                        yield new Promise((resolve) => setTimeout(resolve, 10000));
                     }
                 }
                 isWorking = false;
                 readyToServe.next(true);
             }
         }
-    });
+    }));
     function enqueue(msg) {
         queue.push(msg);
         event.next(null);
     }
-    async function consumeQueue() {
-        while (queue.length > 0) {
-            const msg = queue.shift();
-            try {
-                // If the sync worker or service worker is syncing, wait 'til thei're done.
-                // It's no need to have two channels at the same time - even though it wouldnt
-                // be a problem - this is an optimization.
-                await db.cloud.syncState
-                    .pipe(filter(({ phase }) => phase === 'in-sync' || phase === 'error'), take(1))
-                    .toPromise();
-                console.debug('processing msg', msg);
-                const persistedSyncState = db.cloud.persistedSyncState.value;
-                //syncState.
-                if (!msg)
-                    continue;
-                switch (msg.type) {
-                    case 'token-expired':
-                        console.debug('WebSocket observable: Token expired. Refreshing token...');
-                        const user = db.cloud.currentUser.value;
-                        // Refresh access token
-                        const refreshedLogin = await refreshAccessToken(db.cloud.options.databaseUrl, user);
-                        // Persist updated access token
-                        await db.table('$logins').update(user.userId, {
-                            accessToken: refreshedLogin.accessToken,
-                            accessTokenExpiration: refreshedLogin.accessTokenExpiration,
-                        });
-                        // Updating $logins will trigger emission of db.cloud.currentUser observable, which
-                        // in turn will lead to that connectWebSocket.ts will reconnect the socket with the
-                        // new token. So we don't need to do anything more here.
-                        break;
-                    case 'realm-added':
-                        //if (!persistedSyncState?.realms?.includes(msg.realm) && !persistedSyncState?.inviteRealms?.includes(msg.realm)) {
-                        triggerSync(db, 'pull');
-                        //}
-                        break;
-                    case 'realm-accepted':
-                        //if (!persistedSyncState?.realms?.includes(msg.realm)) {
-                        triggerSync(db, 'pull');
-                        //}
-                        break;
-                    case 'realm-removed':
-                        //if (
-                        persistedSyncState?.realms?.includes(msg.realm) ||
-                            persistedSyncState?.inviteRealms?.includes(msg.realm);
-                        //) {
-                        triggerSync(db, 'pull');
-                        //}
-                        break;
-                    case 'realms-changed':
-                        triggerSync(db, 'pull');
-                        break;
-                    case 'changes':
-                        console.debug('changes');
-                        if (db.cloud.syncState.value?.phase === 'error') {
+    function consumeQueue() {
+        var _a, _b, _c;
+        return __awaiter$1(this, void 0, void 0, function* () {
+            while (queue.length > 0) {
+                const msg = queue.shift();
+                try {
+                    // If the sync worker or service worker is syncing, wait 'til thei're done.
+                    // It's no need to have two channels at the same time - even though it wouldnt
+                    // be a problem - this is an optimization.
+                    yield db.cloud.syncState
+                        .pipe(filter(({ phase }) => phase === 'in-sync' || phase === 'error'), take(1))
+                        .toPromise();
+                    console.debug('processing msg', msg);
+                    const persistedSyncState = db.cloud.persistedSyncState.value;
+                    //syncState.
+                    if (!msg)
+                        continue;
+                    switch (msg.type) {
+                        case 'token-expired':
+                            console.debug('WebSocket observable: Token expired. Refreshing token...');
+                            const user = db.cloud.currentUser.value;
+                            // Refresh access token
+                            const refreshedLogin = yield refreshAccessToken(db.cloud.options.databaseUrl, user);
+                            // Persist updated access token
+                            yield db.table('$logins').update(user.userId, {
+                                accessToken: refreshedLogin.accessToken,
+                                accessTokenExpiration: refreshedLogin.accessTokenExpiration,
+                            });
+                            // Updating $logins will trigger emission of db.cloud.currentUser observable, which
+                            // in turn will lead to that connectWebSocket.ts will reconnect the socket with the
+                            // new token. So we don't need to do anything more here.
+                            break;
+                        case 'realm-added':
+                            //if (!persistedSyncState?.realms?.includes(msg.realm) && !persistedSyncState?.inviteRealms?.includes(msg.realm)) {
                             triggerSync(db, 'pull');
+                            //}
                             break;
-                        }
-                        await db.transaction('rw', db.dx.tables, async (tx) => {
-                            // @ts-ignore
-                            tx.idbtrans.disableChangeTracking = true;
-                            // @ts-ignore
-                            tx.idbtrans.disableAccessControl = true;
-                            const [schema, syncState, currentUser] = await Promise.all([
-                                db.getSchema(),
-                                db.getPersistedSyncState(),
-                                db.getCurrentUser(),
-                            ]);
-                            console.debug('ws message queue: in transaction');
-                            if (!syncState || !schema || !currentUser) {
-                                console.debug('required vars not present', {
-                                    syncState,
-                                    schema,
-                                    currentUser,
-                                });
-                                return; // Initial sync must have taken place - otherwise, ignore this.
+                        case 'realm-accepted':
+                            //if (!persistedSyncState?.realms?.includes(msg.realm)) {
+                            triggerSync(db, 'pull');
+                            //}
+                            break;
+                        case 'realm-removed':
+                            //if (
+                            ((_a = persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.realms) === null || _a === void 0 ? void 0 : _a.includes(msg.realm)) ||
+                                ((_b = persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.inviteRealms) === null || _b === void 0 ? void 0 : _b.includes(msg.realm));
+                            //) {
+                            triggerSync(db, 'pull');
+                            //}
+                            break;
+                        case 'realms-changed':
+                            triggerSync(db, 'pull');
+                            break;
+                        case 'changes':
+                            console.debug('changes');
+                            if (((_c = db.cloud.syncState.value) === null || _c === void 0 ? void 0 : _c.phase) === 'error') {
+                                triggerSync(db, 'pull');
+                                break;
                             }
-                            // Verify again in ACID tx that we're on same server revision.
-                            if (msg.baseRev !== syncState.serverRevision) {
-                                console.debug(`baseRev (${msg.baseRev}) differs from our serverRevision in syncState (${syncState.serverRevision})`);
-                                // Should we trigger a sync now? No. This is a normal case
-                                // when another local peer (such as the SW or a websocket channel on other tab) has
-                                // updated syncState from new server information but we are not aware yet. It would
-                                // be unnescessary to do a sync in that case. Instead, the caller of this consumeQueue()
-                                // function will do readyToServe.next(true) right after this return, which will lead
-                                // to a "ready" message being sent to server with the new accurate serverRev we have,
-                                // so that the next message indeed will be correct.
-                                if (typeof msg.baseRev === 'string' && // v2 format
-                                    (typeof syncState.serverRevision === 'bigint' || // v1 format
-                                        typeof syncState.serverRevision === 'object') // v1 format old browser
-                                ) {
-                                    // The reason for the diff seems to be that server has migrated the revision format.
-                                    // Do a full sync to update revision format.
-                                    // If we don't do a sync request now, we could stuck in an endless loop.
+                            yield db.transaction('rw', db.dx.tables, (tx) => __awaiter$1(this, void 0, void 0, function* () {
+                                // @ts-ignore
+                                tx.idbtrans.disableChangeTracking = true;
+                                // @ts-ignore
+                                tx.idbtrans.disableAccessControl = true;
+                                const [schema, syncState, currentUser] = yield Promise.all([
+                                    db.getSchema(),
+                                    db.getPersistedSyncState(),
+                                    db.getCurrentUser(),
+                                ]);
+                                console.debug('ws message queue: in transaction');
+                                if (!syncState || !schema || !currentUser) {
+                                    console.debug('required vars not present', {
+                                        syncState,
+                                        schema,
+                                        currentUser,
+                                    });
+                                    return; // Initial sync must have taken place - otherwise, ignore this.
+                                }
+                                // Verify again in ACID tx that we're on same server revision.
+                                if (msg.baseRev !== syncState.serverRevision) {
+                                    console.debug(`baseRev (${msg.baseRev}) differs from our serverRevision in syncState (${syncState.serverRevision})`);
+                                    // Should we trigger a sync now? No. This is a normal case
+                                    // when another local peer (such as the SW or a websocket channel on other tab) has
+                                    // updated syncState from new server information but we are not aware yet. It would
+                                    // be unnescessary to do a sync in that case. Instead, the caller of this consumeQueue()
+                                    // function will do readyToServe.next(true) right after this return, which will lead
+                                    // to a "ready" message being sent to server with the new accurate serverRev we have,
+                                    // so that the next message indeed will be correct.
+                                    if (typeof msg.baseRev === 'string' && // v2 format
+                                        (typeof syncState.serverRevision === 'bigint' || // v1 format
+                                            typeof syncState.serverRevision === 'object') // v1 format old browser
+                                    ) {
+                                        // The reason for the diff seems to be that server has migrated the revision format.
+                                        // Do a full sync to update revision format.
+                                        // If we don't do a sync request now, we could stuck in an endless loop.
+                                        triggerSync(db, 'pull');
+                                    }
+                                    return; // Ignore message
+                                }
+                                // Verify also that the message is based on the exact same set of realms
+                                const ourRealmSetHash = yield Dexie.waitFor(
+                                // Keep TX in non-IDB work
+                                computeRealmSetHash(syncState));
+                                console.debug('ourRealmSetHash', ourRealmSetHash);
+                                if (ourRealmSetHash !== msg.realmSetHash) {
+                                    console.debug('not same realmSetHash', msg.realmSetHash);
                                     triggerSync(db, 'pull');
+                                    // The message isn't based on the same realms.
+                                    // Trigger a sync instead to resolve all things up.
+                                    return;
                                 }
-                                return; // Ignore message
-                            }
-                            // Verify also that the message is based on the exact same set of realms
-                            const ourRealmSetHash = await Dexie.waitFor(
-                            // Keep TX in non-IDB work
-                            computeRealmSetHash(syncState));
-                            console.debug('ourRealmSetHash', ourRealmSetHash);
-                            if (ourRealmSetHash !== msg.realmSetHash) {
-                                console.debug('not same realmSetHash', msg.realmSetHash);
-                                triggerSync(db, 'pull');
-                                // The message isn't based on the same realms.
-                                // Trigger a sync instead to resolve all things up.
-                                return;
-                            }
-                            // Get clientChanges
-                            let clientChanges = [];
-                            if (currentUser.isLoggedIn) {
-                                const mutationTables = getSyncableTables(db).map((tbl) => db.table(getMutationTable(tbl.name)));
-                                clientChanges = await listClientChanges(mutationTables, db);
-                                console.debug('msg queue: client changes', clientChanges);
-                            }
-                            if (msg.changes.length > 0) {
-                                const filteredChanges = filterServerChangesThroughAddedClientChanges(msg.changes, clientChanges);
+                                // Get clientChanges
+                                let clientChanges = [];
+                                if (currentUser.isLoggedIn) {
+                                    const mutationTables = getSyncableTables(db).map((tbl) => db.table(getMutationTable(tbl.name)));
+                                    clientChanges = yield listClientChanges(mutationTables, db);
+                                    console.debug('msg queue: client changes', clientChanges);
+                                }
+                                if (msg.changes.length > 0) {
+                                    const filteredChanges = filterServerChangesThroughAddedClientChanges(msg.changes, clientChanges);
+                                    //
+                                    // apply server changes
+                                    //
+                                    console.debug('applying filtered server changes', filteredChanges);
+                                    yield applyServerChanges(filteredChanges, db);
+                                }
+                                // Update latest revisions per table in case there are unsynced changes
+                                // This can be a real case in future when we allow non-eagery sync.
+                                // And it can actually be realistic now also, but very rare.
+                                syncState.latestRevisions = getLatestRevisionsPerTable(clientChanges, syncState.latestRevisions);
+                                syncState.serverRevision = msg.newRev;
+                                // Update base revs
+                                console.debug('Updating baseRefs', syncState.latestRevisions);
+                                yield updateBaseRevs(db, schema, syncState.latestRevisions, msg.newRev);
                                 //
-                                // apply server changes
+                                // Update syncState
                                 //
-                                console.debug('applying filtered server changes', filteredChanges);
-                                await applyServerChanges(filteredChanges, db);
-                            }
-                            // Update latest revisions per table in case there are unsynced changes
-                            // This can be a real case in future when we allow non-eagery sync.
-                            // And it can actually be realistic now also, but very rare.
-                            syncState.latestRevisions = getLatestRevisionsPerTable(clientChanges, syncState.latestRevisions);
-                            syncState.serverRevision = msg.newRev;
-                            // Update base revs
-                            console.debug('Updating baseRefs', syncState.latestRevisions);
-                            await updateBaseRevs(db, schema, syncState.latestRevisions, msg.newRev);
-                            //
-                            // Update syncState
-                            //
-                            console.debug('Updating syncState', syncState);
-                            await db.$syncState.put(syncState, 'syncState');
-                        });
-                        console.debug('msg queue: done with rw transaction');
-                        break;
+                                console.debug('Updating syncState', syncState);
+                                yield db.$syncState.put(syncState, 'syncState');
+                            }));
+                            console.debug('msg queue: done with rw transaction');
+                            break;
+                    }
+                }
+                catch (error) {
+                    console.error(`Error in msg queue`, error);
                 }
             }
-            catch (error) {
-                console.error(`Error in msg queue`, error);
-            }
-        }
+        });
     }
     return {
         enqueue,
@@ -3849,100 +3900,105 @@ class AuthPersistedContext {
             lastLogin: new Date(0)
         }));
     }
-    async save() {
-        const db = wm.get(this);
-        db.table("$logins").put(this);
+    save() {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            const db = wm.get(this);
+            db.table("$logins").put(this);
+        });
     }
 }
 
 function otpFetchTokenCallback(db) {
     const { userInteraction } = db.cloud;
-    return async function otpAuthenticate({ public_key, hints }) {
-        let tokenRequest;
-        const url = db.cloud.options?.databaseUrl;
-        if (!url)
-            throw new Error(`No database URL given.`);
-        if (hints?.grant_type === 'demo') {
-            const demo_user = await promptForEmail(userInteraction, 'Enter a demo user email', hints?.email || hints?.userId);
-            tokenRequest = {
-                demo_user,
-                grant_type: 'demo',
-                scopes: ['ACCESS_DB'],
-                public_key,
-            };
-        }
-        else {
-            const email = await promptForEmail(userInteraction, 'Enter email address', hints?.email);
-            tokenRequest = {
-                email,
-                grant_type: 'otp',
-                scopes: ['ACCESS_DB'],
-                public_key,
-            };
-        }
-        const res1 = await fetch(`${url}/token`, {
-            body: JSON.stringify(tokenRequest),
-            method: 'post',
-            headers: { 'Content-Type': 'application/json', mode: 'cors' },
-        });
-        if (res1.status !== 200) {
-            const errMsg = await res1.text();
-            await alertUser(userInteraction, "Token request failed", {
-                type: 'error',
-                messageCode: 'GENERIC_ERROR',
-                message: errMsg,
-                messageParams: {}
-            }).catch(() => { });
-            throw new HttpError(res1, errMsg);
-        }
-        const response = await res1.json();
-        if (response.type === 'tokens') {
-            // Demo user request can get a "tokens" response right away
-            return response;
-        }
-        else if (tokenRequest.grant_type === 'otp') {
-            if (response.type !== 'otp-sent')
-                throw new Error(`Unexpected response from ${url}/token`);
-            const otp = await promptForOTP(userInteraction, tokenRequest.email);
-            tokenRequest.otp = otp || '';
-            tokenRequest.otp_id = response.otp_id;
-            let res2 = await fetch(`${url}/token`, {
+    return function otpAuthenticate({ public_key, hints }) {
+        var _a;
+        return __awaiter$1(this, void 0, void 0, function* () {
+            let tokenRequest;
+            const url = (_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.databaseUrl;
+            if (!url)
+                throw new Error(`No database URL given.`);
+            if ((hints === null || hints === void 0 ? void 0 : hints.grant_type) === 'demo') {
+                const demo_user = yield promptForEmail(userInteraction, 'Enter a demo user email', (hints === null || hints === void 0 ? void 0 : hints.email) || (hints === null || hints === void 0 ? void 0 : hints.userId));
+                tokenRequest = {
+                    demo_user,
+                    grant_type: 'demo',
+                    scopes: ['ACCESS_DB'],
+                    public_key,
+                };
+            }
+            else {
+                const email = yield promptForEmail(userInteraction, 'Enter email address', hints === null || hints === void 0 ? void 0 : hints.email);
+                tokenRequest = {
+                    email,
+                    grant_type: 'otp',
+                    scopes: ['ACCESS_DB'],
+                    public_key,
+                };
+            }
+            const res1 = yield fetch(`${url}/token`, {
                 body: JSON.stringify(tokenRequest),
                 method: 'post',
-                headers: { 'Content-Type': 'application/json' },
-                mode: 'cors',
+                headers: { 'Content-Type': 'application/json', mode: 'cors' },
             });
-            while (res2.status === 401) {
-                const errorText = await res2.text();
-                tokenRequest.otp = await promptForOTP(userInteraction, tokenRequest.email, {
+            if (res1.status !== 200) {
+                const errMsg = yield res1.text();
+                yield alertUser(userInteraction, "Token request failed", {
                     type: 'error',
-                    messageCode: 'INVALID_OTP',
-                    message: errorText,
+                    messageCode: 'GENERIC_ERROR',
+                    message: errMsg,
                     messageParams: {}
-                });
-                res2 = await fetch(`${url}/token`, {
+                }).catch(() => { });
+                throw new HttpError(res1, errMsg);
+            }
+            const response = yield res1.json();
+            if (response.type === 'tokens') {
+                // Demo user request can get a "tokens" response right away
+                return response;
+            }
+            else if (tokenRequest.grant_type === 'otp') {
+                if (response.type !== 'otp-sent')
+                    throw new Error(`Unexpected response from ${url}/token`);
+                const otp = yield promptForOTP(userInteraction, tokenRequest.email);
+                tokenRequest.otp = otp || '';
+                tokenRequest.otp_id = response.otp_id;
+                let res2 = yield fetch(`${url}/token`, {
                     body: JSON.stringify(tokenRequest),
                     method: 'post',
                     headers: { 'Content-Type': 'application/json' },
                     mode: 'cors',
                 });
+                while (res2.status === 401) {
+                    const errorText = yield res2.text();
+                    tokenRequest.otp = yield promptForOTP(userInteraction, tokenRequest.email, {
+                        type: 'error',
+                        messageCode: 'INVALID_OTP',
+                        message: errorText,
+                        messageParams: {}
+                    });
+                    res2 = yield fetch(`${url}/token`, {
+                        body: JSON.stringify(tokenRequest),
+                        method: 'post',
+                        headers: { 'Content-Type': 'application/json' },
+                        mode: 'cors',
+                    });
+                }
+                if (res2.status !== 200) {
+                    const errMsg = yield res2.text();
+                    yield alertUser(userInteraction, "OTP Authentication Failed", {
+                        type: 'error',
+                        messageCode: 'GENERIC_ERROR',
+                        message: errMsg,
+                        messageParams: {}
+                    }).catch(() => { });
+                    throw new HttpError(res2, errMsg);
+                }
+                const response2 = yield res2.json();
+                return response2;
             }
-            if (res2.status !== 200) {
-                const errMsg = await res2.text();
-                await alertUser(userInteraction, "OTP Authentication Failed", {
-                    type: 'error',
-                    messageCode: 'GENERIC_ERROR',
-                    message: errMsg,
-                    messageParams: {}
-                }).catch(() => { });
-                throw new HttpError(res2, errMsg);
+            else {
+                throw new Error(`Unexpected response from ${url}/token`);
             }
-            const response2 = await res2.json();
-            return response2;
-        }
-        else {
-            throw new Error(`Unexpected response from ${url}/token`);
-        }
+        });
     };
 }
 
@@ -3957,83 +4013,87 @@ function otpFetchTokenCallback(db) {
  * @param db
  * @param newUser
  */
-async function setCurrentUser(db, user) {
-    if (user.userId === db.cloud.currentUserId)
-        return; // Already this user.
-    const $logins = db.table('$logins');
-    await db.transaction('rw', $logins, async (tx) => {
-        const existingLogins = await $logins.toArray();
-        await Promise.all(existingLogins
-            .filter((login) => login.userId !== user.userId && login.isLoggedIn)
-            .map((login) => {
-            login.isLoggedIn = false;
-            return $logins.put(login);
+function setCurrentUser(db, user) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        if (user.userId === db.cloud.currentUserId)
+            return; // Already this user.
+        const $logins = db.table('$logins');
+        yield db.transaction('rw', $logins, (tx) => __awaiter$1(this, void 0, void 0, function* () {
+            const existingLogins = yield $logins.toArray();
+            yield Promise.all(existingLogins
+                .filter((login) => login.userId !== user.userId && login.isLoggedIn)
+                .map((login) => {
+                login.isLoggedIn = false;
+                return $logins.put(login);
+            }));
+            user.isLoggedIn = true;
+            user.lastLogin = new Date();
+            yield user.save();
+            console.debug('Saved new user', user.email);
         }));
-        user.isLoggedIn = true;
-        user.lastLogin = new Date();
-        await user.save();
-        console.debug('Saved new user', user.email);
+        yield new Promise((resolve) => {
+            if (db.cloud.currentUserId === user.userId) {
+                resolve(null);
+            }
+            else {
+                const subscription = db.cloud.currentUser.subscribe((currentUser) => {
+                    if (currentUser.userId === user.userId) {
+                        subscription.unsubscribe();
+                        resolve(null);
+                    }
+                });
+            }
+        });
+        // TANKAR!!!!
+        // V: Service workern kommer inte ha tillgång till currentUserObservable om den inte istället härrör från ett liveQuery.
+        // V: Samma med andra windows.
+        // V: Så kanske göra om den till att häröra från liveQuery som läser $logins.orderBy('lastLogin').last().
+        // V: Då bara vara medveten om:
+        //    V: En sån observable börjar hämta data vid första subscribe
+        //    V: Vi har inget "inital value" men kan emulera det till att vara ANONYMOUS_USER
+        //    V: Om requireAuth är true, så borde db.on(ready) hålla databasen stängd för alla utom denna observable.
+        //    V: Om inte så behöver den inte blocka.
+        // Andra tankar:
+        //    * Man kan inte byta användare när man är offline. Skulle gå att flytta realms till undanstuff-tabell vid user-change.
+        //      men troligen inte värt det.
+        //    * Istället: sälj inte inte switch-user funktionalitet utan tala enbart om inloggat vs icke inloggat läge.
+        //    * populate $logins med ANONYMOUS så att en påbörjad inloggning inte räknas, alternativt ha en boolean prop!
+        //      Kanske bäst ha en boolean prop!
+        //    * Alternativ switch-user funktionalitet:
+        //      * DBCore gömmer data från realms man inte har tillgång till.
+        //      * Cursor impl behövs också då.
+        //      * Då blir det snabba user switch.
+        //      * claims-settet som skickas till servern blir summan av alla claims. Då måste servern stödja multipla tokens eller
+        //        att ens token är ett samlad.
     });
-    await new Promise((resolve) => {
-        if (db.cloud.currentUserId === user.userId) {
-            resolve(null);
-        }
-        else {
-            const subscription = db.cloud.currentUser.subscribe((currentUser) => {
-                if (currentUser.userId === user.userId) {
-                    subscription.unsubscribe();
-                    resolve(null);
+}
+
+function login(db, hints) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        const currentUser = yield db.getCurrentUser();
+        if (currentUser.isLoggedIn) {
+            if (hints) {
+                if (hints.email && db.cloud.currentUser.value.email !== hints.email) {
+                    throw new Error(`Must logout before changing user`);
                 }
-            });
+                if (hints.userId && db.cloud.currentUserId !== hints.userId) {
+                    throw new Error(`Must logout before changing user`);
+                }
+            }
+            // Already authenticated according to given hints.
+            return;
         }
+        const context = new AuthPersistedContext(db, {
+            claims: {},
+            lastLogin: new Date(0),
+        });
+        yield authenticate(db.cloud.options.databaseUrl, context, db.cloud.options.fetchTokens || otpFetchTokenCallback(db), db.cloud.userInteraction, hints);
+        yield context.save();
+        yield setCurrentUser(db, context);
+        // Make sure to resync as the new login will be authorized
+        // for new realms.
+        triggerSync(db, "pull");
     });
-    // TANKAR!!!!
-    // V: Service workern kommer inte ha tillgång till currentUserObservable om den inte istället härrör från ett liveQuery.
-    // V: Samma med andra windows.
-    // V: Så kanske göra om den till att häröra från liveQuery som läser $logins.orderBy('lastLogin').last().
-    // V: Då bara vara medveten om:
-    //    V: En sån observable börjar hämta data vid första subscribe
-    //    V: Vi har inget "inital value" men kan emulera det till att vara ANONYMOUS_USER
-    //    V: Om requireAuth är true, så borde db.on(ready) hålla databasen stängd för alla utom denna observable.
-    //    V: Om inte så behöver den inte blocka.
-    // Andra tankar:
-    //    * Man kan inte byta användare när man är offline. Skulle gå att flytta realms till undanstuff-tabell vid user-change.
-    //      men troligen inte värt det.
-    //    * Istället: sälj inte inte switch-user funktionalitet utan tala enbart om inloggat vs icke inloggat läge.
-    //    * populate $logins med ANONYMOUS så att en påbörjad inloggning inte räknas, alternativt ha en boolean prop!
-    //      Kanske bäst ha en boolean prop!
-    //    * Alternativ switch-user funktionalitet:
-    //      * DBCore gömmer data från realms man inte har tillgång till.
-    //      * Cursor impl behövs också då.
-    //      * Då blir det snabba user switch.
-    //      * claims-settet som skickas till servern blir summan av alla claims. Då måste servern stödja multipla tokens eller
-    //        att ens token är ett samlad.
-}
-
-async function login(db, hints) {
-    const currentUser = await db.getCurrentUser();
-    if (currentUser.isLoggedIn) {
-        if (hints) {
-            if (hints.email && db.cloud.currentUser.value.email !== hints.email) {
-                throw new Error(`Must logout before changing user`);
-            }
-            if (hints.userId && db.cloud.currentUserId !== hints.userId) {
-                throw new Error(`Must logout before changing user`);
-            }
-        }
-        // Already authenticated according to given hints.
-        return;
-    }
-    const context = new AuthPersistedContext(db, {
-        claims: {},
-        lastLogin: new Date(0),
-    });
-    await authenticate(db.cloud.options.databaseUrl, context, db.cloud.options.fetchTokens || otpFetchTokenCallback(db), db.cloud.userInteraction, hints);
-    await context.save();
-    await setCurrentUser(db, context);
-    // Make sure to resync as the new login will be authorized
-    // for new realms.
-    triggerSync(db, "pull");
 }
 
 // @ts-ignore
@@ -4081,9 +4141,10 @@ function toStringTag(o) {
     return toString.call(o).slice(8, -1);
 }
 function getEffectiveKeys(primaryKey, req) {
+    var _a;
     if (req.type === 'delete')
         return req.keys;
-    return req.keys?.slice() || req.values.map(primaryKey.extractKey);
+    return ((_a = req.keys) === null || _a === void 0 ? void 0 : _a.slice()) || req.values.map(primaryKey.extractKey);
 }
 function applyToUpperBitFix(orig, bits) {
     return ((bits & 1 ? orig[0].toUpperCase() : orig[0].toLowerCase()) +
@@ -4174,9 +4235,7 @@ function createIdGenerationMiddleware(db) {
         name: 'idGenerationMiddleware',
         level: 1,
         create: (core) => {
-            return {
-                ...core,
-                table: (tableName) => {
+            return Object.assign(Object.assign({}, core), { table: (tableName) => {
                     const table = core.table(tableName);
                     function generateOrVerifyAtKeys(req, idPrefix) {
                         let valueClones = null;
@@ -4202,24 +4261,19 @@ function createIdGenerationMiddleware(db) {
                                     `If you want to generate IDs programmatically, remove '@' from the schema to get rid of this constraint. Dexie Cloud supports custom IDs as long as they are random and globally unique.`);
                             }
                         });
-                        return table.mutate({
-                            ...req,
-                            keys,
-                            values: valueClones || req.values,
-                        });
+                        return table.mutate(Object.assign(Object.assign({}, req), { keys, values: valueClones || req.values }));
                     }
-                    return {
-                        ...table,
-                        mutate: (req) => {
+                    return Object.assign(Object.assign({}, table), { mutate: (req) => {
+                            var _a, _b;
                             // @ts-ignore
                             if (req.trans.disableChangeTracking) {
                                 // Disable ID policy checks and ID generation
                                 return table.mutate(req);
                             }
                             if (req.type === 'add' || req.type === 'put') {
-                                const cloudTableSchema = db.cloud.schema?.[tableName];
-                                if (!cloudTableSchema?.generatedGlobalId) {
-                                    if (cloudTableSchema?.markedForSync) {
+                                const cloudTableSchema = (_a = db.cloud.schema) === null || _a === void 0 ? void 0 : _a[tableName];
+                                if (!(cloudTableSchema === null || cloudTableSchema === void 0 ? void 0 : cloudTableSchema.generatedGlobalId)) {
+                                    if (cloudTableSchema === null || cloudTableSchema === void 0 ? void 0 : cloudTableSchema.markedForSync) {
                                         // Just make sure primary key is of a supported type:
                                         const keys = getEffectiveKeys(table.schema.primaryKey, req);
                                         keys.forEach((key, idx) => {
@@ -4233,7 +4287,7 @@ function createIdGenerationMiddleware(db) {
                                     }
                                 }
                                 else {
-                                    if (db.cloud.options?.databaseUrl && !db.initiallySynced) {
+                                    if (((_b = db.cloud.options) === null || _b === void 0 ? void 0 : _b.databaseUrl) && !db.initiallySynced) {
                                         // A database URL is configured but no initial sync has been performed.
                                         const keys = getEffectiveKeys(table.schema.primaryKey, req);
                                         // Check if the operation would yield any INSERT. If so, complain! We never want wrong ID prefixes stored.
@@ -4254,10 +4308,8 @@ function createIdGenerationMiddleware(db) {
                                 }
                             }
                             return table.mutate(req);
-                        },
-                    };
-                },
-            };
+                        } });
+                } });
         },
     };
 }
@@ -4268,19 +4320,16 @@ function createImplicitPropSetterMiddleware(db) {
         name: 'implicitPropSetterMiddleware',
         level: 1,
         create: (core) => {
-            return {
-                ...core,
-                table: (tableName) => {
+            return Object.assign(Object.assign({}, core), { table: (tableName) => {
                     const table = core.table(tableName);
-                    return {
-                        ...table,
-                        mutate: (req) => {
+                    return Object.assign(Object.assign({}, table), { mutate: (req) => {
+                            var _a, _b, _c, _d;
                             // @ts-ignore
                             if (req.trans.disableChangeTracking) {
                                 return table.mutate(req);
                             }
                             const trans = req.trans;
-                            if (db.cloud.schema?.[tableName]?.markedForSync) {
+                            if ((_b = (_a = db.cloud.schema) === null || _a === void 0 ? void 0 : _a[tableName]) === null || _b === void 0 ? void 0 : _b.markedForSync) {
                                 if (req.type === 'add' || req.type === 'put') {
                                     // No matter if user is logged in or not, make sure "owner" and "realmId" props are set properly.
                                     // If not logged in, this will be changed upon syncification of the tables (next sync after login),
@@ -4294,7 +4343,7 @@ function createImplicitPropSetterMiddleware(db) {
                                         if (!obj.realmId) {
                                             obj.realmId = trans.currentUser.userId;
                                         }
-                                        const key = table.schema.primaryKey.extractKey?.(obj);
+                                        const key = (_d = (_c = table.schema.primaryKey).extractKey) === null || _d === void 0 ? void 0 : _d.call(_c, obj);
                                         if (typeof key === 'string' && key[0] === '#') {
                                             // Add $ts prop for put operations and
                                             // disable update operations as well as consistent
@@ -4321,10 +4370,8 @@ function createImplicitPropSetterMiddleware(db) {
                                 }
                             }
                             return table.mutate(req);
-                        },
-                    };
-                },
-            };
+                        } });
+                } });
         },
     };
 }
@@ -4343,15 +4390,7 @@ function allSettled(possiblePromises) {
 let counter$1 = 0;
 function guardedTable(table) {
     const prop = "$lock" + (++counter$1);
-    return {
-        ...table,
-        count: readLock(table.count, prop),
-        get: readLock(table.get, prop),
-        getMany: readLock(table.getMany, prop),
-        openCursor: readLock(table.openCursor, prop),
-        query: readLock(table.query, prop),
-        mutate: writeLock(table.mutate, prop),
-    };
+    return Object.assign(Object.assign({}, table), { count: readLock(table.count, prop), get: readLock(table.get, prop), getMany: readLock(table.getMany, prop), openCursor: readLock(table.openCursor, prop), query: readLock(table.query, prop), mutate: writeLock(table.mutate, prop) });
 }
 function readLock(fn, prop) {
     return function readLocker(req) {
@@ -4401,16 +4440,14 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                     core.table(`$${tbl.name}_mutations`)
                 ]));
             }
-            catch {
+            catch (_a) {
                 throwVersionIncrementNeeded();
             }
-            return {
-                ...core,
-                transaction: (tables, mode) => {
+            return Object.assign(Object.assign({}, core), { transaction: (tables, mode) => {
                     let tx;
                     if (mode === 'readwrite') {
                         const mutationTables = tables
-                            .filter((tbl) => db.cloud.schema?.[tbl]?.markedForSync)
+                            .filter((tbl) => { var _a, _b; return (_b = (_a = db.cloud.schema) === null || _a === void 0 ? void 0 : _a[tbl]) === null || _b === void 0 ? void 0 : _b.markedForSync; })
                             .map((tbl) => getMutationTable(tbl));
                         tx = core.transaction([...tables, ...mutationTables], mode);
                     }
@@ -4433,7 +4470,8 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                             outstandingTransactions.next(outstandingTransactions.value);
                         };
                         const txComplete = () => {
-                            if (tx.mutationsAdded && db.cloud.options?.databaseUrl) {
+                            var _a;
+                            if (tx.mutationsAdded && ((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.databaseUrl)) {
                                 if (db.cloud.usingServiceWorker) {
                                     console.debug('registering sync event');
                                     registerSyncEvent(db, "push");
@@ -4449,8 +4487,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                         tx.addEventListener('abort', removeTransaction);
                     }
                     return tx;
-                },
-                table: (tableName) => {
+                }, table: (tableName) => {
                     const table = core.table(tableName);
                     if (/^\$/.test(tableName)) {
                         if (tableName.endsWith('_mutations')) {
@@ -4458,20 +4495,15 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                             // make sure to set the mutationsAdded flag on transaction.
                             // This is also done in mutateAndLog() as that function talks to a
                             // lower level DBCore and wouldn't be catched by this code.
-                            return {
-                                ...table,
-                                mutate: (req) => {
+                            return Object.assign(Object.assign({}, table), { mutate: (req) => {
                                     if (req.type === 'add' || req.type === 'put') {
                                         req.trans.mutationsAdded = true;
                                     }
                                     return table.mutate(req);
-                                }
-                            };
+                                } });
                         }
                         else if (tableName === '$logins') {
-                            return {
-                                ...table,
-                                mutate: (req) => {
+                            return Object.assign(Object.assign({}, table), { mutate: (req) => {
                                     //console.debug('Mutating $logins table', req);
                                     return table
                                         .mutate(req)
@@ -4485,8 +4517,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                                         console.debug('Failed mutation $logins', err);
                                         return Promise.reject(err);
                                     });
-                                }
-                            };
+                                } });
                         }
                         else {
                             return table;
@@ -4494,17 +4525,16 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                     }
                     const { schema } = table;
                     const mutsTable = mutTableMap.get(tableName);
-                    return guardedTable({
-                        ...table,
-                        mutate: (req) => {
+                    return guardedTable(Object.assign(Object.assign({}, table), { mutate: (req) => {
+                            var _a, _b, _c;
                             const trans = req.trans;
                             if (!trans.txid)
                                 return table.mutate(req); // Upgrade transactions not guarded by us.
                             if (trans.disableChangeTracking)
                                 return table.mutate(req);
-                            if (!db.cloud.schema?.[tableName]?.markedForSync)
+                            if (!((_b = (_a = db.cloud.schema) === null || _a === void 0 ? void 0 : _a[tableName]) === null || _b === void 0 ? void 0 : _b.markedForSync))
                                 return table.mutate(req);
-                            if (!trans.currentUser?.isLoggedIn) {
+                            if (!((_c = trans.currentUser) === null || _c === void 0 ? void 0 : _c.isLoggedIn)) {
                                 // Unauthorized user should not log mutations.
                                 // Instead, after login all local data should be logged at once.
                                 return table.mutate(req);
@@ -4527,8 +4557,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                                     });
                                 })
                                 : mutateAndLog(req);
-                        }
-                    });
+                        } }));
                     function mutateAndLog(req) {
                         const trans = req.trans;
                         trans.mutationsAdded = true;
@@ -4599,18 +4628,14 @@ function createMutationTrackingMiddleware({ currentUserObservable, db }) {
                                 : res;
                         });
                     }
-                }
-            };
+                } });
         }
     };
 }
 
 function overrideParseStoresSpec(origFunc, dexie) {
     return function (stores, dbSchema) {
-        const storesClone = {
-            ...DEXIE_CLOUD_SCHEMA,
-            ...stores,
-        };
+        const storesClone = Object.assign(Object.assign({}, DEXIE_CLOUD_SCHEMA), stores);
         const cloudSchema = dexie.cloud.schema || (dexie.cloud.schema = {});
         const allPrefixes = new Set();
         Object.keys(storesClone).forEach(tableName => {
@@ -4642,107 +4667,12 @@ function overrideParseStoresSpec(origFunc, dexie) {
     };
 }
 
-const SECONDS = 1000;
-const MINUTES = 60 * SECONDS;
-
-const myId = randomString$1(16);
-
-const GUARDED_JOB_HEARTBEAT = 1 * SECONDS;
-const GUARDED_JOB_TIMEOUT = 1 * MINUTES;
-async function performGuardedJob(db, jobName, jobsTableName, job, { awaitRemoteJob } = {}) {
-    // Start working.
-    //
-    // Check if someone else is working on this already.
-    //
-    const jobsTable = db.table(jobsTableName);
-    async function aquireLock() {
-        const gotTheLock = await db.transaction('rw!', jobsTableName, async () => {
-            const currentWork = await jobsTable.get(jobName);
-            if (!currentWork) {
-                // No one else is working. Let's record that we are.
-                await jobsTable.add({
-                    nodeId: myId,
-                    started: new Date(),
-                    heartbeat: new Date()
-                }, jobName);
-                return true;
-            }
-            else if (currentWork.heartbeat.getTime() <
-                Date.now() - GUARDED_JOB_TIMEOUT) {
-                console.warn(`Latest ${jobName} worker seem to have died.\n`, `The dead job started:`, currentWork.started, `\n`, `Last heart beat was:`, currentWork.heartbeat, '\n', `We're now taking over!`);
-                // Now, take over!
-                await jobsTable.put({
-                    nodeId: myId,
-                    started: new Date(),
-                    heartbeat: new Date()
-                }, jobName);
-                return true;
-            }
-            return false;
-        });
-        if (gotTheLock)
-            return true;
-        // Someone else took the job.
-        if (awaitRemoteJob) {
-            try {
-                const jobDoneObservable = from$1(liveQuery(() => jobsTable.get(jobName))).pipe(timeout(GUARDED_JOB_TIMEOUT), filter((job) => !job)); // Wait til job is not there anymore.
-                await jobDoneObservable.toPromise();
-                return false;
-            }
-            catch (err) {
-                if (err.name !== 'TimeoutError') {
-                    throw err;
-                }
-                // Timeout stopped us! Try aquire the lock now.
-                // It will likely succeed this time unless
-                // another client took it.
-                return await aquireLock();
-            }
-        }
-        return false;
-    }
-    if (await aquireLock()) {
-        // We own the lock entry and can do our job undisturbed.
-        // We're not within a transaction, but these type of locks
-        // spans over transactions.
-        // Start our heart beat during the job.
-        // Use setInterval to make sure we are updating heartbeat even during long-lived fetch calls.
-        const heartbeat = setInterval(() => {
-            jobsTable.update(jobName, (job) => {
-                if (job.nodeId === myId) {
-                    job.heartbeat = new Date();
-                }
-            });
-        }, GUARDED_JOB_HEARTBEAT);
-        try {
-            return await job();
-        }
-        finally {
-            // Stop heartbeat
-            clearInterval(heartbeat);
-            // Remove the persisted job state:
-            await db.transaction('rw!', jobsTableName, async () => {
-                const currentWork = await jobsTable.get(jobName);
-                if (currentWork && currentWork.nodeId === myId) {
-                    jobsTable.delete(jobName);
-                }
-            });
-        }
-    }
-}
-
-async function performInitialSync(db, cloudOptions, cloudSchema) {
-    console.debug("Performing initial sync");
-    await performGuardedJob(db, 'initialSync', '$jobs', async () => {
-        // Even though caller has already checked it,
-        // Do check again (now within a transaction) that we really do not have a sync state:
-        const syncState = await db.getPersistedSyncState();
-        if (!syncState?.initiallySynced) {
-            await sync(db, cloudOptions, cloudSchema, { isInitialSync: true });
-        }
-    }, { awaitRemoteJob: true } // Don't return until the job is done!
-    );
-    console.debug("Done initial sync");
+function performInitialSync(db, cloudOptions, cloudSchema) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        console.debug('Performing initial sync');
+        yield sync(db, cloudOptions, cloudSchema, { isInitialSync: true });
+        console.debug('Done initial sync');
+    });
 }
 
 const USER_INACTIVITY_TIMEOUT = 180000; // 3 minutes
@@ -4860,7 +4790,7 @@ class WSConnection extends Subscription$1 {
             try {
                 this.ws.close();
             }
-            catch { }
+            catch (_a) { }
         }
         this.ws = null;
         if (this.messageProducerSubscription) {
@@ -4875,168 +4805,174 @@ class WSConnection extends Subscription$1 {
         try {
             this.disconnect();
         }
-        catch { }
+        catch (_a) { }
         this.connect()
             .catch(() => { })
             .then(() => (this.reconnecting = false)); // finally()
     }
-    async connect() {
-        this.lastServerActivity = new Date();
-        if (this.pauseUntil && this.pauseUntil > new Date()) {
-            console.debug('WS not reconnecting just yet', {
-                id: this.id,
-                pauseUntil: this.pauseUntil,
-            });
-            return;
-        }
-        if (this.ws) {
-            throw new Error(`Called connect() when a connection is already open`);
-        }
-        if (!this.databaseUrl)
-            throw new Error(`Cannot connect without a database URL`);
-        if (this.closed) {
-            //console.debug('SyncStatus: DUBB: Ooops it was closed!');
-            return;
-        }
-        if (this.tokenExpiration && this.tokenExpiration < new Date()) {
-            this.subscriber.error(new TokenExpiredError()); // Will be handled in connectWebSocket.ts.
-            return;
-        }
-        this.webSocketStatus.next('connecting');
-        this.pinger = setInterval(async () => {
-            if (this.closed) {
-                console.debug('pinger check', this.id, 'CLOSED.');
-                this.teardown();
+    connect() {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            this.lastServerActivity = new Date();
+            if (this.pauseUntil && this.pauseUntil > new Date()) {
+                console.debug('WS not reconnecting just yet', {
+                    id: this.id,
+                    pauseUntil: this.pauseUntil,
+                });
                 return;
             }
             if (this.ws) {
-                try {
-                    this.ws.send(JSON.stringify({ type: 'ping' }));
-                    setTimeout(() => {
-                        console.debug('pinger setTimeout', this.id, this.pinger ? `alive` : 'dead');
-                        if (!this.pinger)
-                            return;
-                        if (this.closed) {
-                            console.debug('pinger setTimeout', this.id, 'subscription is closed');
-                            this.teardown();
-                            return;
-                        }
-                        if (this.lastServerActivity <
-                            new Date(Date.now() - SERVER_PING_TIMEOUT)) {
-                            // Server inactive. Reconnect if user is active.
-                            console.debug('pinger: server is inactive');
-                            console.debug('pinger reconnecting');
-                            this.reconnect();
-                        }
-                        else {
-                            console.debug('pinger: server still active');
-                        }
-                    }, SERVER_PING_TIMEOUT);
-                }
-                catch {
-                    console.debug('pinger catch error', this.id, 'reconnecting');
-                    this.reconnect();
-                }
+                throw new Error(`Called connect() when a connection is already open`);
             }
-            else {
-                console.debug('pinger', this.id, 'reconnecting');
-                this.reconnect();
-            }
-        }, CLIENT_PING_INTERVAL);
-        // The following vars are needed because we must know which callback to ack when server sends it's ack to us.
-        const wsUrl = new URL(this.databaseUrl);
-        wsUrl.protocol = wsUrl.protocol === 'http:' ? 'ws' : 'wss';
-        const searchParams = new URLSearchParams();
-        if (this.subscriber.closed)
-            return;
-        searchParams.set('v', '2');
-        searchParams.set('rev', this.rev);
-        searchParams.set('realmsHash', this.realmSetHash);
-        searchParams.set('clientId', this.clientIdentity);
-        if (this.token) {
-            searchParams.set('token', this.token);
-        }
-        // Connect the WebSocket to given url:
-        console.debug('dexie-cloud WebSocket create');
-        const ws = (this.ws = new WebSocket(`${wsUrl}/changes?${searchParams}`));
-        //ws.binaryType = "arraybuffer"; // For future when subscribing to actual changes.
-        ws.onclose = (event) => {
-            if (!this.pinger)
+            if (!this.databaseUrl)
+                throw new Error(`Cannot connect without a database URL`);
+            if (this.closed) {
+                //console.debug('SyncStatus: DUBB: Ooops it was closed!');
                 return;
-            console.debug('dexie-cloud WebSocket onclosed', this.id);
-            this.reconnect();
-        };
-        ws.onmessage = (event) => {
-            if (!this.pinger)
+            }
+            if (this.tokenExpiration && this.tokenExpiration < new Date()) {
+                this.subscriber.error(new TokenExpiredError()); // Will be handled in connectWebSocket.ts.
                 return;
-            console.debug('dexie-cloud WebSocket onmessage', event.data);
-            this.lastServerActivity = new Date();
-            try {
-                const msg = TSON.parse(event.data);
-                if (msg.type === 'error') {
-                    throw new Error(`Error message from dexie-cloud: ${msg.error}`);
+            }
+            this.webSocketStatus.next('connecting');
+            this.pinger = setInterval(() => __awaiter$1(this, void 0, void 0, function* () {
+                if (this.closed) {
+                    console.debug('pinger check', this.id, 'CLOSED.');
+                    this.teardown();
+                    return;
                 }
-                if (msg.type === 'rev') {
-                    this.rev = msg.rev; // No meaning but seems reasonable.
+                if (this.ws) {
+                    try {
+                        this.ws.send(JSON.stringify({ type: 'ping' }));
+                        setTimeout(() => {
+                            console.debug('pinger setTimeout', this.id, this.pinger ? `alive` : 'dead');
+                            if (!this.pinger)
+                                return;
+                            if (this.closed) {
+                                console.debug('pinger setTimeout', this.id, 'subscription is closed');
+                                this.teardown();
+                                return;
+                            }
+                            if (this.lastServerActivity <
+                                new Date(Date.now() - SERVER_PING_TIMEOUT)) {
+                                // Server inactive. Reconnect if user is active.
+                                console.debug('pinger: server is inactive');
+                                console.debug('pinger reconnecting');
+                                this.reconnect();
+                            }
+                            else {
+                                console.debug('pinger: server still active');
+                            }
+                        }, SERVER_PING_TIMEOUT);
+                    }
+                    catch (_a) {
+                        console.debug('pinger catch error', this.id, 'reconnecting');
+                        this.reconnect();
+                    }
                 }
-                if (msg.type !== 'pong') {
-                    this.subscriber.next(msg);
+                else {
+                    console.debug('pinger', this.id, 'reconnecting');
+                    this.reconnect();
                 }
+            }), CLIENT_PING_INTERVAL);
+            // The following vars are needed because we must know which callback to ack when server sends it's ack to us.
+            const wsUrl = new URL(this.databaseUrl);
+            wsUrl.protocol = wsUrl.protocol === 'http:' ? 'ws' : 'wss';
+            const searchParams = new URLSearchParams();
+            if (this.subscriber.closed)
+                return;
+            searchParams.set('v', '2');
+            searchParams.set('rev', this.rev);
+            searchParams.set('realmsHash', this.realmSetHash);
+            searchParams.set('clientId', this.clientIdentity);
+            if (this.token) {
+                searchParams.set('token', this.token);
             }
-            catch (e) {
-                this.subscriber.error(e);
-            }
-        };
-        try {
-            let everConnected = false;
-            await new Promise((resolve, reject) => {
-                ws.onopen = (event) => {
-                    console.debug('dexie-cloud WebSocket onopen');
-                    everConnected = true;
-                    resolve(null);
-                };
-                ws.onerror = (event) => {
-                    if (!everConnected) {
-                        const error = event.error || new Error('WebSocket Error');
-                        this.subscriber.error(error);
-                        this.webSocketStatus.next('error');
-                        reject(error);
+            // Connect the WebSocket to given url:
+            console.debug('dexie-cloud WebSocket create');
+            const ws = (this.ws = new WebSocket(`${wsUrl}/changes?${searchParams}`));
+            //ws.binaryType = "arraybuffer"; // For future when subscribing to actual changes.
+            ws.onclose = (event) => {
+                if (!this.pinger)
+                    return;
+                console.debug('dexie-cloud WebSocket onclosed', this.id);
+                this.reconnect();
+            };
+            ws.onmessage = (event) => {
+                if (!this.pinger)
+                    return;
+                console.debug('dexie-cloud WebSocket onmessage', event.data);
+                this.lastServerActivity = new Date();
+                try {
+                    const msg = TSON.parse(event.data);
+                    if (msg.type === 'error') {
+                        throw new Error(`Error message from dexie-cloud: ${msg.error}`);
                     }
-                    else {
-                        this.reconnect();
+                    if (msg.type === 'rev') {
+                        this.rev = msg.rev; // No meaning but seems reasonable.
                     }
-                };
-            });
-            this.messageProducerSubscription = this.messageProducer.subscribe((msg) => {
-                if (!this.closed) {
-                    if (msg.type === 'ready' &&
-                        this.webSocketStatus.value !== 'connected') {
-                        this.webSocketStatus.next('connected');
+                    if (msg.type !== 'pong') {
+                        this.subscriber.next(msg);
                     }
-                    this.ws?.send(TSON.stringify(msg));
                 }
-            });
-        }
-        catch (error) {
-            this.pauseUntil = new Date(Date.now() + FAIL_RETRY_WAIT_TIME);
-        }
+                catch (e) {
+                    this.subscriber.error(e);
+                }
+            };
+            try {
+                let everConnected = false;
+                yield new Promise((resolve, reject) => {
+                    ws.onopen = (event) => {
+                        console.debug('dexie-cloud WebSocket onopen');
+                        everConnected = true;
+                        resolve(null);
+                    };
+                    ws.onerror = (event) => {
+                        if (!everConnected) {
+                            const error = event.error || new Error('WebSocket Error');
+                            this.subscriber.error(error);
+                            this.webSocketStatus.next('error');
+                            reject(error);
+                        }
+                        else {
+                            this.reconnect();
+                        }
+                    };
+                });
+                this.messageProducerSubscription = this.messageProducer.subscribe((msg) => {
+                    var _a;
+                    if (!this.closed) {
+                        if (msg.type === 'ready' &&
+                            this.webSocketStatus.value !== 'connected') {
+                            this.webSocketStatus.next('connected');
+                        }
+                        (_a = this.ws) === null || _a === void 0 ? void 0 : _a.send(TSON.stringify(msg));
+                    }
+                });
+            }
+            catch (error) {
+                this.pauseUntil = new Date(Date.now() + FAIL_RETRY_WAIT_TIME);
+            }
+        });
     }
 }
 
 function sleep$1(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function waitAndReconnectWhenUserDoesSomething(error) {
-    console.error(`WebSocket observable: error but revive when user does some active thing...`, error);
-    // Sleep some seconds...
-    await sleep$1(3000);
-    // Wait til user does something (move mouse, tap, scroll, click etc)
-    console.debug('waiting for someone to do something');
-    await userDoesSomething.pipe(take(1)).toPromise();
-    console.debug('someone did something!');
+function waitAndReconnectWhenUserDoesSomething(error) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        console.error(`WebSocket observable: error but revive when user does some active thing...`, error);
+        // Sleep some seconds...
+        yield sleep$1(3000);
+        // Wait til user does something (move mouse, tap, scroll, click etc)
+        console.debug('waiting for someone to do something');
+        yield userDoesSomething.pipe(take(1)).toPromise();
+        console.debug('someone did something!');
+    });
 }
 function connectWebSocket(db) {
-    if (!db.cloud.options?.databaseUrl) {
+    var _a;
+    if (!((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.databaseUrl)) {
         throw new Error(`No database URL to connect WebSocket to`);
     }
     const messageProducer = db.messageConsumer.readyToServe.pipe(filter((isReady) => isReady), // When consumer is ready for new messages, produce such a message to inform server about it
@@ -5048,27 +4984,27 @@ function connectWebSocket(db) {
         rev: syncState.serverRevision,
     })));
     function createObservable() {
-        return db.cloud.persistedSyncState.pipe(filter((syncState) => syncState?.serverRevision), // Don't connect before there's no initial sync performed.
+        return db.cloud.persistedSyncState.pipe(filter((syncState) => syncState === null || syncState === void 0 ? void 0 : syncState.serverRevision), // Don't connect before there's no initial sync performed.
         take(1), // Don't continue waking up whenever syncState change
-        switchMap((syncState) => db.cloud.currentUser.pipe(map((userLogin) => [userLogin, syncState]))), switchMap(([userLogin, syncState]) => userIsReallyActive.pipe(map((isActive) => [isActive ? userLogin : null, syncState]))), switchMap(async ([userLogin, syncState]) => [userLogin, await computeRealmSetHash(syncState)]), switchMap(([userLogin, realmSetHash]) => 
+        switchMap((syncState) => db.cloud.currentUser.pipe(map((userLogin) => [userLogin, syncState]))), switchMap(([userLogin, syncState]) => userIsReallyActive.pipe(map((isActive) => [isActive ? userLogin : null, syncState]))), switchMap(([userLogin, syncState]) => __awaiter$1(this, void 0, void 0, function* () { return [userLogin, yield computeRealmSetHash(syncState)]; })), switchMap(([userLogin, realmSetHash]) => 
         // Let server end query changes from last entry of same client-ID and forward.
         // 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.
         userLogin
             ? new WSObservable(db.cloud.options.databaseUrl, db.cloud.persistedSyncState.value.serverRevision, realmSetHash, db.cloud.persistedSyncState.value.clientIdentity, messageProducer, db.cloud.webSocketStatus, userLogin.accessToken, userLogin.accessTokenExpiration)
             : from$1([])), catchError((error) => {
-            if (error?.name === 'TokenExpiredError') {
+            if ((error === null || error === void 0 ? void 0 : error.name) === 'TokenExpiredError') {
                 console.debug('WebSocket observable: Token expired. Refreshing token...');
-                return of(true).pipe(switchMap(async () => {
+                return of(true).pipe(switchMap(() => __awaiter$1(this, void 0, void 0, function* () {
                     // Refresh access token
-                    const user = await db.getCurrentUser();
-                    const refreshedLogin = await refreshAccessToken(db.cloud.options.databaseUrl, user);
+                    const user = yield db.getCurrentUser();
+                    const refreshedLogin = yield refreshAccessToken(db.cloud.options.databaseUrl, user);
                     // Persist updated access token
-                    await db.table('$logins').update(user.userId, {
+                    yield db.table('$logins').update(user.userId, {
                         accessToken: refreshedLogin.accessToken,
                         accessTokenExpiration: refreshedLogin.accessTokenExpiration,
                     });
-                }), switchMap(() => createObservable()));
+                })), switchMap(() => createObservable()));
             }
             else {
                 return throwError(error);
@@ -5090,17 +5026,113 @@ function connectWebSocket(db) {
     });
 }
 
-async function isSyncNeeded(db) {
-    return db.cloud.options?.databaseUrl && db.cloud.schema
-        ? await sync(db, db.cloud.options, db.cloud.schema, { justCheckIfNeeded: true })
-        : false;
+function isSyncNeeded(db) {
+    var _a;
+    return __awaiter$1(this, void 0, void 0, function* () {
+        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;
+    });
+}
+
+const SECONDS = 1000;
+const MINUTES = 60 * SECONDS;
+
+const myId = randomString$1(16);
+
+const GUARDED_JOB_HEARTBEAT = 1 * SECONDS;
+const GUARDED_JOB_TIMEOUT = 1 * MINUTES;
+function performGuardedJob(db, jobName, jobsTableName, job, { awaitRemoteJob } = {}) {
+    return __awaiter$1(this, void 0, void 0, function* () {
+        // Start working.
+        //
+        // Check if someone else is working on this already.
+        //
+        const jobsTable = db.table(jobsTableName);
+        function aquireLock() {
+            return __awaiter$1(this, void 0, void 0, function* () {
+                const gotTheLock = yield db.transaction('rw!', jobsTableName, () => __awaiter$1(this, void 0, void 0, function* () {
+                    const currentWork = yield jobsTable.get(jobName);
+                    if (!currentWork) {
+                        // No one else is working. Let's record that we are.
+                        yield jobsTable.add({
+                            nodeId: myId,
+                            started: new Date(),
+                            heartbeat: new Date()
+                        }, jobName);
+                        return true;
+                    }
+                    else if (currentWork.heartbeat.getTime() <
+                        Date.now() - GUARDED_JOB_TIMEOUT) {
+                        console.warn(`Latest ${jobName} worker seem to have died.\n`, `The dead job started:`, currentWork.started, `\n`, `Last heart beat was:`, currentWork.heartbeat, '\n', `We're now taking over!`);
+                        // Now, take over!
+                        yield jobsTable.put({
+                            nodeId: myId,
+                            started: new Date(),
+                            heartbeat: new Date()
+                        }, jobName);
+                        return true;
+                    }
+                    return false;
+                }));
+                if (gotTheLock)
+                    return true;
+                // Someone else took the job.
+                if (awaitRemoteJob) {
+                    try {
+                        const jobDoneObservable = from$1(liveQuery(() => jobsTable.get(jobName))).pipe(timeout(GUARDED_JOB_TIMEOUT), filter((job) => !job)); // Wait til job is not there anymore.
+                        yield jobDoneObservable.toPromise();
+                        return false;
+                    }
+                    catch (err) {
+                        if (err.name !== 'TimeoutError') {
+                            throw err;
+                        }
+                        // Timeout stopped us! Try aquire the lock now.
+                        // It will likely succeed this time unless
+                        // another client took it.
+                        return yield aquireLock();
+                    }
+                }
+                return false;
+            });
+        }
+        if (yield aquireLock()) {
+            // We own the lock entry and can do our job undisturbed.
+            // We're not within a transaction, but these type of locks
+            // spans over transactions.
+            // Start our heart beat during the job.
+            // Use setInterval to make sure we are updating heartbeat even during long-lived fetch calls.
+            const heartbeat = setInterval(() => {
+                jobsTable.update(jobName, (job) => {
+                    if (job.nodeId === myId) {
+                        job.heartbeat = new Date();
+                    }
+                });
+            }, GUARDED_JOB_HEARTBEAT);
+            try {
+                return yield job();
+            }
+            finally {
+                // Stop heartbeat
+                clearInterval(heartbeat);
+                // Remove the persisted job state:
+                yield db.transaction('rw!', jobsTableName, () => __awaiter$1(this, void 0, void 0, function* () {
+                    const currentWork = yield jobsTable.get(jobName);
+                    if (currentWork && currentWork.nodeId === myId) {
+                        yield jobsTable.delete(jobName);
+                    }
+                }));
+            }
+        }
+    });
 }
 
 const ongoingSyncs = new WeakMap();
 function syncIfPossible(db, cloudOptions, cloudSchema, options) {
     const ongoing = ongoingSyncs.get(db);
     if (ongoing) {
-        if (ongoing.pull || options?.purpose === 'push') {
+        if (ongoing.pull || (options === null || options === void 0 ? void 0 : options.purpose) === 'push') {
             console.debug('syncIfPossible(): returning the ongoing sync promise.');
             return ongoing.promise;
         }
@@ -5142,32 +5174,37 @@ function syncIfPossible(db, cloudOptions, cloudSchema, options) {
         }
     }
     const promise = _syncIfPossible();
-    ongoingSyncs.set(db, { promise, pull: options?.purpose !== 'push' });
+    ongoingSyncs.set(db, { promise, pull: (options === null || options === void 0 ? void 0 : options.purpose) !== 'push' });
     return promise;
-    async function _syncIfPossible() {
-        try {
-            if (db.cloud.usingServiceWorker) {
-                if (IS_SERVICE_WORKER) {
-                    await sync(db, cloudOptions, cloudSchema, options);
+    function _syncIfPossible() {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            try {
+                if (db.cloud.isServiceWorkerDB) {
+                    // We are the dedicated sync SW:
+                    yield sync(db, cloudOptions, cloudSchema, options);
+                }
+                else if (!db.cloud.usingServiceWorker) {
+                    // We use a flow that is better suited for the case when multiple workers want to
+                    // do the same thing.
+                    yield performGuardedJob(db, CURRENT_SYNC_WORKER, '$jobs', () => sync(db, cloudOptions, cloudSchema, options));
+                }
+                else {
+                    assert(false);
+                    throw new Error('Internal _syncIfPossible() - invalid precondition - should not have been called.');
                 }
+                ongoingSyncs.delete(db);
+                console.debug('Done sync');
             }
-            else {
-                // We use a flow that is better suited for the case when multiple workers want to
-                // do the same thing.
-                await performGuardedJob(db, CURRENT_SYNC_WORKER, '$jobs', () => sync(db, cloudOptions, cloudSchema, options));
+            catch (error) {
+                ongoingSyncs.delete(db);
+                console.error(`Failed to sync client changes`, error);
+                throw error; // Make sure we rethrow error so that sync event is retried.
+                // I don't think we should setTimout or so here.
+                // Unless server tells us to in some response.
+                // Then we could follow that advice but not by waiting here but by registering
+                // Something that triggers an event listened to in startPushWorker()
             }
-            ongoingSyncs.delete(db);
-            console.debug('Done sync');
-        }
-        catch (error) {
-            ongoingSyncs.delete(db);
-            console.error(`Failed to sync client changes`, error);
-            throw error; // Make sure we rethrow error so that sync event is retried.
-            // I don't think we should setTimout or so here.
-            // Unless server tells us to in some response.
-            // Then we could follow that advice but not by waiting here but by registering
-            // Something that triggers an event listened to in startPushWorker()
-        }
+        });
     }
 }
 
@@ -5237,8 +5274,9 @@ function updateSchemaFromOptions(schema, options) {
 }
 
 function verifySchema(db) {
+    var _a, _b;
     for (const table of db.tables) {
-        if (db.cloud.schema?.[table.name]?.markedForSync) {
+        if ((_b = (_a = db.cloud.schema) === null || _a === void 0 ? void 0 : _a[table.name]) === null || _b === void 0 ? void 0 : _b.markedForSync) {
             if (table.schema.primKey.auto) {
                 throw new Dexie.SchemaError(`Table ${table.name} is both autoIncremented and synced. ` +
                     `Use db.cloud.configure({unsyncedTables: [${JSON.stringify(table.name)}]}) to blacklist it from sync`);
@@ -5331,7 +5369,7 @@ function resolveText({ message, messageCode, messageParams }) {
 function LoginDialog({ title, alerts, fields, onCancel, onSubmit, }) {
     const [params, setParams] = l({});
     const firstFieldRef = s();
-    h(() => firstFieldRef.current?.focus(), []);
+    h(() => { var _a; return (_a = firstFieldRef.current) === null || _a === void 0 ? void 0 : _a.focus(); }, []);
     return (a$1(Dialog, null,
         a$1(y, null,
             a$1("h3", { style: Styles.WindowHeader }, title),
@@ -5341,7 +5379,7 @@ function LoginDialog({ title, alerts, fields, onCancel, onSubmit, }) {
                     onSubmit(params);
                 } }, Object.entries(fields).map(([fieldName, { type, label, placeholder }], idx) => (a$1("label", { style: Styles.Label },
                 label ? `${label}: ` : '',
-                a$1("input", { ref: idx === 0 ? firstFieldRef : undefined, type: type, name: fieldName, autoComplete: "on", style: Styles.Input, autoFocus: true, placeholder: placeholder, value: params[fieldName] || '', onInput: (ev) => setParams({ ...params, [fieldName]: valueTransformer(type, ev.target?.['value']) }) })))))),
+                a$1("input", { ref: idx === 0 ? firstFieldRef : undefined, type: type, name: fieldName, autoComplete: "on", style: Styles.Input, autoFocus: true, placeholder: placeholder, value: params[fieldName] || '', onInput: (ev) => { var _a; return setParams(Object.assign(Object.assign({}, params), { [fieldName]: valueTransformer(type, (_a = ev.target) === null || _a === void 0 ? void 0 : _a['value']) })); } })))))),
         a$1("div", { style: Styles.ButtonsDiv },
             a$1("button", { type: "submit", style: Styles.Button, onClick: () => onSubmit(params) }, "Submit"),
             a$1("button", { style: Styles.Button, onClick: onCancel }, "Cancel"))));
@@ -5373,7 +5411,7 @@ class LoginGui extends p$1 {
         if (!userInteraction)
             return null;
         //if (props.db.cloud.userInteraction.observers.length > 1) return null; // Someone else subscribes.
-        return a$1(LoginDialog, { ...userInteraction });
+        return a$1(LoginDialog, Object.assign({}, userInteraction));
     }
 }
 function setupDefaultGUI(db) {
@@ -5559,7 +5597,7 @@ function mergePermissions(...permissions) {
     if (permissions.length === 0)
         return {};
     const reduced = permissions.reduce((result, next) => {
-        const ret = { ...result };
+        const ret = Object.assign({}, result);
         for (const [verb, rights] of Object.entries(next)) {
             if (verb in ret && ret[verb]) {
                 if (ret[verb] === '*')
@@ -5641,14 +5679,11 @@ const getPermissionsLookupObservable = associate((db) => {
                 .map((role) => globalRoles[role])
                 .filter((role) => role)
                 .map((role) => role.permissions);
-            return {
-                ...realm,
-                permissions: realm.owner === userId
+            return Object.assign(Object.assign({}, realm), { permissions: realm.owner === userId
                     ? { manage: '*' }
-                    : mergePermissions(...directPermissionSets, ...rolePermissionSets),
-            };
+                    : mergePermissions(...directPermissionSets, ...rolePermissionSets) });
         })
-            .reduce((p, c) => ({ ...p, [c.realmId]: c }), {
+            .reduce((p, c) => (Object.assign(Object.assign({}, p), { [c.realmId]: c })), {
             [userId]: {
                 realmId: userId,
                 owner: userId,
@@ -5667,47 +5702,50 @@ class PermissionChecker {
         this.isOwner = isOwner;
     }
     add(...tableNames) {
+        var _a;
         // If user can manage the whole realm, return true.
         if (this.permissions.manage === '*')
             return true;
         // If user can manage given table in realm, return true
-        if (this.permissions.manage?.includes(this.tableName))
+        if ((_a = this.permissions.manage) === null || _a === void 0 ? void 0 : _a.includes(this.tableName))
             return true;
         // If user can add any type, return true
         if (this.permissions.add === '*')
             return true;
         // If user can add objects into given table names in the realm, return true
-        if (tableNames.every((tableName) => this.permissions.add?.includes(tableName))) {
+        if (tableNames.every((tableName) => { var _a; return (_a = this.permissions.add) === null || _a === void 0 ? void 0 : _a.includes(tableName); })) {
             return true;
         }
         return false;
     }
     update(...props) {
+        var _a, _b;
         // If user is owner of this object, or if user can manage the whole realm, return true.
         if (this.isOwner || this.permissions.manage === '*')
             return true;
         // If user can manage given table in realm, return true
-        if (this.permissions.manage?.includes(this.tableName))
+        if ((_a = this.permissions.manage) === null || _a === void 0 ? void 0 : _a.includes(this.tableName))
             return true;
         // If user can update any prop in any table in this realm, return true unless
         // it regards to ownership change:
         if (this.permissions.update === '*') {
             return props.every((prop) => prop !== 'owner');
         }
-        const tablePermissions = this.permissions.update?.[this.tableName];
+        const tablePermissions = (_b = this.permissions.update) === null || _b === void 0 ? void 0 : _b[this.tableName];
         // If user can update any prop in table and realm, return true unless
         // accessing special props owner or realmId
         if (tablePermissions === '*')
             return props.every((prop) => prop !== 'owner');
         // Explicitely listed properties to allow updates on:
-        return props.every((prop) => tablePermissions?.some((permittedProp) => permittedProp === prop || (permittedProp === '*' && prop !== 'owner')));
+        return props.every((prop) => tablePermissions === null || tablePermissions === void 0 ? void 0 : tablePermissions.some((permittedProp) => permittedProp === prop || (permittedProp === '*' && prop !== 'owner')));
     }
     delete() {
+        var _a;
         // If user is owner of this object, or if user can manage the whole realm, return true.
         if (this.isOwner || this.permissions.manage === '*')
             return true;
         // If user can manage given table in realm, return true
-        if (this.permissions.manage?.includes(this.tableName))
+        if ((_a = this.permissions.manage) === null || _a === void 0 ? void 0 : _a.includes(this.tableName))
             return true;
         return false;
     }
@@ -5743,7 +5781,7 @@ const getInvitesObservable = associate((db) => {
     const permissions = getPermissionsLookupObservable(db._novip);
     const accessControl = getInternalAccessControlObservable(db._novip);
     return createSharedValueObservable(combineLatest([membersByEmail, accessControl, permissions]).pipe(map$1(([membersByEmail, accessControl, realmLookup]) => {
-        const reducer = (result, m) => ({ ...result, [m.id]: { ...m, realm: realmLookup[m.realmId] } });
+        const reducer = (result, m) => (Object.assign(Object.assign({}, result), { [m.id]: Object.assign(Object.assign({}, m), { realm: realmLookup[m.realmId] }) }));
         const emailMembersById = membersByEmail.reduce(reducer, {});
         const membersById = accessControl.selfMembers.reduce(reducer, emailMembersById);
         return Object.values(membersById).filter(m => !m.accepted);
@@ -5763,15 +5801,15 @@ function dexieCloud(dexie) {
     let configuredProgramatically = false;
     // local sync worker - used when there's no service worker.
     let localSyncWorker = null;
-    dexie.on('ready', async (dexie) => {
+    dexie.on('ready', (dexie) => __awaiter$1(this, void 0, void 0, function* () {
         try {
-            await onDbReady(dexie);
+            yield onDbReady(dexie);
         }
         catch (error) {
             console.error(error);
             // Make sure to succeed with database open even if network is down.
         }
-    }, true // true = sticky
+    }), true // true = sticky
     );
     /** Void starting subscribers after a close has happened. */
     let closed = false;
@@ -5787,8 +5825,8 @@ function dexieCloud(dexie) {
         currentUserEmitter.next(UNAUTHORIZED_USER);
     });
     dexie.cloud = {
-        version: '4.0.0-beta.16',
-        options: { ...DEFAULT_OPTIONS },
+        version: '4.0.0-beta.19',
+        options: Object.assign({}, DEFAULT_OPTIONS),
         schema: null,
         serverState: null,
         get currentUserId() {
@@ -5802,15 +5840,17 @@ function dexieCloud(dexie) {
         persistedSyncState: new BehaviorSubject(undefined),
         userInteraction: new BehaviorSubject(undefined),
         webSocketStatus: new BehaviorSubject('not-started'),
-        async login(hint) {
-            const db = DexieCloudDB(dexie);
-            await db.cloud.sync();
-            await login(db, hint);
+        login(hint) {
+            return __awaiter$1(this, void 0, void 0, function* () {
+                const db = DexieCloudDB(dexie);
+                yield db.cloud.sync();
+                yield login(db, hint);
+            });
         },
         invites: getInvitesObservable(dexie),
         roles: getGlobalRolesObservable(dexie),
         configure(options) {
-            options = dexie.cloud.options = { ...dexie.cloud.options, ...options };
+            options = dexie.cloud.options = Object.assign(Object.assign({}, dexie.cloud.options), options);
             configuredProgramatically = true;
             if (options.databaseUrl && options.nameSuffix) {
                 // @ts-ignore
@@ -5819,41 +5859,43 @@ function dexieCloud(dexie) {
             }
             updateSchemaFromOptions(dexie.cloud.schema, dexie.cloud.options);
         },
-        async sync({ wait, purpose } = { wait: true, purpose: 'push' }) {
-            if (wait === undefined)
-                wait = true;
-            const db = DexieCloudDB(dexie);
-            if (purpose === 'pull') {
-                const syncState = db.cloud.persistedSyncState.value;
-                triggerSync(db, purpose);
-                if (wait) {
-                    const newSyncState = await db.cloud.persistedSyncState
-                        .pipe(filter((newSyncState) => newSyncState?.timestamp != null &&
-                        (!syncState || newSyncState.timestamp > syncState.timestamp)), take(1))
-                        .toPromise();
-                    if (newSyncState?.error) {
-                        throw new Error(`Sync error: ` + newSyncState.error);
+        sync({ wait, purpose } = { wait: true, purpose: 'push' }) {
+            return __awaiter$1(this, void 0, void 0, function* () {
+                if (wait === undefined)
+                    wait = true;
+                const db = DexieCloudDB(dexie);
+                if (purpose === 'pull') {
+                    const syncState = db.cloud.persistedSyncState.value;
+                    triggerSync(db, purpose);
+                    if (wait) {
+                        const newSyncState = yield db.cloud.persistedSyncState
+                            .pipe(filter((newSyncState) => (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.timestamp) != null &&
+                            (!syncState || newSyncState.timestamp > syncState.timestamp)), take(1))
+                            .toPromise();
+                        if (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.error) {
+                            throw new Error(`Sync error: ` + newSyncState.error);
+                        }
                     }
                 }
-            }
-            else if (await isSyncNeeded(db)) {
-                const syncState = db.cloud.persistedSyncState.value;
-                triggerSync(db, purpose);
-                if (wait) {
-                    console.debug('db.cloud.login() is waiting for sync completion...');
-                    await from$1(liveQuery(async () => {
-                        const syncNeeded = await isSyncNeeded(db);
-                        const newSyncState = await db.getPersistedSyncState();
-                        if (newSyncState?.timestamp !== syncState?.timestamp &&
-                            newSyncState?.error)
-                            throw new Error(`Sync error: ` + newSyncState.error);
-                        return syncNeeded;
-                    }))
-                        .pipe(filter((isNeeded) => !isNeeded), take(1))
-                        .toPromise();
-                    console.debug('Done waiting for sync completion because we have nothing to push anymore');
+                else if (yield isSyncNeeded(db)) {
+                    const syncState = db.cloud.persistedSyncState.value;
+                    triggerSync(db, purpose);
+                    if (wait) {
+                        console.debug('db.cloud.login() is waiting for sync completion...');
+                        yield from$1(liveQuery(() => __awaiter$1(this, void 0, void 0, function* () {
+                            const syncNeeded = yield isSyncNeeded(db);
+                            const newSyncState = yield db.getPersistedSyncState();
+                            if ((newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.timestamp) !== (syncState === null || syncState === void 0 ? void 0 : syncState.timestamp) &&
+                                (newSyncState === null || newSyncState === void 0 ? void 0 : newSyncState.error))
+                                throw new Error(`Sync error: ` + newSyncState.error);
+                            return syncNeeded;
+                        })))
+                            .pipe(filter((isNeeded) => !isNeeded), take(1))
+                            .toPromise();
+                        console.debug('Done waiting for sync completion because we have nothing to push anymore');
+                    }
                 }
-            }
+            });
         },
         permissions(obj, tableName) {
             return permissions(dexie._novip, obj, tableName);
@@ -5865,7 +5907,8 @@ function dexieCloud(dexie) {
         return generateKey(dexie.cloud.schema[this.name].idPrefix || '', shardKey);
     };
     dexie.Table.prototype.idPrefix = function () {
-        return this.db.cloud.schema?.[this.name]?.idPrefix || '';
+        var _a, _b;
+        return ((_b = (_a = this.db.cloud.schema) === null || _a === void 0 ? void 0 : _a[this.name]) === null || _b === void 0 ? void 0 : _b.idPrefix) || '';
     };
     dexie.use(createMutationTrackingMiddleware({
         currentUserObservable: dexie.cloud.currentUser,
@@ -5873,163 +5916,170 @@ function dexieCloud(dexie) {
     }));
     dexie.use(createImplicitPropSetterMiddleware(DexieCloudDB(dexie)));
     dexie.use(createIdGenerationMiddleware(DexieCloudDB(dexie)));
-    async function onDbReady(dexie) {
-        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:
-        if (!IS_SERVICE_WORKER) {
-            if (!db.cloud.options?.customLoginGui) {
-                subscriptions.push(setupDefaultGUI(dexie));
-            }
-            subscriptions.push(computeSyncState(db).subscribe(dexie.cloud.syncState));
-        }
-        //verifyConfig(db.cloud.options); Not needed (yet at least!)
-        // Verify the user has allowed version increment.
-        if (!db.tables.every((table) => table.core)) {
-            throwVersionIncrementNeeded();
-        }
-        const swRegistrations = 'serviceWorker' in navigator
-            ? await navigator.serviceWorker.getRegistrations()
-            : [];
-        const initiallySynced = await db.transaction('rw', db.$syncState, async () => {
-            const { options, schema } = db.cloud;
-            const [persistedOptions, persistedSchema, persistedSyncState] = await Promise.all([
-                db.getOptions(),
-                db.getSchema(),
-                db.getPersistedSyncState(),
-            ]);
-            if (!configuredProgramatically) {
-                // Options not specified programatically (use case for SW!)
-                // Take persisted options:
-                db.cloud.options = persistedOptions || null;
-            }
-            else if (!persistedOptions ||
-                JSON.stringify(persistedOptions) !== JSON.stringify(options)) {
-                // Update persisted options:
-                if (!options)
-                    throw new Error(`Internal error`); // options cannot be null if configuredProgramatically is set.
-                await db.$syncState.put(options, 'options');
-            }
-            if (db.cloud.options?.tryUseServiceWorker &&
-                'serviceWorker' in navigator &&
-                swRegistrations.length > 0 &&
-                !DISABLE_SERVICEWORKER_STRATEGY) {
-                // * Configured for using service worker if available.
-                // * Browser supports service workers
-                // * There are at least one service worker registration
-                console.debug('Dexie Cloud Addon: Using service worker');
-                db.cloud.usingServiceWorker = true;
+    function onDbReady(dexie) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        return __awaiter$1(this, void 0, void 0, function* () {
+            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:
+            if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+                if (!((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.customLoginGui)) {
+                    subscriptions.push(setupDefaultGUI(dexie));
+                }
             }
-            else {
-                // 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 (db.cloud.options?.tryUseServiceWorker && !IS_SERVICE_WORKER) {
-                    console.debug('dexie-cloud-addon: Not using service worker.', swRegistrations.length === 0
-                        ? 'No SW registrations found.'
-                        : 'serviceWorker' in navigator && DISABLE_SERVICEWORKER_STRATEGY
-                            ? 'Avoiding SW background sync and SW periodic bg sync for this browser due to browser bugs.'
-                            : 'navigator.serviceWorker not present');
+            if (!db.cloud.isServiceWorkerDB) {
+                subscriptions.push(computeSyncState(db).subscribe(dexie.cloud.syncState));
+            }
+            //verifyConfig(db.cloud.options); Not needed (yet at least!)
+            // Verify the user has allowed version increment.
+            if (!db.tables.every((table) => table.core)) {
+                throwVersionIncrementNeeded();
+            }
+            const swRegistrations = 'serviceWorker' in navigator
+                ? yield navigator.serviceWorker.getRegistrations()
+                : [];
+            const initiallySynced = yield db.transaction('rw', db.$syncState, () => __awaiter$1(this, void 0, void 0, function* () {
+                var _h, _j;
+                const { options, schema } = db.cloud;
+                const [persistedOptions, persistedSchema, persistedSyncState] = yield Promise.all([
+                    db.getOptions(),
+                    db.getSchema(),
+                    db.getPersistedSyncState(),
+                ]);
+                if (!configuredProgramatically) {
+                    // Options not specified programatically (use case for SW!)
+                    // Take persisted options:
+                    db.cloud.options = persistedOptions || null;
                 }
-                db.cloud.usingServiceWorker = false;
-            }
-            updateSchemaFromOptions(schema, db.cloud.options);
-            updateSchemaFromOptions(persistedSchema, db.cloud.options);
-            if (!schema) {
-                // Database opened dynamically (use case for SW!)
-                // Take persisted schema:
-                db.cloud.schema = persistedSchema || null;
-            }
-            else if (!persistedSchema ||
-                JSON.stringify(persistedSchema) !== JSON.stringify(schema)) {
-                // Update persisted schema (but don't overwrite table prefixes)
-                const newPersistedSchema = persistedSchema || {};
-                for (const [table, tblSchema] of Object.entries(schema)) {
-                    const newTblSchema = newPersistedSchema[table];
-                    if (!newTblSchema) {
-                        newPersistedSchema[table] = { ...tblSchema };
+                else if (!persistedOptions ||
+                    JSON.stringify(persistedOptions) !== JSON.stringify(options)) {
+                    // Update persisted options:
+                    if (!options)
+                        throw new Error(`Internal error`); // options cannot be null if configuredProgramatically is set.
+                    yield db.$syncState.put(options, 'options');
+                }
+                if (((_h = db.cloud.options) === null || _h === void 0 ? void 0 : _h.tryUseServiceWorker) &&
+                    'serviceWorker' in navigator &&
+                    swRegistrations.length > 0 &&
+                    !DISABLE_SERVICEWORKER_STRATEGY) {
+                    // * Configured for using service worker if available.
+                    // * Browser supports service workers
+                    // * There are at least one service worker registration
+                    console.debug('Dexie Cloud Addon: Using service worker');
+                    db.cloud.usingServiceWorker = true;
+                }
+                else {
+                    // 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) &&
+                        !db.cloud.isServiceWorkerDB) {
+                        console.debug('dexie-cloud-addon: Not using service worker.', swRegistrations.length === 0
+                            ? 'No SW registrations found.'
+                            : 'serviceWorker' in navigator && DISABLE_SERVICEWORKER_STRATEGY
+                                ? 'Avoiding SW background sync and SW periodic bg sync for this browser due to browser bugs.'
+                                : 'navigator.serviceWorker not present');
                     }
-                    else {
-                        newTblSchema.markedForSync = tblSchema.markedForSync;
-                        tblSchema.deleted = newTblSchema.deleted;
-                        newTblSchema.generatedGlobalId = tblSchema.generatedGlobalId;
+                    db.cloud.usingServiceWorker = false;
+                }
+                updateSchemaFromOptions(schema, db.cloud.options);
+                updateSchemaFromOptions(persistedSchema, db.cloud.options);
+                if (!schema) {
+                    // Database opened dynamically (use case for SW!)
+                    // Take persisted schema:
+                    db.cloud.schema = persistedSchema || null;
+                }
+                else if (!persistedSchema ||
+                    JSON.stringify(persistedSchema) !== JSON.stringify(schema)) {
+                    // Update persisted schema (but don't overwrite table prefixes)
+                    const newPersistedSchema = persistedSchema || {};
+                    for (const [table, tblSchema] of Object.entries(schema)) {
+                        const newTblSchema = newPersistedSchema[table];
+                        if (!newTblSchema) {
+                            newPersistedSchema[table] = Object.assign({}, tblSchema);
+                        }
+                        else {
+                            newTblSchema.markedForSync = tblSchema.markedForSync;
+                            tblSchema.deleted = newTblSchema.deleted;
+                            newTblSchema.generatedGlobalId = tblSchema.generatedGlobalId;
+                        }
                     }
+                    yield db.$syncState.put(newPersistedSchema, 'schema');
+                    // Make sure persisted table prefixes are being used instead of computed ones:
+                    // Let's assign all props as the newPersistedSchems should be what we should be working with.
+                    Object.assign(schema, newPersistedSchema);
                 }
-                await db.$syncState.put(newPersistedSchema, 'schema');
-                // Make sure persisted table prefixes are being used instead of computed ones:
-                // Let's assign all props as the newPersistedSchems should be what we should be working with.
-                Object.assign(schema, newPersistedSchema);
+                return persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.initiallySynced;
+            }));
+            if (initiallySynced) {
+                db.setInitiallySynced(true);
             }
-            return persistedSyncState?.initiallySynced;
-        });
-        if (initiallySynced) {
-            db.setInitiallySynced(true);
-        }
-        verifySchema(db);
-        if (db.cloud.options?.databaseUrl && !initiallySynced) {
-            await performInitialSync(db, db.cloud.options, db.cloud.schema);
-            db.setInitiallySynced(true);
-        }
-        // Manage CurrentUser observable:
-        throwIfClosed();
-        if (!IS_SERVICE_WORKER) {
-            subscriptions.push(liveQuery(() => db.getCurrentUser()).subscribe(currentUserEmitter));
-            // Manage PersistendSyncState observable:
-            subscriptions.push(liveQuery(() => db.getPersistedSyncState()).subscribe(db.cloud.persistedSyncState));
-            // Wait till currentUser and persistedSyncState gets populated
-            // with things from the database and not just the default values.
-            // This is so that when db.open() completes, user should be safe
-            // to subscribe to these observables and get actual data.
-            await combineLatest([
-                currentUserEmitter.pipe(skip(1), take(1)),
-                db.cloud.persistedSyncState.pipe(skip(1), take(1)),
-            ]).toPromise();
-        }
-        // HERE: If requireAuth, do athentication now.
-        if (db.cloud.options?.requireAuth) {
-            await login(db);
-        }
-        if (localSyncWorker)
-            localSyncWorker.stop();
-        localSyncWorker = null;
-        throwIfClosed();
-        if (db.cloud.usingServiceWorker && db.cloud.options?.databaseUrl) {
-            registerSyncEvent(db, 'push').catch(() => { });
-            registerPeriodicSyncEvent(db).catch(() => { });
-        }
-        else if (db.cloud.options?.databaseUrl &&
-            db.cloud.schema &&
-            !IS_SERVICE_WORKER) {
-            // There's no SW. Start SyncWorker instead.
-            localSyncWorker = LocalSyncWorker(db, db.cloud.options, db.cloud.schema);
-            localSyncWorker.start();
-            triggerSync(db, 'push');
-        }
-        // Listen to online event and do sync.
-        throwIfClosed();
-        if (!IS_SERVICE_WORKER) {
-            subscriptions.push(fromEvent(self, 'online').subscribe(() => {
-                console.debug('online!');
-                db.syncStateChangedEvent.next({
-                    phase: 'not-in-sync',
-                });
+            verifySchema(db);
+            if (((_b = db.cloud.options) === null || _b === void 0 ? void 0 : _b.databaseUrl) && !initiallySynced) {
+                yield performInitialSync(db, db.cloud.options, db.cloud.schema);
+                db.setInitiallySynced(true);
+            }
+            // Manage CurrentUser observable:
+            throwIfClosed();
+            if (!db.cloud.isServiceWorkerDB) {
+                subscriptions.push(liveQuery(() => db.getCurrentUser()).subscribe(currentUserEmitter));
+                // Manage PersistendSyncState observable:
+                subscriptions.push(liveQuery(() => db.getPersistedSyncState()).subscribe(db.cloud.persistedSyncState));
+                // Wait till currentUser and persistedSyncState gets populated
+                // with things from the database and not just the default values.
+                // This is so that when db.open() completes, user should be safe
+                // to subscribe to these observables and get actual data.
+                yield combineLatest([
+                    currentUserEmitter.pipe(skip(1), take(1)),
+                    db.cloud.persistedSyncState.pipe(skip(1), take(1)),
+                ]).toPromise();
+            }
+            // HERE: If requireAuth, do athentication now.
+            if ((_c = db.cloud.options) === null || _c === void 0 ? void 0 : _c.requireAuth) {
+                yield login(db);
+            }
+            if (localSyncWorker)
+                localSyncWorker.stop();
+            localSyncWorker = null;
+            throwIfClosed();
+            if (db.cloud.usingServiceWorker && ((_d = db.cloud.options) === null || _d === void 0 ? void 0 : _d.databaseUrl)) {
+                registerSyncEvent(db, 'push').catch(() => { });
+                registerPeriodicSyncEvent(db).catch(() => { });
+            }
+            else if (((_e = db.cloud.options) === null || _e === void 0 ? void 0 : _e.databaseUrl) &&
+                db.cloud.schema &&
+                !db.cloud.isServiceWorkerDB) {
+                // There's no SW. Start SyncWorker instead.
+                localSyncWorker = LocalSyncWorker(db, db.cloud.options, db.cloud.schema);
+                localSyncWorker.start();
                 triggerSync(db, 'push');
-            }), fromEvent(self, 'offline').subscribe(() => {
-                console.debug('offline!');
-                db.syncStateChangedEvent.next({
-                    phase: 'offline',
-                });
-            }));
-        }
-        // Connect WebSocket only if we're a browser window
-        if (typeof window !== 'undefined' &&
-            !IS_SERVICE_WORKER &&
-            db.cloud.options?.databaseUrl) {
-            subscriptions.push(connectWebSocket(db));
-        }
+            }
+            // Listen to online event and do sync.
+            throwIfClosed();
+            if (!db.cloud.isServiceWorkerDB) {
+                subscriptions.push(fromEvent(self, 'online').subscribe(() => {
+                    console.debug('online!');
+                    db.syncStateChangedEvent.next({
+                        phase: 'not-in-sync',
+                    });
+                    triggerSync(db, 'push');
+                }), fromEvent(self, 'offline').subscribe(() => {
+                    console.debug('offline!');
+                    db.syncStateChangedEvent.next({
+                        phase: 'offline',
+                    });
+                }));
+            }
+            // Connect WebSocket unless we
+            if (((_f = db.cloud.options) === null || _f === void 0 ? void 0 : _f.databaseUrl) &&
+                !((_g = db.cloud.options) === null || _g === void 0 ? void 0 : _g.disableWebSocket) &&
+                !IS_SERVICE_WORKER) {
+                subscriptions.push(connectWebSocket(db));
+            }
+        });
     }
 }
-dexieCloud.version = '4.0.0-beta.16';
+dexieCloud.version = '4.0.0-beta.19';
 Dexie.Cloud = dexieCloud;
 
 // In case the SW lives for a while, let it reuse already opened connections:
@@ -6058,55 +6108,61 @@ function syncDB(dbName, purpose) {
         syncDBSemaphore.set(dbName + '/' + purpose, promise);
     }
     return promise;
-    async function _syncDB(dbName, purpose) {
-        let db = managedDBs.get(dbName);
-        if (!db) {
-            console.debug('Dexie Cloud SW: Creating new Dexie instance for', dbName);
-            const dexie = new Dexie(dbName, { addons: [dexieCloud] });
-            db = DexieCloudDB(dexie);
-            dexie.on('versionchange', stopManagingDB);
-            await db.dx.open(); // Makes sure db.cloud.options and db.cloud.schema are read from db,
-            if (!managedDBs.get(dbName)) {
-                // Avoid race conditions.
+    function _syncDB(dbName, purpose) {
+        var _a;
+        return __awaiter$1(this, void 0, void 0, function* () {
+            let db = managedDBs.get(dbName);
+            if (!db) {
+                console.debug('Dexie Cloud SW: Creating new Dexie instance for', dbName);
+                const dexie = new Dexie(dbName, { addons: [dexieCloud] });
+                db = DexieCloudDB(dexie);
+                db.cloud.isServiceWorkerDB = true;
+                dexie.on('versionchange', stopManagingDB);
+                yield db.dx.open(); // Makes sure db.cloud.options and db.cloud.schema are read from db,
+                if (managedDBs.get(dbName)) {
+                    // Avoid race conditions.
+                    db.close();
+                    return yield _syncDB(dbName, purpose);
+                }
                 managedDBs.set(dbName, db);
             }
-        }
-        if (!db.cloud.options?.databaseUrl) {
-            console.error(`Dexie Cloud: No databaseUrl configured`);
-            return; // Nothing to sync.
-        }
-        if (!db.cloud.schema) {
-            console.error(`Dexie Cloud: No schema persisted`);
-            return; // Nothing to sync.
-        }
-        function stopManagingDB() {
-            db.dx.on.versionchange.unsubscribe(stopManagingDB);
-            if (managedDBs.get(db.name) === db) {
-                // Avoid race conditions.
-                managedDBs.delete(db.name);
+            if (!((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.databaseUrl)) {
+                console.error(`Dexie Cloud: No databaseUrl configured`);
+                return; // Nothing to sync.
             }
-            console.debug(`Dexie Cloud SW: Closing Dexie instance for ${dbName}`);
-            db.dx.close();
-            return false;
-        }
-        try {
-            console.debug('Dexie Cloud SW: Syncing');
-            await syncIfPossible(db, db.cloud.options, db.cloud.schema, {
-                retryImmediatelyOnFetchError: true,
-                purpose,
-            });
-            console.debug('Dexie Cloud SW: Done Syncing');
-        }
-        catch (e) {
-            console.error(`Dexie Cloud SW Error`, e);
-            // Error occured. Stop managing this DB until we wake up again by a sync event,
-            // which will open a new Dexie and start trying to sync it.
-            stopManagingDB();
-            if (e.name !== Dexie.errnames.NoSuchDatabase) {
-                // Unless the error was that DB doesn't exist, rethrow to trigger sync retry.
-                throw e; // Throw e to make syncEvent.waitUntil() receive a rejected promis, so it will retry.
+            if (!db.cloud.schema) {
+                console.error(`Dexie Cloud: No schema persisted`);
+                return; // Nothing to sync.
             }
-        }
+            function stopManagingDB() {
+                db.dx.on.versionchange.unsubscribe(stopManagingDB);
+                if (managedDBs.get(db.name) === db) {
+                    // Avoid race conditions.
+                    managedDBs.delete(db.name);
+                }
+                console.debug(`Dexie Cloud SW: Closing Dexie instance for ${dbName}`);
+                db.dx.close();
+                return false;
+            }
+            try {
+                console.debug('Dexie Cloud SW: Syncing');
+                yield syncIfPossible(db, db.cloud.options, db.cloud.schema, {
+                    retryImmediatelyOnFetchError: true,
+                    purpose,
+                });
+                console.debug('Dexie Cloud SW: Done Syncing');
+            }
+            catch (e) {
+                console.error(`Dexie Cloud SW Error`, e);
+                // Error occured. Stop managing this DB until we wake up again by a sync event,
+                // which will open a new Dexie and start trying to sync it.
+                stopManagingDB();
+                if (e.name !== Dexie.errnames.NoSuchDatabase) {
+                    // Unless the error was that DB doesn't exist, rethrow to trigger sync retry.
+                    throw e; // Throw e to make syncEvent.waitUntil() receive a rejected promis, so it will retry.
+                }
+            }
+        });
     }
 }
 // Avoid taking care of events if browser bugs out by using dexie cloud from a service worker.
@@ -6132,12 +6188,12 @@ if (!DISABLE_SERVICEWORKER_STRATEGY) {
             // Mimic background sync behavior - retry in X minutes on failure.
             // But lesser timeout and more number of times.
             const syncAndRetry = (num = 1) => {
-                return syncDB(dbName, event.data.purpose || "pull").catch(async (e) => {
+                return syncDB(dbName, event.data.purpose || "pull").catch((e) => __awaiter$1(void 0, void 0, void 0, function* () {
                     if (num === 3)
                         throw e;
-                    await sleep(60000); // 1 minute
+                    yield sleep(60000); // 1 minute
                     syncAndRetry(num + 1);
-                });
+                }));
             };
             if ('waitUntil' in event) {
                 event.waitUntil(syncAndRetry().catch(error => console.error(error)));