dexie-cloud-addon 4.0.0-beta.15 → 4.0.0-beta.18

package/dist/umd-modern/dexie-cloud-addon.js

@@ -26,6 +26,31 @@
 
     var Dexie__default = /*#__PURE__*/_interopDefaultLegacy(Dexie);
 
+    /*! *****************************************************************************
+    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());
+        });
+    }
+
     //@ts-check
     const randomFillSync = crypto.getRandomValues;
 
@@ -1909,55 +1934,60 @@
 
     //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) {
@@ -1989,19 +2019,15 @@
     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__default["default"].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) => {
@@ -2022,180 +2048,193 @@
             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);
@@ -2231,9 +2270,11 @@
                 lastLogin: new Date(0)
             }));
         }
-        async save() {
-            const db = wm$1.get(this);
-            db.table("$logins").put(this);
+        save() {
+            return __awaiter$1(this, void 0, void 0, function* () {
+                const db = wm$1.get(this);
+                db.table("$logins").put(this);
+            });
         }
     }
 
@@ -2249,92 +2290,95 @@
 
     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`);
-            }
+            });
         };
     }
 
@@ -2349,83 +2393,87 @@
      * @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`);
                     }
-                });
-            }
-        });
-        // 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;
             }
-            // Already authenticated according to given hints.
-            return;
-        }
-        const context = new AuthPersistedContext(db, {
-            claims: {},
-            lastLogin: new Date(0),
+            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");
         });
-        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");
     }
 
     const UNAUTHORIZED_USER = {
@@ -2440,7 +2488,7 @@
         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
@@ -2449,8 +2497,9 @@
     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); });
             }
         });
     }
@@ -2462,7 +2511,8 @@
             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);
                 }
             };
@@ -2470,6 +2520,7 @@
             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({
@@ -2480,7 +2531,7 @@
             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
                 });
@@ -2523,22 +2574,24 @@
             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);
         }
     }
 
-    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) {
@@ -2553,7 +2606,8 @@
     }
 
     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;
@@ -2564,49 +2618,51 @@
         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(bytes) {
@@ -2615,58 +2671,60 @@
         return btoa(String.fromCharCode.apply(null, buf));
     }
 
-    async function listSyncifiedChanges(tablesToSyncify, currentUser, schema, alreadySyncedRealms) {
-        const txid = `upload-${randomString(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(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;
@@ -3188,23 +3246,17 @@
             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);
 
@@ -3253,110 +3305,107 @@
     }
     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}`;
             }
-        }
+            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);
+            }
+            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;
+                }
+            }
+        });
     }
 
-    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;
-                    }
-                });
-            }
-            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;
-                    }
-                });
-            }
-            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__default["default"].AbortError(`Operation was cancelled`);
     }
 
@@ -3368,17 +3417,19 @@
     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 = {}) {
@@ -3389,104 +3440,108 @@
         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 (Dexie.cmp(value, key) !== 0) {
-                            throw new Error(`Cannot change primary 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 (Dexie.cmp(value, key) !== 0) {
+                                throw new Error(`Cannot change primary key`);
+                            }
+                        }
+                        else {
+                            Dexie__default["default"].setByKeyPath(obj, keyPath, value);
                         }
                     }
-                    else {
-                        Dexie__default["default"].setByKeyPath(obj, keyPath, value);
-                    }
+                    resultKeys.push(key);
+                    resultObjs.push(obj);
                 }
-                resultKeys.push(key);
-                resultObjs.push(obj);
-            }
+            });
+            yield (table.schema.primKey.keyPath == null
+                ? table.bulkPut(resultObjs, resultKeys)
+                : table.bulkPut(resultObjs));
         });
-        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__default["default"].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 applyServerChanges(changes, db) {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            console.debug('Applying server changes', changes, Dexie__default["default"].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);
                             }
-                            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__default["default"].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__default["default"].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);
-                        }
-                        break;
-                    case 'update':
-                        await bulkUpdate(table, keys, mut.changeSpecs);
-                        break;
-                    case 'delete':
-                        await table.bulkDelete(keys);
-                        break;
+                            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__default["default"].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__default["default"].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';
@@ -3494,14 +3549,14 @@
         return _sync
             .apply(this, arguments)
             .then(() => {
-            if (!syncOptions?.justCheckIfNeeded) {
+            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,
@@ -3509,23 +3564,20 @@
                 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,
             });
@@ -3534,234 +3586,239 @@
                 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$1(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$1(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 = {};
@@ -3779,7 +3836,7 @@
         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) {
@@ -3788,7 +3845,7 @@
                 loopDetection.push(Date.now());
                 readyToServe.next(false);
                 try {
-                    await consumeQueue();
+                    yield consumeQueue();
                 }
                 finally {
                     if (loopDetection[loopDetection.length - 1] - loopDetection[0] <
@@ -3798,170 +3855,173 @@
                             // 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__default["default"].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__default["default"].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,
@@ -4106,9 +4166,10 @@
         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()) +
@@ -4199,9 +4260,7 @@
             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;
@@ -4227,24 +4286,19 @@
                                         `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) => {
@@ -4258,7 +4312,7 @@
                                         }
                                     }
                                     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.
@@ -4279,10 +4333,8 @@
                                     }
                                 }
                                 return table.mutate(req);
-                            },
-                        };
-                    },
-                };
+                            } });
+                    } });
             },
         };
     }
@@ -4293,19 +4345,16 @@
             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),
@@ -4319,7 +4368,7 @@
                                             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
@@ -4346,10 +4395,8 @@
                                     }
                                 }
                                 return table.mutate(req);
-                            },
-                        };
-                    },
-                };
+                            } });
+                    } });
             },
         };
     }
@@ -4368,15 +4415,7 @@
     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) {
@@ -4426,16 +4465,14 @@
                         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);
                         }
@@ -4458,7 +4495,8 @@
                                 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");
@@ -4474,8 +4512,7 @@
                             tx.addEventListener('abort', removeTransaction);
                         }
                         return tx;
-                    },
-                    table: (tableName) => {
+                    }, table: (tableName) => {
                         const table = core.table(tableName);
                         if (/^\$/.test(tableName)) {
                             if (tableName.endsWith('_mutations')) {
@@ -4483,20 +4520,15 @@
                                 // 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)
@@ -4510,8 +4542,7 @@
                                             console.debug('Failed mutation $logins', err);
                                             return Promise.reject(err);
                                         });
-                                    }
-                                };
+                                    } });
                             }
                             else {
                                 return table;
@@ -4519,17 +4550,16 @@
                         }
                         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);
@@ -4552,8 +4582,7 @@
                                         });
                                     })
                                     : mutateAndLog(req);
-                            }
-                        });
+                            } }));
                         function mutateAndLog(req) {
                             const trans = req.trans;
                             trans.mutationsAdded = true;
@@ -4624,18 +4653,14 @@
                                     : 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 => {
@@ -4667,110 +4692,15 @@
         };
     }
 
-    const SECONDS = 1000;
-    const MINUTES = 60 * SECONDS;
-
-    const myId = randomString(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 = rxjs.from(Dexie.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 = 300000; // 300_000;
+    const USER_INACTIVITY_TIMEOUT = 180000; // 3 minutes
     const INACTIVE_WAIT_TIME = 20000;
     // This observable will be emitted to later down....
     const userIsActive = new rxjs.BehaviorSubject(true);
@@ -4784,9 +4714,13 @@
     //   for just a short time.
     const userIsReallyActive = new rxjs.BehaviorSubject(true);
     userIsActive
-        .pipe(switchMap((isActive) => isActive
-        ? rxjs.of(true)
-        : rxjs.of(false).pipe(delay(INACTIVE_WAIT_TIME))), distinctUntilChanged())
+        .pipe(switchMap((isActive) => {
+        //console.debug('SyncStatus: DUBB: isActive changed to', isActive);
+        return isActive
+            ? rxjs.of(true)
+            : rxjs.of(false).pipe(delay(INACTIVE_WAIT_TIME))
+                ;
+    }), distinctUntilChanged())
         .subscribe(userIsReallyActive);
     //
     // First create some corner-stone observables to build the flow on
@@ -4801,7 +4735,7 @@
     const documentBecomesVisible = visibilityStateIsChanged.pipe(filter(() => document.visibilityState === 'visible'));
     // Any of various user-activity-related events happen:
     const userDoesSomething = typeof window !== 'undefined'
-        ? rxjs.merge(documentBecomesVisible, rxjs.fromEvent(window, 'mousemove'), rxjs.fromEvent(window, 'keydown'), rxjs.fromEvent(window, 'wheel'), rxjs.fromEvent(window, 'touchmove'))
+        ? rxjs.merge(documentBecomesVisible, rxjs.fromEvent(window, 'mousedown'), rxjs.fromEvent(window, 'mousemove'), rxjs.fromEvent(window, 'keydown'), rxjs.fromEvent(window, 'wheel'), rxjs.fromEvent(window, 'touchmove'))
         : rxjs.of({});
     if (typeof document !== 'undefined') {
         //
@@ -4852,6 +4786,7 @@
         constructor(databaseUrl, rev, realmSetHash, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus) {
             super(() => this.teardown());
             this.id = ++counter;
+            this.reconnecting = false;
             console.debug('New WebSocket Connection', this.id, token ? 'authorized' : 'unauthorized');
             this.databaseUrl = databaseUrl;
             this.rev = rev;
@@ -4871,7 +4806,7 @@
             this.disconnect();
         }
         disconnect() {
-            this.webSocketStatus.next("disconnected");
+            this.webSocketStatus.next('disconnected');
             if (this.pinger) {
                 clearInterval(this.pinger);
                 this.pinger = null;
@@ -4880,7 +4815,7 @@
                 try {
                     this.ws.close();
                 }
-                catch { }
+                catch (_a) { }
             }
             this.ws = null;
             if (this.messageProducerSubscription) {
@@ -4889,158 +4824,180 @@
             }
         }
         reconnect() {
-            this.disconnect();
-            this.connect();
-        }
-        async connect() {
-            this.webSocketStatus.next("connecting");
-            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) {
-                return;
-            }
-            if (this.tokenExpiration && this.tokenExpiration < new Date()) {
-                this.subscriber.error(new TokenExpiredError()); // Will be handled in connectWebSocket.ts.
+            if (this.reconnecting)
                 return;
+            this.reconnecting = true;
+            try {
+                this.disconnect();
             }
-            this.pinger = setInterval(async () => {
-                if (this.closed) {
-                    console.debug('pinger check', this.id, 'CLOSED.');
-                    this.teardown();
+            catch (_a) { }
+            this.connect()
+                .catch(() => { })
+                .then(() => (this.reconnecting = false)); // finally()
+        }
+        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 {
-                await new Promise((resolve, reject) => {
-                    ws.onopen = (event) => {
-                        console.debug('dexie-cloud WebSocket onopen');
-                        resolve(null);
-                    };
-                    ws.onerror = (event) => {
-                        const error = event.error || new Error('WebSocket Error');
-                        this.disconnect();
-                        this.subscriber.error(error);
-                        this.webSocketStatus.next("error");
-                        reject(error);
-                    };
-                });
-                this.messageProducerSubscription = this.messageProducer.subscribe(msg => {
-                    if (!this.closed) {
-                        if (msg.type === 'ready' && this.webSocketStatus.value !== 'connected') {
-                            this.webSocketStatus.next("connected");
+                // 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}`);
+                        }
+                        if (msg.type === 'rev') {
+                            this.rev = msg.rev; // No meaning but seems reasonable.
+                        }
+                        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(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(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(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
@@ -5052,32 +5009,35 @@
             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)
                 : rxjs.from([])), 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 rxjs.of(true).pipe(switchMap(async () => {
+                    return rxjs.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 rxjs.throwError(error);
                 }
-            }), catchError((error) => rxjs.from(waitAndReconnectWhenUserDoesSomething(error)).pipe(switchMap(() => createObservable()))));
+            }), catchError((error) => {
+                db.cloud.webSocketStatus.next("error");
+                return rxjs.from(waitAndReconnectWhenUserDoesSomething(error)).pipe(switchMap(() => createObservable()));
+            }));
         }
         return createObservable().subscribe((msg) => {
             if (msg) {
@@ -5091,17 +5051,113 @@
         });
     }
 
-    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(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 = rxjs.from(Dexie.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;
             }
@@ -5143,32 +5199,34 @@
             }
         }
         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.usingServiceWorker) {
+                        if (IS_SERVICE_WORKER) {
+                            yield sync(db, cloudOptions, cloudSchema, options);
+                        }
+                    }
+                    else {
+                        // 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));
                     }
+                    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()
-            }
+            });
         }
     }
 
@@ -5238,8 +5296,9 @@
     }
 
     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__default["default"].SchemaError(`Table ${table.name} is both autoIncremented and synced. ` +
                         `Use db.cloud.configure({unsyncedTables: [${JSON.stringify(table.name)}]}) to blacklist it from sync`);
@@ -5332,7 +5391,7 @@
     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),
@@ -5342,7 +5401,7 @@
                         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"))));
@@ -5374,7 +5433,7 @@
             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) {
@@ -5501,6 +5560,21 @@
         return rv;
     }
 
+    const getGlobalRolesObservable = associate((db) => {
+        return createSharedValueObservable(Dexie.liveQuery(() => db.roles
+            .where({ realmId: 'rlm-public' })
+            .toArray()
+            .then((roles) => {
+            const rv = {};
+            for (const role of roles
+                .slice()
+                .sort((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0))) {
+                rv[role.name] = role;
+            }
+            return rv;
+        })), {});
+    });
+
     const getCurrentUserEmitter = associate((db) => new rxjs.BehaviorSubject(UNAUTHORIZED_USER));
 
     const getInternalAccessControlObservable = associate((db) => {
@@ -5545,7 +5619,7 @@
         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] === '*')
@@ -5602,19 +5676,36 @@
     }
 
     const getPermissionsLookupObservable = associate((db) => {
-        const o = getInternalAccessControlObservable(db._novip);
-        return mapValueObservable(o, ({ selfMembers, realms, userId }) => {
+        const o = createSharedValueObservable(rxjs.combineLatest([
+            getInternalAccessControlObservable(db._novip),
+            getGlobalRolesObservable(db._novip),
+        ]).pipe(map(([{ selfMembers, realms, userId }, globalRoles]) => ({
+            selfMembers,
+            realms,
+            userId,
+            globalRoles,
+        }))), {
+            selfMembers: [],
+            realms: [],
+            userId: UNAUTHORIZED_USER.userId,
+            globalRoles: {},
+        });
+        return mapValueObservable(o, ({ selfMembers, realms, userId, globalRoles }) => {
             const rv = realms
-                .map((realm) => ({
-                ...realm,
-                permissions: realm.owner === userId
-                    ? { manage: '*' }
-                    : mergePermissions(...selfMembers
-                        .filter((m) => m.realmId === realm.realmId)
-                        .map((m) => m.permissions)
-                        .filter((p) => p)),
-            }))
-                .reduce((p, c) => ({ ...p, [c.realmId]: c }), {
+                .map((realm) => {
+                const selfRealmMembers = selfMembers.filter((m) => m.realmId === realm.realmId);
+                const directPermissionSets = selfRealmMembers
+                    .map((m) => m.permissions)
+                    .filter((p) => p);
+                const rolePermissionSets = flatten(selfRealmMembers.map((m) => m.roles).filter((roleName) => roleName))
+                    .map((role) => globalRoles[role])
+                    .filter((role) => role)
+                    .map((role) => role.permissions);
+                return Object.assign(Object.assign({}, realm), { permissions: realm.owner === userId
+                        ? { manage: '*' }
+                        : mergePermissions(...directPermissionSets, ...rolePermissionSets) });
+            })
+                .reduce((p, c) => (Object.assign(Object.assign({}, p), { [c.realmId]: c })), {
                 [userId]: {
                     realmId: userId,
                     owner: userId,
@@ -5633,47 +5724,50 @@
             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;
         }
@@ -5697,7 +5791,7 @@
             const realm = permissionsLookup[realmId || dexie.cloud.currentUserId];
             if (!realm)
                 return new PermissionChecker({}, tableName, !owner || owner === dexie.cloud.currentUserId);
-            return new PermissionChecker(realm.permissions, tableName, !owner || owner === dexie.cloud.currentUserId);
+            return new PermissionChecker(realm.permissions, tableName, realmId === dexie.cloud.currentUserId || owner === dexie.cloud.currentUserId);
         };
         const o = source.pipe(map(mapper));
         o.getValue = () => mapper(source.getValue());
@@ -5709,7 +5803,7 @@
         const permissions = getPermissionsLookupObservable(db._novip);
         const accessControl = getInternalAccessControlObservable(db._novip);
         return createSharedValueObservable(rxjs.combineLatest([membersByEmail, accessControl, permissions]).pipe(rxjs.map(([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);
@@ -5736,15 +5830,15 @@
         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;
@@ -5761,7 +5855,7 @@
         });
         dexie.cloud = {
             version: '{version}',
-            options: { ...DEFAULT_OPTIONS },
+            options: Object.assign({}, DEFAULT_OPTIONS),
             schema: null,
             serverState: null,
             get currentUserId() {
@@ -5775,14 +5869,17 @@
             persistedSyncState: new rxjs.BehaviorSubject(undefined),
             userInteraction: new rxjs.BehaviorSubject(undefined),
             webSocketStatus: new rxjs.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
@@ -5791,41 +5888,43 @@
                 }
                 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 rxjs.from(Dexie.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 rxjs.from(Dexie.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);
@@ -5837,7 +5936,8 @@
             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,
@@ -5845,160 +5945,164 @@
         }));
         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;
-                }
-                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');
+        function onDbReady(dexie) {
+            var _a, _b, _c, _d, _e, _f;
+            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 (!IS_SERVICE_WORKER) {
+                    if (!((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.customLoginGui)) {
+                        subscriptions.push(setupDefaultGUI(dexie));
                     }
-                    db.cloud.usingServiceWorker = false;
+                    subscriptions.push(computeSyncState(db).subscribe(dexie.cloud.syncState));
                 }
-                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;
+                //verifyConfig(db.cloud.options); Not needed (yet at least!)
+                // Verify the user has allowed version increment.
+                if (!db.tables.every((table) => table.core)) {
+                    throwVersionIncrementNeeded();
                 }
-                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 };
+                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 _g, _h;
+                    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;
+                    }
+                    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 (((_g = db.cloud.options) === null || _g === void 0 ? void 0 : _g.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 (((_h = db.cloud.options) === null || _h === void 0 ? void 0 : _h.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');
                         }
-                        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(Dexie.liveQuery(() => db.getCurrentUser()).subscribe(currentUserEmitter));
-                // Manage PersistendSyncState observable:
-                subscriptions.push(Dexie.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 rxjs.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(rxjs.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 (!IS_SERVICE_WORKER) {
+                    subscriptions.push(Dexie.liveQuery(() => db.getCurrentUser()).subscribe(currentUserEmitter));
+                    // Manage PersistendSyncState observable:
+                    subscriptions.push(Dexie.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 rxjs.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 &&
+                    !IS_SERVICE_WORKER) {
+                    // There's no SW. Start SyncWorker instead.
+                    localSyncWorker = LocalSyncWorker(db, db.cloud.options, db.cloud.schema);
+                    localSyncWorker.start();
                     triggerSync(db, 'push');
-                }), rxjs.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 (!IS_SERVICE_WORKER) {
+                    subscriptions.push(rxjs.fromEvent(self, 'online').subscribe(() => {
+                        console.debug('online!');
+                        db.syncStateChangedEvent.next({
+                            phase: 'not-in-sync',
+                        });
+                        triggerSync(db, 'push');
+                    }), rxjs.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 &&
+                    ((_f = db.cloud.options) === null || _f === void 0 ? void 0 : _f.databaseUrl)) {
+                    subscriptions.push(connectWebSocket(db));
+                }
+            });
         }
     }
     dexieCloud.version = '{version}';