dexie-cloud-addon 1.0.0-beta.10 → 1.0.0-beta.11

package/dist/umd/service-worker.js

@@ -2127,1234 +2127,1218 @@
         return timeoutWith(due, throwError(new TimeoutError()), scheduler);
     }
 
-    const { toString: toStr } = {};
-    function getToStringTag(val) {
-        return toStr.call(val).slice(8, -1);
-    }
-    function escapeDollarProps(value) {
-        const keys = Object.keys(value);
-        let dollarKeys = null;
-        for (let i = 0, l = keys.length; i < l; ++i) {
-            if (keys[i][0] === "$") {
-                dollarKeys = dollarKeys || [];
-                dollarKeys.push(keys[i]);
+    //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 {
+                console.error(`Dexie Cloud: There's no active service worker. Can this ever happen??`);
+            }
+            return;
         }
-        if (!dollarKeys)
-            return value;
-        const clone = { ...value };
-        for (const k of dollarKeys) {
-            delete clone[k];
-            clone["$" + k] = value[k];
+        catch (e) {
+            if (!hasComplainedAboutSyncEvent) {
+                console.debug(`Dexie Cloud: Could not register sync event`, e);
+                hasComplainedAboutSyncEvent = true;
+            }
         }
-        return clone;
     }
-    const ObjectDef = {
-        replace: escapeDollarProps,
-    };
-    function TypesonSimplified(...typeDefsInputs) {
-        const typeDefs = typeDefsInputs.reduce((p, c) => ({ ...p, ...c }), typeDefsInputs.reduce((p, c) => ({ ...c, ...p }), {}));
-        const protoMap = new WeakMap();
-        return {
-            stringify(value, alternateChannel, space) {
-                const json = JSON.stringify(value, function (key) {
-                    const realVal = this[key];
-                    const typeDef = getTypeDef(realVal);
-                    return typeDef
-                        ? typeDef.replace(realVal, alternateChannel, typeDefs)
-                        : realVal;
-                }, space);
-                return json;
-            },
-            parse(tson, alternateChannel) {
-                let parent = null;
-                let unescapeParentKeys = [];
-                return JSON.parse(tson, function (key, value) {
-                    //
-                    // Parent Part
-                    //
-                    const type = value === null || value === void 0 ? void 0 : value.$t;
-                    if (type) {
-                        const typeDef = typeDefs[type];
-                        value = typeDef
-                            ? typeDef.revive(value, alternateChannel, typeDefs)
-                            : value;
-                    }
-                    if (value === parent) {
-                        // Do what the kid told us to
-                        if (unescapeParentKeys.length > 0) {
-                            // Unescape dollar props
-                            value = { ...value };
-                            for (const k of unescapeParentKeys) {
-                                value[k.substr(1)] = value[k];
-                                delete value[k];
-                            }
-                        }
-                        unescapeParentKeys = [];
-                        return value;
-                    }
-                    //
-                    // Child part
-                    //
-                    if (key[0] === "$" && key !== "$t") {
-                        parent = this;
-                        unescapeParentKeys.push(key);
-                    }
-                    return value;
-                });
-            },
-        };
-        function getTypeDef(realVal) {
-            const type = typeof realVal;
-            switch (typeof realVal) {
-                case "object":
-                case "function": {
-                    // "object", "function", null
-                    if (realVal === null)
-                        return null;
-                    const proto = Object.getPrototypeOf(realVal);
-                    if (!proto)
-                        return ObjectDef;
-                    let typeDef = protoMap.get(proto);
-                    if (typeDef !== undefined)
-                        return typeDef; // Null counts to! So the caching of Array.prototype also counts.
-                    const toStringTag = getToStringTag(realVal);
-                    const entry = Object.entries(typeDefs).find(([typeName, typeDef]) => { var _a, _b; return (_b = (_a = typeDef === null || typeDef === void 0 ? void 0 : typeDef.test) === null || _a === void 0 ? void 0 : _a.call(typeDef, realVal, toStringTag)) !== null && _b !== void 0 ? _b : typeName === toStringTag; });
-                    typeDef = entry === null || entry === void 0 ? void 0 : entry[1];
-                    if (!typeDef) {
-                        typeDef = Array.isArray(realVal)
-                            ? null
-                            : typeof realVal === "function"
-                                ? typeDefs.function || null
-                                : ObjectDef;
-                    }
-                    protoMap.set(proto, typeDef);
-                    return typeDef;
+    async function registerPeriodicSyncEvent(db) {
+        var _a;
+        try {
+            // Register periodicSync event to SW:
+            // @ts-ignore
+            const { periodicSync } = await navigator.serviceWorker.ready;
+            if (periodicSync) {
+                try {
+                    await 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);
                 }
-                default:
-                    return typeDefs[type];
             }
+            else {
+                console.debug(`Dexie Cloud: periodicSync not supported.`);
+            }
+        }
+        catch (e) {
+            console.debug(`Dexie Cloud: Could not register periodicSync for ${db.name}`, e);
         }
     }
 
-    const BisonBinaryTypes = {
-        Blob: {
-            test: (blob, toStringTag) => toStringTag === "Blob",
-            replace: (blob, altChannel) => {
-                const i = altChannel.length;
-                altChannel.push(blob);
-                return {
-                    $t: "Blob",
-                    mimeType: blob.type,
-                    i,
-                };
-            },
-            revive: ({ i, mimeType }, altChannel) => new Blob([altChannel[i]], { type: mimeType }),
-        },
-    };
-
-    var numberDef = {
-        number: {
-            replace: (num) => {
-                switch (true) {
-                    case isNaN(num):
-                        return { $t: "number", v: "NaN" };
-                    case num === Infinity:
-                        return { $t: "number", v: "Infinity" };
-                    case num === -Infinity:
-                        return { $t: "number", v: "-Infinity" };
-                    default:
-                        return num;
-                }
-            },
-            revive: ({ v }) => Number(v),
-        },
-    };
+    function triggerSync(db, purpose) {
+        if (db.cloud.usingServiceWorker) {
+            registerSyncEvent(db, purpose);
+        }
+        else {
+            db.localSyncEvent.next({ purpose });
+        }
+    }
 
-    const bigIntDef = {
-        bigint: {
-            replace: (realVal) => {
-                return { $t: "bigint", v: "" + realVal };
-            },
-            revive: (obj) => BigInt(obj.v),
-        },
-    };
+    const b64decode = typeof Buffer !== "undefined"
+        ? (base64) => Buffer.from(base64, "base64")
+        : (base64) => {
+            const binary_string = atob(base64);
+            const len = binary_string.length;
+            const bytes = new Uint8Array(len);
+            for (var i = 0; i < len; i++) {
+                bytes[i] = binary_string.charCodeAt(i);
+            }
+            return bytes;
+        };
+    const b64encode = typeof Buffer !== "undefined"
+        ? (b) => ArrayBuffer.isView(b)
+            ? Buffer.from(b.buffer, b.byteOffset, b.byteLength).toString("base64")
+            : Buffer.from(b).toString("base64")
+        : (b) => btoa(String.fromCharCode.apply(null, b));
 
-    var DateDef = {
-        Date: {
-            replace: (date) => ({
-                $t: "Date",
-                v: isNaN(date.getTime()) ? "NaN" : date.toISOString(),
-            }),
-            revive: ({ v }) => new Date(v === "NaN" ? NaN : Date.parse(v)),
-        },
-    };
+    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;
+    }
 
-    var SetDef = {
-        Set: {
-            replace: (set) => ({
-                $t: "Set",
-                v: Array.from(set.entries()),
-            }),
-            revive: ({ v }) => new Set(v),
-        },
-    };
+    function getSyncableTables(db) {
+        return Object.entries(db.cloud.schema || {})
+            .filter(([, { markedForSync }]) => markedForSync)
+            .map(([tbl]) => db.table(tbl));
+    }
 
-    var MapDef = {
-        Map: {
-            replace: (map) => ({
-                $t: "Map",
-                v: Array.from(map.entries()),
-            }),
-            revive: ({ v }) => new Map(v),
-        },
-    };
+    function getMutationTable(tableName) {
+        return `$${tableName}_mutations`;
+    }
 
-    const _global = typeof globalThis !== "undefined"
-        ? globalThis
-        : typeof self !== "undefined"
-            ? self
-            : typeof global === "undefined"
-                ? global
-                : undefined;
+    function getTableFromMutationTable(mutationTable) {
+        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;
+    }
 
-    var TypedArraysDefs = [
-        "Int8Array",
-        "Uint8Array",
-        "Uint8ClampedArray",
-        "Int16Array",
-        "Uint16Array",
-        "Int32Array",
-        "Uint32Array",
-        "Float32Array",
-        "Float64Array",
-        "DataView",
-        "BigInt64Array",
-        "BigUint64Array",
-    ].reduce((specs, typeName) => ({
-        ...specs,
-        [typeName]: {
-            // Replace passes the the typed array into $t, buffer so that
-            // the ArrayBuffer typedef takes care of further handling of the buffer:
-            // {$t:"Uint8Array",buffer:{$t:"ArrayBuffer",idx:0}}
-            // CHANGED ABOVE! Now shortcutting that for more sparse format of the typed arrays
-            // to contain the b64 property directly.
-            replace: (a, _, typeDefs) => {
-                const result = {
-                    $t: typeName,
-                    v: typeDefs.ArrayBuffer.replace(a.byteOffset === 0 && a.byteLength === a.buffer.byteLength
-                        ? a.buffer
-                        : a.buffer.slice(a.byteOffset, a.byteOffset + a.byteLength), _, typeDefs).v,
-                };
-                return result;
-            },
-            revive: ({ v }, _, typeDefs) => {
-                const TypedArray = _global[typeName];
-                return (TypedArray &&
-                    new TypedArray(typeDefs.ArrayBuffer.revive({ v }, _, typeDefs)));
-            },
-        },
-    }), {});
+    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 {
+                table: tableName,
+                muts,
+            };
+        }));
+        // Filter out those tables that doesn't have any mutations:
+        return allMutsOnTables.filter(({ muts }) => muts.length > 0);
+    }
 
-    const b64decode = typeof Buffer !== "undefined"
-        ? (base64) => Buffer.from(base64, "base64")
-        : (base64) => {
-            const binary_string = atob(base64);
-            const len = binary_string.length;
-            const bytes = new Uint8Array(len);
-            for (var i = 0; i < len; i++) {
-                bytes[i] = binary_string.charCodeAt(i);
-            }
-            return bytes;
-        };
-    const b64encode = typeof Buffer !== "undefined"
-        ? (b) => ArrayBuffer.isView(b)
-            ? Buffer.from(b.buffer, b.byteOffset, b.byteLength).toString("base64")
-            : Buffer.from(b).toString("base64")
-        : (b) => btoa(String.fromCharCode.apply(null, b));
+    //@ts-check
+    const randomFillSync = crypto.getRandomValues;
 
-    function b64LexEncode(b) {
-        return b64ToLex(b64encode(b));
-    }
-    function b64LexDecode(b64Lex) {
-        return b64decode(lexToB64(b64Lex));
-    }
-    function b64ToLex(base64) {
-        var encoded = "";
-        for (var i = 0, length = base64.length; i < length; i++) {
-            encoded += ENCODE_TABLE[base64[i]];
-        }
-        return encoded;
+    function assert(b) {
+        if (!b)
+            throw new Error('Assertion Failed');
     }
-    function lexToB64(base64lex) {
-        // only accept string input
-        if (typeof base64lex !== "string") {
-            throw new Error("invalid decoder input: " + base64lex);
+    function setByKeyPath(obj, keyPath, value) {
+        if (!obj || keyPath === undefined)
+            return;
+        if ('isFrozen' in Object && Object.isFrozen(obj))
+            return;
+        if (typeof keyPath !== 'string' && 'length' in keyPath) {
+            assert(typeof value !== 'string' && 'length' in value);
+            for (var i = 0, l = keyPath.length; i < l; ++i) {
+                setByKeyPath(obj, keyPath[i], value[i]);
+            }
         }
-        var base64 = "";
-        for (var i = 0, length = base64lex.length; i < length; i++) {
-            base64 += DECODE_TABLE[base64lex[i]];
+        else {
+            var period = keyPath.indexOf('.');
+            if (period !== -1) {
+                var currentKeyPath = keyPath.substr(0, period);
+                var remainingKeyPath = keyPath.substr(period + 1);
+                if (remainingKeyPath === '')
+                    if (value === undefined) {
+                        if (Array.isArray(obj)) {
+                            if (!isNaN(parseInt(currentKeyPath)))
+                                obj.splice(parseInt(currentKeyPath), 1);
+                        }
+                        else
+                            delete obj[currentKeyPath];
+                        // @ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
+                    }
+                    else
+                        obj[currentKeyPath] = value;
+                else {
+                    //@ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
+                    var innerObj = obj[currentKeyPath];
+                    //@ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
+                    if (!innerObj)
+                        innerObj = obj[currentKeyPath] = {};
+                    setByKeyPath(innerObj, remainingKeyPath, value);
+                }
+            }
+            else {
+                if (value === undefined) {
+                    if (Array.isArray(obj) && !isNaN(parseInt(keyPath)))
+                        // @ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
+                        obj.splice(keyPath, 1);
+                    //@ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
+                    else
+                        delete obj[keyPath];
+                    //@ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
+                }
+                else
+                    obj[keyPath] = value;
+            }
         }
-        return base64;
     }
-    const DECODE_TABLE = {
-        "-": "=",
-        "0": "A",
-        "1": "B",
-        "2": "C",
-        "3": "D",
-        "4": "E",
-        "5": "F",
-        "6": "G",
-        "7": "H",
-        "8": "I",
-        "9": "J",
-        A: "K",
-        B: "L",
-        C: "M",
-        D: "N",
-        E: "O",
-        F: "P",
-        G: "Q",
-        H: "R",
-        I: "S",
-        J: "T",
-        K: "U",
-        L: "V",
-        M: "W",
-        N: "X",
-        O: "Y",
-        P: "Z",
-        Q: "a",
-        R: "b",
-        S: "c",
-        T: "d",
-        U: "e",
-        V: "f",
-        W: "g",
-        X: "h",
-        Y: "i",
-        Z: "j",
-        _: "k",
-        a: "l",
-        b: "m",
-        c: "n",
-        d: "o",
-        e: "p",
-        f: "q",
-        g: "r",
-        h: "s",
-        i: "t",
-        j: "u",
-        k: "v",
-        l: "w",
-        m: "x",
-        n: "y",
-        o: "z",
-        p: "0",
-        q: "1",
-        r: "2",
-        s: "3",
-        t: "4",
-        u: "5",
-        v: "6",
-        w: "7",
-        x: "8",
-        y: "9",
-        z: "+",
-        "|": "/",
+    const randomString$1 = typeof self === 'undefined' ? (bytes) => {
+        // Node
+        const buf = Buffer.alloc(bytes);
+        randomFillSync(buf);
+        return buf.toString("base64");
+    } : (bytes) => {
+        // Web
+        const buf = new Uint8Array(bytes);
+        crypto.getRandomValues(buf);
+        return btoa(String.fromCharCode.apply(null, buf));
     };
-    const ENCODE_TABLE = {};
-    for (const c of Object.keys(DECODE_TABLE)) {
-        ENCODE_TABLE[DECODE_TABLE[c]] = c;
-    }
 
-    var ArrayBufferDef = {
-        ArrayBuffer: {
-            replace: (ab) => ({
-                $t: "ArrayBuffer",
-                v: b64LexEncode(ab),
-            }),
-            revive: ({ v }) => {
-                const ba = b64LexDecode(v);
-                return ba.buffer.byteLength === ba.byteLength
-                    ? ba.buffer
-                    : ba.buffer.slice(ba.byteOffset, ba.byteOffset + ba.byteLength);
-            },
-        },
-    };
-
-    class FakeBlob {
-        constructor(buf, type) {
-            this.buf = buf;
-            this.type = type;
-        }
+    /** Verifies that given primary key is valid.
+     * The reason we narrow validity for valid keys are twofold:
+     *  1: Make sure to only support types that can be used as an object index in DBKeyMutationSet.
+     *     For example, ArrayBuffer cannot be used (gives "object ArrayBuffer") but Uint8Array can be
+     *     used (gives comma-delimited list of included bytes).
+     *  2: Avoid using plain numbers and Dates as keys when they are synced, as they are not globally unique.
+     *  3: Since we store the key as a VARCHAR server side in current version, try not promote types that stringifies to become very long server side.
+     *
+     * @param id
+     * @returns
+     */
+    function isValidSyncableID(id) {
+        if (typeof id === "string")
+            return true;
+        //if (validIDTypes[toStringTag(id)]) return true;
+        //if (Array.isArray(id)) return id.every((part) => isValidSyncableID(part));
+        if (Array.isArray(id) && id.some(key => isValidSyncableID(key)) && id.every(isValidSyncableIDPart))
+            return true;
+        return false;
+    }
+    /** Verifies that given key part is valid.
+     *  1: Make sure that arrays of this types are stringified correclty and works with DBKeyMutationSet.
+     *     For example, ArrayBuffer cannot be used (gives "object ArrayBuffer") but Uint8Array can be
+     *     used (gives comma-delimited list of included bytes).
+     *  2: Since we store the key as a VARCHAR server side in current version, try not promote types that stringifies to become very long server side.
+    */
+    function isValidSyncableIDPart(part) {
+        return typeof part === "string" || typeof part === "number" || Array.isArray(part) && part.every(isValidSyncableIDPart);
+    }
+    function isValidAtID(id, idPrefix) {
+        return !idPrefix || (typeof id === "string" && id.startsWith(idPrefix));
     }
 
-    function readBlobSync(b) {
-        const req = new XMLHttpRequest();
-        req.overrideMimeType("text/plain; charset=x-user-defined");
-        req.open("GET", URL.createObjectURL(b), false); // Sync
-        req.send();
-        if (req.status !== 200 && req.status !== 0) {
-            throw new Error("Bad Blob access: " + req.status);
+    function applyOperation(target, table, op) {
+        const tbl = target[table] || (target[table] = {});
+        switch (op.type) {
+            case "insert":
+            // TODO: Don't treat insert and upsert the same?
+            case "upsert":
+                op.keys.forEach((key, idx) => {
+                    tbl[key] = {
+                        type: "ups",
+                        val: op.values[idx],
+                    };
+                });
+                break;
+            case "update":
+            case "modify": {
+                op.keys.forEach((key, idx) => {
+                    const changeSpec = op.type === "update"
+                        ? op.changeSpecs[idx]
+                        : op.changeSpec;
+                    const entry = tbl[key];
+                    if (!entry) {
+                        tbl[key] = {
+                            type: "upd",
+                            mod: changeSpec,
+                        };
+                    }
+                    else {
+                        switch (entry.type) {
+                            case "ups":
+                                // Adjust the existing upsert with additional updates
+                                for (const [propPath, value] of Object.entries(changeSpec)) {
+                                    setByKeyPath(entry.val, propPath, value);
+                                }
+                                break;
+                            case "del":
+                                // No action.
+                                break;
+                            case "upd":
+                                // Adjust existing update with additional updates
+                                Object.assign(entry.mod, changeSpec); // May work for deep props as well - new keys is added later, right? Does the prop order persist along TSON and all? But it will not be 100% when combined with some server code (seach for "address.city": "Stockholm" comment)
+                                break;
+                        }
+                    }
+                });
+                break;
+            }
+            case "delete":
+                op.keys.forEach((key) => {
+                    tbl[key] = {
+                        type: "del",
+                    };
+                });
+                break;
         }
-        return req.responseText;
+        return target;
     }
 
-    function string2ArrayBuffer(str) {
-        const array = new Uint8Array(str.length);
-        for (let i = 0; i < str.length; ++i) {
-            array[i] = str.charCodeAt(i); // & 0xff;
+    function applyOperations(target, ops) {
+        for (const { table, muts } of ops) {
+            for (const mut of muts) {
+                applyOperation(target, table, mut);
+            }
         }
-        return array.buffer;
     }
 
-    var BlobDef = {
-        Blob: {
-            test: (blob, toStringTag) => toStringTag === "Blob" || blob instanceof FakeBlob,
-            replace: (blob) => ({
-                $t: "Blob",
-                v: blob instanceof FakeBlob
-                    ? b64encode(blob.buf)
-                    : b64encode(string2ArrayBuffer(readBlobSync(blob))),
-                type: blob.type,
-            }),
-            revive: ({ type, v }) => {
-                const ab = b64decode(v);
-                return typeof Blob !== undefined
-                    ? new Blob([ab])
-                    : new FakeBlob(ab.buffer, type);
-            },
-        },
-    };
-
-    const builtin = {
-        ...numberDef,
-        ...bigIntDef,
-        ...DateDef,
-        ...SetDef,
-        ...MapDef,
-        ...TypedArraysDefs,
-        ...ArrayBufferDef,
-        ...BlobDef,
-    };
-
-    function Bison(...typeDefsInputs) {
-        const tson = TypesonSimplified(builtin, BisonBinaryTypes, ...typeDefsInputs);
-        return {
-            toBinary(value) {
-                const [blob, json] = this.stringify(value);
-                const lenBuf = new ArrayBuffer(4);
-                new DataView(lenBuf).setUint32(0, blob.size);
-                return new Blob([lenBuf, blob, json]);
-            },
-            stringify(value) {
-                const binaries = [];
-                const json = tson.stringify(value, binaries);
-                const blob = new Blob(binaries.map((b) => {
-                    const lenBuf = new ArrayBuffer(4);
-                    new DataView(lenBuf).setUint32(0, "byteLength" in b ? b.byteLength : b.size);
-                    return new Blob([lenBuf, b]);
-                }));
-                return [blob, json];
-            },
-            async parse(json, binData) {
-                let pos = 0;
-                const arrayBuffers = [];
-                const buf = await readBlobBinary(binData);
-                const view = new DataView(buf);
-                while (pos < buf.byteLength) {
-                    const len = view.getUint32(pos);
-                    pos += 4;
-                    const ab = buf.slice(pos, pos + len);
-                    pos += len;
-                    arrayBuffers.push(ab);
+    function subtractChanges(target, // Server change set
+    changesToSubtract // additional mutations on client during syncWithServer()
+    ) {
+        var _a, _b, _c;
+        for (const [table, mutationSet] of Object.entries(changesToSubtract)) {
+            for (const [key, mut] of Object.entries(mutationSet)) {
+                switch (mut.type) {
+                    case 'ups':
+                        {
+                            const targetMut = (_a = target[table]) === null || _a === void 0 ? void 0 : _a[key];
+                            if (targetMut) {
+                                switch (targetMut.type) {
+                                    case 'ups':
+                                        delete target[table][key];
+                                        break;
+                                    case 'del':
+                                        // Leave delete operation.
+                                        // (Don't resurrect objects unintenionally (using tx(get, put) pattern locally))
+                                        break;
+                                    case 'upd':
+                                        delete target[table][key];
+                                        break;
+                                }
+                            }
+                        }
+                        break;
+                    case 'del':
+                        (_b = target[table]) === null || _b === void 0 ? true : delete _b[key];
+                        break;
+                    case 'upd': {
+                        const targetMut = (_c = target[table]) === null || _c === void 0 ? void 0 : _c[key];
+                        if (targetMut) {
+                            switch (targetMut.type) {
+                                case 'ups':
+                                    // Adjust the server upsert with locally updated values.
+                                    for (const [propPath, value] of Object.entries(mut.mod)) {
+                                        setByKeyPath(targetMut.val, propPath, value);
+                                    }
+                                    break;
+                                case 'del':
+                                    // Leave delete.
+                                    break;
+                                case 'upd':
+                                    // Remove the local update props from the server update mutation.
+                                    for (const propPath of Object.keys(mut.mod)) {
+                                        delete targetMut.mod[propPath];
+                                    }
+                                    break;
+                            }
+                        }
+                        break;
+                    }
                 }
-                return tson.parse(json, arrayBuffers);
-            },
-            async fromBinary(blob) {
-                const len = new DataView(await readBlobBinary(blob.slice(0, 4))).getUint32(0);
-                const binData = blob.slice(4, len + 4);
-                const json = await readBlob(blob.slice(len + 4));
-                return await this.parse(json, binData);
-            },
-        };
-    }
-    function readBlob(blob) {
-        return new Promise((resolve, reject) => {
-            const reader = new FileReader();
-            reader.onabort = (ev) => reject(new Error("file read aborted"));
-            reader.onerror = (ev) => reject(ev.target.error);
-            reader.onload = (ev) => resolve(ev.target.result);
-            reader.readAsText(blob);
-        });
-    }
-    function readBlobBinary(blob) {
-        return new Promise((resolve, reject) => {
-            const reader = new FileReader();
-            reader.onabort = (ev) => reject(new Error("file read aborted"));
-            reader.onerror = (ev) => reject(ev.target.error);
-            reader.onload = (ev) => resolve(ev.target.result);
-            reader.readAsArrayBuffer(blob);
-        });
+            }
+        }
     }
 
-    /** The undefined type is not part of builtin but can be manually added.
-     * The reason for supporting undefined is if the following object should be revived correctly:
-     *
-     *    {foo: undefined}
+    /** Convert a DBKeyMutationSet (which is an internal format capable of looking up changes per ID)
+     * ...into a DBOperationsSet (which is more optimal for performing DB operations into DB (bulkAdd() etc))
      *
-     * Without including this typedef, the revived object would just be {}.
-     * If including this typedef, the revived object would be {foo: undefined}.
+     * @param inSet
+     * @returns DBOperationsSet representing inSet
      */
-    var undefinedDef = {
-        undefined: {
-            replace: () => {
-            },
-            revive: () => undefined,
-        },
-    };
-
-    // Since server revisions are stored in bigints, we need to handle clients without
-    // bigint support to not fail when serverRevision is passed over to client.
-    // We need to not fail when reviving it and we need to somehow store the information.
-    // Since the revived version will later on be put into indexedDB we have another
-    // issue: When reading it back from indexedDB we will get a poco object that we
-    // cannot replace correctly when sending it to server. So we will also need
-    // to do an explicit workaround in the protocol where a bigint is supported.
-    // The workaround should be there regardless if browser supports BigInt or not, because
-    // the serverRev might have been stored in IDB before the browser was upgraded to support bigint.
-    //
-    // if (typeof serverRev.rev !== "bigint")
-    //   if (hasBigIntSupport)
-    //     serverRev.rev = bigIntDef.bigint.revive(server.rev)
-    //   else
-    //     serverRev.rev = new FakeBigInt(server.rev)
-    const hasBigIntSupport = typeof BigInt(0) === 'bigint';
-    function getValueOfBigInt(x) {
-        if (typeof x === 'bigint') {
-            return x;
-        }
-        if (hasBigIntSupport) {
-            return typeof x === 'string' ? BigInt(x) : BigInt(x.v);
-        }
-        else {
-            return typeof x === 'string' ? Number(x) : Number(x.v);
-        }
-    }
-    function compareBigInts(a, b) {
-        const valA = getValueOfBigInt(a);
-        const valB = getValueOfBigInt(b);
-        return valA < valB ? -1 : valA > valB ? 1 : 0;
-    }
-    class FakeBigInt {
-        constructor(value) {
-            this.v = value;
-        }
-        toString() {
-            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 TSON = TypesonSimplified(builtin, defs);
-    const BISON = Bison(defs);
-
-    //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 {
-                console.error(`Dexie Cloud: There's no active service worker. Can this ever happen??`);
-            }
-            return;
-        }
-        catch (e) {
-            if (!hasComplainedAboutSyncEvent) {
-                console.debug(`Dexie Cloud: Could not register sync event`, e);
-                hasComplainedAboutSyncEvent = true;
+    function toDBOperationSet(inSet) {
+        // Fictive transaction:
+        const txid = randomString$1(16);
+        // Convert data into a temporary map to collect mutations of same table and type
+        const map = {};
+        for (const [table, ops] of Object.entries(inSet)) {
+            for (const [key, op] of Object.entries(ops)) {
+                const mapEntry = map[table] || (map[table] = {});
+                const ops = mapEntry[op.type] || (mapEntry[op.type] = []);
+                ops.push(Object.assign({ key }, op)); // DBKeyMutation doesn't contain key, so we need to bring it in.
             }
         }
-    }
-    async function registerPeriodicSyncEvent(db) {
-        var _a;
-        try {
-            // Register periodicSync event to SW:
-            // @ts-ignore
-            const { periodicSync } = await navigator.serviceWorker.ready;
-            if (periodicSync) {
-                try {
-                    await 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);
+        // Start computing the resulting format:
+        const result = [];
+        for (const [table, ops] of Object.entries(map)) {
+            const resultEntry = {
+                table,
+                muts: [],
+            };
+            for (const [optype, muts] of Object.entries(ops)) {
+                switch (optype) {
+                    case "ups": {
+                        const op = {
+                            type: "upsert",
+                            keys: muts.map(mut => mut.key),
+                            values: muts.map(mut => mut.val),
+                            txid
+                        };
+                        resultEntry.muts.push(op);
+                        break;
+                    }
+                    case "upd": {
+                        const op = {
+                            type: "update",
+                            keys: muts.map(mut => mut.key),
+                            changeSpecs: muts.map(mut => mut.mod),
+                            txid
+                        };
+                        resultEntry.muts.push(op);
+                        break;
+                    }
+                    case "del": {
+                        const op = {
+                            type: "delete",
+                            keys: muts.map(mut => mut.key),
+                            txid,
+                        };
+                        resultEntry.muts.push(op);
+                        break;
+                    }
                 }
             }
-            else {
-                console.debug(`Dexie Cloud: periodicSync not supported.`);
-            }
-        }
-        catch (e) {
-            console.debug(`Dexie Cloud: Could not register periodicSync for ${db.name}`, e);
+            result.push(resultEntry);
         }
+        return result;
     }
 
-    function triggerSync(db, purpose) {
-        if (db.cloud.usingServiceWorker) {
-            registerSyncEvent(db, purpose);
-        }
-        else {
-            db.localSyncEvent.next({ purpose });
-        }
+    function getDbNameFromDbUrl(dbUrl) {
+        const url = new URL(dbUrl);
+        return url.pathname === "/"
+            ? url.hostname.split('.')[0]
+            : url.pathname.split('/')[1];
     }
 
-    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;
+    async function listSyncifiedChanges(tablesToSyncify, currentUser, schema, alreadySyncedRealms) {
+        if (currentUser.isLoggedIn) {
+            if (tablesToSyncify.length > 0) {
+                const ignoredRealms = new Set(alreadySyncedRealms || []);
+                const inserts = 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 === null || dexieCloudTableSchema === void 0 ? void 0 : dexieCloudTableSchema.generatedGlobalId)
+                        ? table.filter((item) => !ignoredRealms.has(item.realmId || "") && isValidSyncableID(extractKey(item)))
+                        : table.filter((item) => !ignoredRealms.has(item.realmId || "") && isValidAtID(extractKey(item), dexieCloudTableSchema === null || dexieCloudTableSchema === void 0 ? void 0 : dexieCloudTableSchema.idPrefix));
+                    const unsyncedObjects = await query.toArray();
+                    if (unsyncedObjects.length > 0) {
+                        const mut = {
+                            type: "insert",
+                            values: unsyncedObjects,
+                            keys: unsyncedObjects.map(extractKey),
+                            userId: currentUser.userId,
+                        };
+                        return {
+                            table: table.name,
+                            muts: [mut],
+                        };
+                    }
+                    else {
+                        return {
+                            table: table.name,
+                            muts: []
+                        };
+                    }
+                }));
+                return inserts.filter(op => op.muts.length > 0);
+            }
+        }
+        return [];
     }
 
-    function getSyncableTables(db) {
-        return Object.entries(db.cloud.schema || {})
-            .filter(([, { markedForSync }]) => markedForSync)
-            .map(([tbl]) => db.table(tbl));
+    function getTablesToSyncify(db, syncState) {
+        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;
     }
 
-    function getMutationTable(tableName) {
-        return `$${tableName}_mutations`;
+    function interactWithUser(userInteraction, req) {
+        return new Promise((resolve, reject) => {
+            const interactionProps = {
+                ...req,
+                onSubmit: (res) => {
+                    userInteraction.next(undefined);
+                    resolve(res);
+                },
+                onCancel: () => {
+                    userInteraction.next(undefined);
+                    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) => {
+              if (currentInteractionProps !== interactionProps) {
+                if (subscription) subscription.unsubscribe();
+                if (!done) {
+                  reject(new Dexie.AbortError("User cancelled"));
+                }
+              }
+            });*/
+        });
     }
-
-    function getTableFromMutationTable(mutationTable) {
-        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;
+    function alertUser(userInteraction, title, ...alerts) {
+        return interactWithUser(userInteraction, {
+            type: 'message-alert',
+            title,
+            alerts,
+            fields: {}
+        });
     }
-
-    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 {
-                table: tableName,
-                muts,
-            };
-        }));
-        // Filter out those tables that doesn't have any mutations:
-        return allMutsOnTables.filter(({ muts }) => muts.length > 0);
+    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: {},
+                        },
+                    ]
+                    : [],
+                fields: {
+                    email: {
+                        type: 'email',
+                        placeholder: 'you@somedomain.com',
+                    },
+                },
+            })).email;
+        }
+        return email;
     }
-
-    //@ts-check
-    const randomFillSync = crypto.getRandomValues;
-
-    function assert(b) {
-        if (!b)
-            throw new Error('Assertion Failed');
+    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',
+                },
+            },
+        });
+        return otp;
     }
-    function setByKeyPath(obj, keyPath, value) {
-        if (!obj || keyPath === undefined)
-            return;
-        if ('isFrozen' in Object && Object.isFrozen(obj))
+
+    async function loadAccessToken(db) {
+        var _a, _b;
+        const currentUser = await db.getCurrentUser();
+        const { accessToken, accessTokenExpiration, refreshToken, refreshTokenExpiration, claims, } = currentUser;
+        if (!accessToken)
             return;
-        if (typeof keyPath !== 'string' && 'length' in keyPath) {
-            assert(typeof value !== 'string' && 'length' in value);
-            for (var i = 0, l = keyPath.length; i < l; ++i) {
-                setByKeyPath(obj, keyPath[i], value[i]);
-            }
+        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 = await refreshAccessToken(db.cloud.options.databaseUrl, currentUser);
+        await db.table('$logins').update(claims.sub, {
+            accessToken: refreshedLogin.accessToken,
+            accessTokenExpiration: refreshedLogin.accessTokenExpiration,
+        });
+        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 {
-            var period = keyPath.indexOf('.');
-            if (period !== -1) {
-                var currentKeyPath = keyPath.substr(0, period);
-                var remainingKeyPath = keyPath.substr(period + 1);
-                if (remainingKeyPath === '')
-                    if (value === undefined) {
-                        if (Array.isArray(obj)) {
-                            if (!isNaN(parseInt(currentKeyPath)))
-                                obj.splice(parseInt(currentKeyPath), 1);
-                        }
-                        else
-                            delete obj[currentKeyPath];
-                        // @ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
-                    }
-                    else
-                        obj[currentKeyPath] = value;
-                else {
-                    //@ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
-                    var innerObj = obj[currentKeyPath];
-                    //@ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
-                    if (!innerObj)
-                        innerObj = obj[currentKeyPath] = {};
-                    setByKeyPath(innerObj, remainingKeyPath, value);
-                }
+            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',
+        });
+        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']);
+        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,
+            });
+            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);
             }
-            else {
-                if (value === undefined) {
-                    if (Array.isArray(obj) && !isNaN(parseInt(keyPath)))
-                        // @ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
-                        obj.splice(keyPath, 1);
-                    //@ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
-                    else
-                        delete obj[keyPath];
-                    //@ts-ignore: even if currentKeyPath would be numeric string and obj would be array - it works.
-                }
-                else
-                    obj[keyPath] = value;
+            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,
+                });
             }
+            return context;
+        }
+        catch (error) {
+            await alertUser(userInteraction, 'Authentication Failed', {
+                type: 'error',
+                messageCode: 'GENERIC_ERROR',
+                message: `We're having a problem to authenticate rigth now.`,
+                messageParams: {}
+            }).catch(() => { });
+            throw error;
         }
     }
-    const randomString$1 = typeof self === 'undefined' ? (bytes) => {
-        // Node
-        const buf = Buffer.alloc(bytes);
-        randomFillSync(buf);
-        return buf.toString("base64");
-    } : (bytes) => {
-        // Web
-        const buf = new Uint8Array(bytes);
-        crypto.getRandomValues(buf);
-        return btoa(String.fromCharCode.apply(null, buf));
-    };
-
-    /** Verifies that given primary key is valid.
-     * The reason we narrow validity for valid keys are twofold:
-     *  1: Make sure to only support types that can be used as an object index in DBKeyMutationSet.
-     *     For example, ArrayBuffer cannot be used (gives "object ArrayBuffer") but Uint8Array can be
-     *     used (gives comma-delimited list of included bytes).
-     *  2: Avoid using plain numbers and Dates as keys when they are synced, as they are not globally unique.
-     *  3: Since we store the key as a VARCHAR server side in current version, try not promote types that stringifies to become very long server side.
-     *
-     * @param id
-     * @returns
-     */
-    function isValidSyncableID(id) {
-        if (typeof id === "string")
-            return true;
-        //if (validIDTypes[toStringTag(id)]) return true;
-        //if (Array.isArray(id)) return id.every((part) => isValidSyncableID(part));
-        if (Array.isArray(id) && id.some(key => isValidSyncableID(key)) && id.every(isValidSyncableIDPart))
-            return true;
-        return false;
-    }
-    /** Verifies that given key part is valid.
-     *  1: Make sure that arrays of this types are stringified correclty and works with DBKeyMutationSet.
-     *     For example, ArrayBuffer cannot be used (gives "object ArrayBuffer") but Uint8Array can be
-     *     used (gives comma-delimited list of included bytes).
-     *  2: Since we store the key as a VARCHAR server side in current version, try not promote types that stringifies to become very long server side.
-    */
-    function isValidSyncableIDPart(part) {
-        return typeof part === "string" || typeof part === "number" || Array.isArray(part) && part.every(isValidSyncableIDPart);
+    function spkiToPEM(keydata) {
+        const keydataB64 = b64encode(keydata);
+        const keydataB64Pem = formatAsPem(keydataB64);
+        return keydataB64Pem;
     }
-    function isValidAtID(id, idPrefix) {
-        return !idPrefix || (typeof id === "string" && id.startsWith(idPrefix));
+    function formatAsPem(str) {
+        let finalString = '-----BEGIN PUBLIC KEY-----\n';
+        while (str.length > 0) {
+            finalString += str.substring(0, 64) + '\n';
+            str = str.substring(64);
+        }
+        finalString = finalString + '-----END PUBLIC KEY-----';
+        return finalString;
     }
 
-    function applyOperation(target, table, op) {
-        const tbl = target[table] || (target[table] = {});
-        switch (op.type) {
-            case "insert":
-            // TODO: Don't treat insert and upsert the same?
-            case "upsert":
-                op.keys.forEach((key, idx) => {
-                    tbl[key] = {
-                        type: "ups",
-                        val: op.values[idx],
-                    };
-                });
-                break;
-            case "update":
-            case "modify": {
-                op.keys.forEach((key, idx) => {
-                    const changeSpec = op.type === "update"
-                        ? op.changeSpecs[idx]
-                        : op.changeSpec;
-                    const entry = tbl[key];
-                    if (!entry) {
-                        tbl[key] = {
-                            type: "upd",
-                            mod: changeSpec,
-                        };
+    const { toString: toStr } = {};
+    function getToStringTag(val) {
+        return toStr.call(val).slice(8, -1);
+    }
+    function escapeDollarProps(value) {
+        const keys = Object.keys(value);
+        let dollarKeys = null;
+        for (let i = 0, l = keys.length; i < l; ++i) {
+            if (keys[i][0] === "$") {
+                dollarKeys = dollarKeys || [];
+                dollarKeys.push(keys[i]);
+            }
+        }
+        if (!dollarKeys)
+            return value;
+        const clone = { ...value };
+        for (const k of dollarKeys) {
+            delete clone[k];
+            clone["$" + k] = value[k];
+        }
+        return clone;
+    }
+    const ObjectDef = {
+        replace: escapeDollarProps,
+    };
+    function TypesonSimplified(...typeDefsInputs) {
+        const typeDefs = typeDefsInputs.reduce((p, c) => ({ ...p, ...c }), typeDefsInputs.reduce((p, c) => ({ ...c, ...p }), {}));
+        const protoMap = new WeakMap();
+        return {
+            stringify(value, alternateChannel, space) {
+                const json = JSON.stringify(value, function (key) {
+                    const realVal = this[key];
+                    const typeDef = getTypeDef(realVal);
+                    return typeDef
+                        ? typeDef.replace(realVal, alternateChannel, typeDefs)
+                        : realVal;
+                }, space);
+                return json;
+            },
+            parse(tson, alternateChannel) {
+                let parent = null;
+                let unescapeParentKeys = [];
+                return JSON.parse(tson, function (key, value) {
+                    //
+                    // Parent Part
+                    //
+                    const type = value === null || value === void 0 ? void 0 : value.$t;
+                    if (type) {
+                        const typeDef = typeDefs[type];
+                        value = typeDef
+                            ? typeDef.revive(value, alternateChannel, typeDefs)
+                            : value;
                     }
-                    else {
-                        switch (entry.type) {
-                            case "ups":
-                                // Adjust the existing upsert with additional updates
-                                for (const [propPath, value] of Object.entries(changeSpec)) {
-                                    setByKeyPath(entry.val, propPath, value);
-                                }
-                                break;
-                            case "del":
-                                // No action.
-                                break;
-                            case "upd":
-                                // Adjust existing update with additional updates
-                                Object.assign(entry.mod, changeSpec); // May work for deep props as well - new keys is added later, right? Does the prop order persist along TSON and all? But it will not be 100% when combined with some server code (seach for "address.city": "Stockholm" comment)
-                                break;
+                    if (value === parent) {
+                        // Do what the kid told us to
+                        if (unescapeParentKeys.length > 0) {
+                            // Unescape dollar props
+                            value = { ...value };
+                            for (const k of unescapeParentKeys) {
+                                value[k.substr(1)] = value[k];
+                                delete value[k];
+                            }
                         }
+                        unescapeParentKeys = [];
+                        return value;
                     }
+                    //
+                    // Child part
+                    //
+                    if (key[0] === "$" && key !== "$t") {
+                        parent = this;
+                        unescapeParentKeys.push(key);
+                    }
+                    return value;
                 });
-                break;
+            },
+        };
+        function getTypeDef(realVal) {
+            const type = typeof realVal;
+            switch (typeof realVal) {
+                case "object":
+                case "function": {
+                    // "object", "function", null
+                    if (realVal === null)
+                        return null;
+                    const proto = Object.getPrototypeOf(realVal);
+                    if (!proto)
+                        return ObjectDef;
+                    let typeDef = protoMap.get(proto);
+                    if (typeDef !== undefined)
+                        return typeDef; // Null counts to! So the caching of Array.prototype also counts.
+                    const toStringTag = getToStringTag(realVal);
+                    const entry = Object.entries(typeDefs).find(([typeName, typeDef]) => { var _a, _b; return (_b = (_a = typeDef === null || typeDef === void 0 ? void 0 : typeDef.test) === null || _a === void 0 ? void 0 : _a.call(typeDef, realVal, toStringTag)) !== null && _b !== void 0 ? _b : typeName === toStringTag; });
+                    typeDef = entry === null || entry === void 0 ? void 0 : entry[1];
+                    if (!typeDef) {
+                        typeDef = Array.isArray(realVal)
+                            ? null
+                            : typeof realVal === "function"
+                                ? typeDefs.function || null
+                                : ObjectDef;
+                    }
+                    protoMap.set(proto, typeDef);
+                    return typeDef;
+                }
+                default:
+                    return typeDefs[type];
             }
-            case "delete":
-                op.keys.forEach((key) => {
-                    tbl[key] = {
-                        type: "del",
-                    };
-                });
-                break;
         }
-        return target;
     }
 
-    function applyOperations(target, ops) {
-        for (const { table, muts } of ops) {
-            for (const mut of muts) {
-                applyOperation(target, table, mut);
-            }
-        }
-    }
+    const BisonBinaryTypes = {
+        Blob: {
+            test: (blob, toStringTag) => toStringTag === "Blob",
+            replace: (blob, altChannel) => {
+                const i = altChannel.length;
+                altChannel.push(blob);
+                return {
+                    $t: "Blob",
+                    mimeType: blob.type,
+                    i,
+                };
+            },
+            revive: ({ i, mimeType }, altChannel) => new Blob([altChannel[i]], { type: mimeType }),
+        },
+    };
 
-    function subtractChanges(target, // Server change set
-    changesToSubtract // additional mutations on client during syncWithServer()
-    ) {
-        var _a, _b, _c;
-        for (const [table, mutationSet] of Object.entries(changesToSubtract)) {
-            for (const [key, mut] of Object.entries(mutationSet)) {
-                switch (mut.type) {
-                    case 'ups':
-                        {
-                            const targetMut = (_a = target[table]) === null || _a === void 0 ? void 0 : _a[key];
-                            if (targetMut) {
-                                switch (targetMut.type) {
-                                    case 'ups':
-                                        delete target[table][key];
-                                        break;
-                                    case 'del':
-                                        // Leave delete operation.
-                                        // (Don't resurrect objects unintenionally (using tx(get, put) pattern locally))
-                                        break;
-                                    case 'upd':
-                                        delete target[table][key];
-                                        break;
-                                }
-                            }
-                        }
-                        break;
-                    case 'del':
-                        (_b = target[table]) === null || _b === void 0 ? true : delete _b[key];
-                        break;
-                    case 'upd': {
-                        const targetMut = (_c = target[table]) === null || _c === void 0 ? void 0 : _c[key];
-                        if (targetMut) {
-                            switch (targetMut.type) {
-                                case 'ups':
-                                    // Adjust the server upsert with locally updated values.
-                                    for (const [propPath, value] of Object.entries(mut.mod)) {
-                                        setByKeyPath(targetMut.val, propPath, value);
-                                    }
-                                    break;
-                                case 'del':
-                                    // Leave delete.
-                                    break;
-                                case 'upd':
-                                    // Remove the local update props from the server update mutation.
-                                    for (const propPath of Object.keys(mut.mod)) {
-                                        delete targetMut.mod[propPath];
-                                    }
-                                    break;
-                            }
-                        }
-                        break;
-                    }
+    var numberDef = {
+        number: {
+            replace: (num) => {
+                switch (true) {
+                    case isNaN(num):
+                        return { $t: "number", v: "NaN" };
+                    case num === Infinity:
+                        return { $t: "number", v: "Infinity" };
+                    case num === -Infinity:
+                        return { $t: "number", v: "-Infinity" };
+                    default:
+                        return num;
                 }
-            }
+            },
+            revive: ({ v }) => Number(v),
+        },
+    };
+
+    const bigIntDef = {
+        bigint: {
+            replace: (realVal) => {
+                return { $t: "bigint", v: "" + realVal };
+            },
+            revive: (obj) => BigInt(obj.v),
+        },
+    };
+
+    var DateDef = {
+        Date: {
+            replace: (date) => ({
+                $t: "Date",
+                v: isNaN(date.getTime()) ? "NaN" : date.toISOString(),
+            }),
+            revive: ({ v }) => new Date(v === "NaN" ? NaN : Date.parse(v)),
+        },
+    };
+
+    var SetDef = {
+        Set: {
+            replace: (set) => ({
+                $t: "Set",
+                v: Array.from(set.entries()),
+            }),
+            revive: ({ v }) => new Set(v),
+        },
+    };
+
+    var MapDef = {
+        Map: {
+            replace: (map) => ({
+                $t: "Map",
+                v: Array.from(map.entries()),
+            }),
+            revive: ({ v }) => new Map(v),
+        },
+    };
+
+    const _global = typeof globalThis !== "undefined"
+        ? globalThis
+        : typeof self !== "undefined"
+            ? self
+            : typeof global === "undefined"
+                ? global
+                : undefined;
+
+    var TypedArraysDefs = [
+        "Int8Array",
+        "Uint8Array",
+        "Uint8ClampedArray",
+        "Int16Array",
+        "Uint16Array",
+        "Int32Array",
+        "Uint32Array",
+        "Float32Array",
+        "Float64Array",
+        "DataView",
+        "BigInt64Array",
+        "BigUint64Array",
+    ].reduce((specs, typeName) => ({
+        ...specs,
+        [typeName]: {
+            // Replace passes the the typed array into $t, buffer so that
+            // the ArrayBuffer typedef takes care of further handling of the buffer:
+            // {$t:"Uint8Array",buffer:{$t:"ArrayBuffer",idx:0}}
+            // CHANGED ABOVE! Now shortcutting that for more sparse format of the typed arrays
+            // to contain the b64 property directly.
+            replace: (a, _, typeDefs) => {
+                const result = {
+                    $t: typeName,
+                    v: typeDefs.ArrayBuffer.replace(a.byteOffset === 0 && a.byteLength === a.buffer.byteLength
+                        ? a.buffer
+                        : a.buffer.slice(a.byteOffset, a.byteOffset + a.byteLength), _, typeDefs).v,
+                };
+                return result;
+            },
+            revive: ({ v }, _, typeDefs) => {
+                const TypedArray = _global[typeName];
+                return (TypedArray &&
+                    new TypedArray(typeDefs.ArrayBuffer.revive({ v }, _, typeDefs)));
+            },
+        },
+    }), {});
+
+    function b64LexEncode(b) {
+        return b64ToLex(b64encode(b));
+    }
+    function b64LexDecode(b64Lex) {
+        return b64decode(lexToB64(b64Lex));
+    }
+    function b64ToLex(base64) {
+        var encoded = "";
+        for (var i = 0, length = base64.length; i < length; i++) {
+            encoded += ENCODE_TABLE[base64[i]];
         }
+        return encoded;
+    }
+    function lexToB64(base64lex) {
+        // only accept string input
+        if (typeof base64lex !== "string") {
+            throw new Error("invalid decoder input: " + base64lex);
+        }
+        var base64 = "";
+        for (var i = 0, length = base64lex.length; i < length; i++) {
+            base64 += DECODE_TABLE[base64lex[i]];
+        }
+        return base64;
+    }
+    const DECODE_TABLE = {
+        "-": "=",
+        "0": "A",
+        "1": "B",
+        "2": "C",
+        "3": "D",
+        "4": "E",
+        "5": "F",
+        "6": "G",
+        "7": "H",
+        "8": "I",
+        "9": "J",
+        A: "K",
+        B: "L",
+        C: "M",
+        D: "N",
+        E: "O",
+        F: "P",
+        G: "Q",
+        H: "R",
+        I: "S",
+        J: "T",
+        K: "U",
+        L: "V",
+        M: "W",
+        N: "X",
+        O: "Y",
+        P: "Z",
+        Q: "a",
+        R: "b",
+        S: "c",
+        T: "d",
+        U: "e",
+        V: "f",
+        W: "g",
+        X: "h",
+        Y: "i",
+        Z: "j",
+        _: "k",
+        a: "l",
+        b: "m",
+        c: "n",
+        d: "o",
+        e: "p",
+        f: "q",
+        g: "r",
+        h: "s",
+        i: "t",
+        j: "u",
+        k: "v",
+        l: "w",
+        m: "x",
+        n: "y",
+        o: "z",
+        p: "0",
+        q: "1",
+        r: "2",
+        s: "3",
+        t: "4",
+        u: "5",
+        v: "6",
+        w: "7",
+        x: "8",
+        y: "9",
+        z: "+",
+        "|": "/",
+    };
+    const ENCODE_TABLE = {};
+    for (const c of Object.keys(DECODE_TABLE)) {
+        ENCODE_TABLE[DECODE_TABLE[c]] = c;
     }
 
-    /** Convert a DBKeyMutationSet (which is an internal format capable of looking up changes per ID)
-     * ...into a DBOperationsSet (which is more optimal for performing DB operations into DB (bulkAdd() etc))
-     *
-     * @param inSet
-     * @returns DBOperationsSet representing inSet
-     */
-    function toDBOperationSet(inSet) {
-        // Fictive transaction:
-        const txid = randomString$1(16);
-        // Convert data into a temporary map to collect mutations of same table and type
-        const map = {};
-        for (const [table, ops] of Object.entries(inSet)) {
-            for (const [key, op] of Object.entries(ops)) {
-                const mapEntry = map[table] || (map[table] = {});
-                const ops = mapEntry[op.type] || (mapEntry[op.type] = []);
-                ops.push(Object.assign({ key }, op)); // DBKeyMutation doesn't contain key, so we need to bring it in.
-            }
-        }
-        // Start computing the resulting format:
-        const result = [];
-        for (const [table, ops] of Object.entries(map)) {
-            const resultEntry = {
-                table,
-                muts: [],
-            };
-            for (const [optype, muts] of Object.entries(ops)) {
-                switch (optype) {
-                    case "ups": {
-                        const op = {
-                            type: "upsert",
-                            keys: muts.map(mut => mut.key),
-                            values: muts.map(mut => mut.val),
-                            txid
-                        };
-                        resultEntry.muts.push(op);
-                        break;
-                    }
-                    case "upd": {
-                        const op = {
-                            type: "update",
-                            keys: muts.map(mut => mut.key),
-                            changeSpecs: muts.map(mut => mut.mod),
-                            txid
-                        };
-                        resultEntry.muts.push(op);
-                        break;
-                    }
-                    case "del": {
-                        const op = {
-                            type: "delete",
-                            keys: muts.map(mut => mut.key),
-                            txid,
-                        };
-                        resultEntry.muts.push(op);
-                        break;
-                    }
-                }
-            }
-            result.push(resultEntry);
+    var ArrayBufferDef = {
+        ArrayBuffer: {
+            replace: (ab) => ({
+                $t: "ArrayBuffer",
+                v: b64LexEncode(ab),
+            }),
+            revive: ({ v }) => {
+                const ba = b64LexDecode(v);
+                return ba.buffer.byteLength === ba.byteLength
+                    ? ba.buffer
+                    : ba.buffer.slice(ba.byteOffset, ba.byteOffset + ba.byteLength);
+            },
+        },
+    };
+
+    class FakeBlob {
+        constructor(buf, type) {
+            this.buf = buf;
+            this.type = type;
         }
-        return result;
     }
 
-    function getDbNameFromDbUrl(dbUrl) {
-        const url = new URL(dbUrl);
-        return url.pathname === "/"
-            ? url.hostname.split('.')[0]
-            : url.pathname.split('/')[1];
+    function readBlobSync(b) {
+        const req = new XMLHttpRequest();
+        req.overrideMimeType("text/plain; charset=x-user-defined");
+        req.open("GET", URL.createObjectURL(b), false); // Sync
+        req.send();
+        if (req.status !== 200 && req.status !== 0) {
+            throw new Error("Bad Blob access: " + req.status);
+        }
+        return req.responseText;
     }
 
-    async function listSyncifiedChanges(tablesToSyncify, currentUser, schema, alreadySyncedRealms) {
-        if (currentUser.isLoggedIn) {
-            if (tablesToSyncify.length > 0) {
-                const ignoredRealms = new Set(alreadySyncedRealms || []);
-                const inserts = 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 === null || dexieCloudTableSchema === void 0 ? void 0 : dexieCloudTableSchema.generatedGlobalId)
-                        ? table.filter((item) => !ignoredRealms.has(item.realmId || "") && isValidSyncableID(extractKey(item)))
-                        : table.filter((item) => !ignoredRealms.has(item.realmId || "") && isValidAtID(extractKey(item), dexieCloudTableSchema === null || dexieCloudTableSchema === void 0 ? void 0 : dexieCloudTableSchema.idPrefix));
-                    const unsyncedObjects = await query.toArray();
-                    if (unsyncedObjects.length > 0) {
-                        const mut = {
-                            type: "insert",
-                            values: unsyncedObjects,
-                            keys: unsyncedObjects.map(extractKey),
-                            userId: currentUser.userId,
-                        };
-                        return {
-                            table: table.name,
-                            muts: [mut],
-                        };
-                    }
-                    else {
-                        return {
-                            table: table.name,
-                            muts: []
-                        };
-                    }
-                }));
-                return inserts.filter(op => op.muts.length > 0);
-            }
+    function string2ArrayBuffer(str) {
+        const array = new Uint8Array(str.length);
+        for (let i = 0; i < str.length; ++i) {
+            array[i] = str.charCodeAt(i); // & 0xff;
         }
-        return [];
+        return array.buffer;
     }
 
-    function getTablesToSyncify(db, syncState) {
-        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;
-    }
+    var BlobDef = {
+        Blob: {
+            test: (blob, toStringTag) => toStringTag === "Blob" || blob instanceof FakeBlob,
+            replace: (blob) => ({
+                $t: "Blob",
+                v: blob instanceof FakeBlob
+                    ? b64encode(blob.buf)
+                    : b64encode(string2ArrayBuffer(readBlobSync(blob))),
+                type: blob.type,
+            }),
+            revive: ({ type, v }) => {
+                const ab = b64decode(v);
+                return typeof Blob !== undefined
+                    ? new Blob([ab])
+                    : new FakeBlob(ab.buffer, type);
+            },
+        },
+    };
 
-    function interactWithUser(userInteraction, req) {
-        return new Promise((resolve, reject) => {
-            const interactionProps = {
-                ...req,
-                onSubmit: (res) => {
-                    userInteraction.next(undefined);
-                    resolve(res);
-                },
-                onCancel: () => {
-                    userInteraction.next(undefined);
-                    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) => {
-              if (currentInteractionProps !== interactionProps) {
-                if (subscription) subscription.unsubscribe();
-                if (!done) {
-                  reject(new Dexie.AbortError("User cancelled"));
-                }
-              }
-            });*/
-        });
-    }
-    function alertUser(userInteraction, title, ...alerts) {
-        return interactWithUser(userInteraction, {
-            type: 'message-alert',
-            title,
-            alerts,
-            fields: {}
-        });
-    }
-    async function promptForEmail(userInteraction, title, emailHint) {
-        let email = emailHint || '';
-        while (!email || !/^[\w-\.]+@([\w-]+\.)+[\w-]{2,10}$/.test(email)) {
-            email = (await interactWithUser(userInteraction, {
-                type: 'email',
-                title,
-                alerts: email
-                    ? [
-                        {
-                            type: 'error',
-                            messageCode: 'INVALID_EMAIL',
-                            message: 'Please enter a valid email address',
-                            messageParams: {},
-                        },
-                    ]
-                    : [],
-                fields: {
-                    email: {
-                        type: 'email',
-                        placeholder: 'you@somedomain.com',
-                    },
-                },
-            })).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 },
+    const builtin = {
+        ...numberDef,
+        ...bigIntDef,
+        ...DateDef,
+        ...SetDef,
+        ...MapDef,
+        ...TypedArraysDefs,
+        ...ArrayBufferDef,
+        ...BlobDef,
+    };
+
+    function Bison(...typeDefsInputs) {
+        const tson = TypesonSimplified(builtin, BisonBinaryTypes, ...typeDefsInputs);
+        return {
+            toBinary(value) {
+                const [blob, json] = this.stringify(value);
+                const lenBuf = new ArrayBuffer(4);
+                new DataView(lenBuf).setUint32(0, blob.size);
+                return new Blob([lenBuf, blob, json]);
+            },
+            stringify(value) {
+                const binaries = [];
+                const json = tson.stringify(value, binaries);
+                const blob = new Blob(binaries.map((b) => {
+                    const lenBuf = new ArrayBuffer(4);
+                    new DataView(lenBuf).setUint32(0, "byteLength" in b ? b.byteLength : b.size);
+                    return new Blob([lenBuf, b]);
+                }));
+                return [blob, json];
             },
-        ];
-        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',
-                },
+            async parse(json, binData) {
+                let pos = 0;
+                const arrayBuffers = [];
+                const buf = await readBlobBinary(binData);
+                const view = new DataView(buf);
+                while (pos < buf.byteLength) {
+                    const len = view.getUint32(pos);
+                    pos += 4;
+                    const ab = buf.slice(pos, pos + len);
+                    pos += len;
+                    arrayBuffers.push(ab);
+                }
+                return tson.parse(json, arrayBuffers);
             },
-        });
-        return otp;
+            async fromBinary(blob) {
+                const len = new DataView(await readBlobBinary(blob.slice(0, 4))).getUint32(0);
+                const binData = blob.slice(4, len + 4);
+                const json = await readBlob(blob.slice(len + 4));
+                return await this.parse(json, binData);
+            },
+        };
     }
-
-    async function loadAccessToken(db) {
-        var _a, _b;
-        const currentUser = await 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 = await refreshAccessToken(db.cloud.options.databaseUrl, currentUser);
-        await db.table('$logins').update(claims.sub, {
-            accessToken: refreshedLogin.accessToken,
-            accessTokenExpiration: refreshedLogin.accessTokenExpiration,
+    function readBlob(blob) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onabort = (ev) => reject(new Error("file read aborted"));
+            reader.onerror = (ev) => reject(ev.target.error);
+            reader.onload = (ev) => resolve(ev.target.result);
+            reader.readAsText(blob);
         });
-        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 readBlobBinary(blob) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onabort = (ev) => reject(new Error("file read aborted"));
+            reader.onerror = (ev) => reject(ev.target.error);
+            reader.onload = (ev) => resolve(ev.target.result);
+            reader.readAsArrayBuffer(blob);
         });
-        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']);
-        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,
-            });
-            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,
-                });
-            }
-            return context;
-        }
-        catch (error) {
-            await alertUser(userInteraction, 'Authentication Failed', {
-                type: 'error',
-                messageCode: 'GENERIC_ERROR',
-                message: `We're having a problem to authenticate rigth now.`,
-                messageParams: {}
-            }).catch(() => { });
-            throw error;
+
+    /** The undefined type is not part of builtin but can be manually added.
+     * The reason for supporting undefined is if the following object should be revived correctly:
+     *
+     *    {foo: undefined}
+     *
+     * Without including this typedef, the revived object would just be {}.
+     * If including this typedef, the revived object would be {foo: undefined}.
+     */
+    var undefinedDef = {
+        undefined: {
+            replace: () => {
+            },
+            revive: () => undefined,
+        },
+    };
+
+    // Since server revisions are stored in bigints, we need to handle clients without
+    // bigint support to not fail when serverRevision is passed over to client.
+    // We need to not fail when reviving it and we need to somehow store the information.
+    // Since the revived version will later on be put into indexedDB we have another
+    // issue: When reading it back from indexedDB we will get a poco object that we
+    // cannot replace correctly when sending it to server. So we will also need
+    // to do an explicit workaround in the protocol where a bigint is supported.
+    // The workaround should be there regardless if browser supports BigInt or not, because
+    // the serverRev might have been stored in IDB before the browser was upgraded to support bigint.
+    //
+    // if (typeof serverRev.rev !== "bigint")
+    //   if (hasBigIntSupport)
+    //     serverRev.rev = bigIntDef.bigint.revive(server.rev)
+    //   else
+    //     serverRev.rev = new FakeBigInt(server.rev)
+    const hasBigIntSupport = typeof BigInt(0) === 'bigint';
+    class FakeBigInt {
+        constructor(value) {
+            this.v = value;
         }
-    }
-    function spkiToPEM(keydata) {
-        const keydataB64 = b64encode(keydata);
-        const keydataB64Pem = formatAsPem(keydataB64);
-        return keydataB64Pem;
-    }
-    function formatAsPem(str) {
-        let finalString = '-----BEGIN PUBLIC KEY-----\n';
-        while (str.length > 0) {
-            finalString += str.substring(0, 64) + '\n';
-            str = str.substring(64);
+        toString() {
+            return this.v;
         }
-        finalString = finalString + '-----END PUBLIC KEY-----';
-        return finalString;
     }
+    const defs = {
+        ...undefinedDef,
+        ...(hasBigIntSupport
+            ? {}
+            : {
+                bigint: {
+                    test: (val) => val instanceof FakeBigInt,
+                    replace: (fakeBigInt) => {
+                        return {
+                            $t: 'bigint',
+                            ...fakeBigInt
+                        };
+                    },
+                    revive: ({ v, }) => new FakeBigInt(v)
+                }
+            })
+    };
+    const TSON = TypesonSimplified(builtin, defs);
+    const BISON = Bison(defs);
 
     class HttpError extends Error {
         constructor(res, message) {
@@ -3380,6 +3364,7 @@
             headers.Authorization = `Bearer ${accessToken}`;
         }
         const syncRequest = {
+            v: 2,
             dbID: syncState === null || syncState === void 0 ? void 0 : syncState.remoteDbId,
             clientIdentity,
             schema: schema || {},
@@ -3506,8 +3491,8 @@
 
     function getLatestRevisionsPerTable(clientChangeSet, lastRevisions = {}) {
         for (const { table, muts } of clientChangeSet) {
-            const lastRev = muts.length > 0 ? muts[muts.length - 1].rev || 0 : 0;
-            lastRevisions[table] = lastRev;
+            const lastRev = muts.length > 0 ? muts[muts.length - 1].rev : null;
+            lastRevisions[table] = lastRev || lastRevisions[table] || 0;
         }
         return lastRevisions;
     }
@@ -3828,16 +3813,35 @@
         const readyToServe = new rxjs.BehaviorSubject(true);
         const event = new rxjs.BehaviorSubject(null);
         let isWorking = false;
+        let loopWarning = 0;
+        let loopDetection = [0, 0, 0, 0, 0, 0, 0, 0, 0, Date.now()];
         event.subscribe(async () => {
             if (isWorking)
                 return;
             if (queue.length > 0) {
                 isWorking = true;
+                loopDetection.shift();
+                loopDetection.push(Date.now());
                 readyToServe.next(false);
                 try {
                     await consumeQueue();
                 }
                 finally {
+                    if (loopDetection[loopDetection.length - 1] - loopDetection[0] < 10000) {
+                        // Ten loops within 10 seconds. Slow down!
+                        if (Date.now() - loopWarning < 5000) {
+                            // 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));
+                        }
+                        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));
+                        }
+                    }
                     isWorking = false;
                     readyToServe.next(true);
                 }
@@ -3853,6 +3857,9 @@
                 const msg = queue.shift();
                 try {
                     console.debug('processing msg', msg);
+                    // 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();
@@ -3876,26 +3883,23 @@
                             // 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 'rev':
-                            if (!(persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.serverRevision) ||
-                                compareBigInts(persistedSyncState.serverRevision, msg.rev) < 0) {
-                                triggerSync(db, "pull");
-                            }
-                            break;
                         case 'realm-added':
                             if (!((_a = persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.realms) === null || _a === void 0 ? void 0 : _a.includes(msg.realm))) {
-                                triggerSync(db, "pull");
+                                triggerSync(db, 'pull');
                             }
                             break;
                         case 'realm-removed':
                             if ((_b = persistedSyncState === null || persistedSyncState === void 0 ? void 0 : persistedSyncState.realms) === null || _b === void 0 ? void 0 : _b.includes(msg.realm)) {
-                                triggerSync(db, "pull");
+                                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");
+                                triggerSync(db, 'pull');
                                 break;
                             }
                             await db.transaction('rw', db.dx.tables, async (tx) => {
@@ -3918,16 +3922,34 @@
                                     return; // Initial sync must have taken place - otherwise, ignore this.
                                 }
                                 // Verify again in ACID tx that we're on same server revision.
-                                if (compareBigInts(msg.baseRev, syncState.serverRevision) !== 0) {
+                                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 = await Dexie__default['default'].waitFor(computeRealmSetHash(syncState));
+                                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");
+                                    triggerSync(db, 'pull');
                                     // The message isn't based on the same realms.
                                     // Trigger a sync instead to resolve all things up.
                                     return;
@@ -3939,12 +3961,14 @@
                                     clientChanges = await listClientChanges(mutationTables, db);
                                     console.debug('msg queue: client changes', clientChanges);
                                 }
-                                const filteredChanges = filterServerChangesThroughAddedClientChanges(msg.changes, clientChanges);
-                                //
-                                // apply server changes
-                                //
-                                console.debug('applying filtered server changes', filteredChanges);
-                                await applyServerChanges(filteredChanges, db);
+                                if (msg.changes.length > 0) {
+                                    const filteredChanges = filterServerChangesThroughAddedClientChanges(msg.changes, clientChanges);
+                                    //
+                                    // apply server changes
+                                    //
+                                    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.
@@ -5025,18 +5049,19 @@
     const CLIENT_PING_INTERVAL = 30000;
     const FAIL_RETRY_WAIT_TIME = 60000;
     class WSObservable extends rxjs.Observable {
-        constructor(databaseUrl, rev, clientIdentity, messageProducer, webSocketStatus, token, tokenExpiration) {
-            super((subscriber) => new WSConnection(databaseUrl, rev, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus));
+        constructor(databaseUrl, rev, realmSetHash, clientIdentity, messageProducer, webSocketStatus, token, tokenExpiration) {
+            super((subscriber) => new WSConnection(databaseUrl, rev, realmSetHash, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus));
         }
     }
     let counter = 0;
     class WSConnection extends rxjs.Subscription {
-        constructor(databaseUrl, rev, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus) {
+        constructor(databaseUrl, rev, realmSetHash, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus) {
             super(() => this.teardown());
             this.id = ++counter;
             console.debug('New WebSocket Connection', this.id, token ? 'authorized' : 'unauthorized');
             this.databaseUrl = databaseUrl;
             this.rev = rev;
+            this.realmSetHash = realmSetHash;
             this.clientIdentity = clientIdentity;
             this.token = token;
             this.tokenExpiration = tokenExpiration;
@@ -5141,7 +5166,9 @@
             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);
@@ -5235,12 +5262,12 @@
         function createObservable() {
             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(() => db.cloud.currentUser), switchMap((userLogin) => userIsReallyActive.pipe(map((isActive) => (isActive ? userLogin : null)))), switchMap((userLogin) => 
+            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]) => 
             // 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, db.cloud.persistedSyncState.value.clientIdentity, messageProducer, db.cloud.webSocketStatus, userLogin.accessToken, userLogin.accessTokenExpiration)
+                ? 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 === null || error === void 0 ? void 0 : error.name) === 'TokenExpiredError') {
                     console.debug('WebSocket observable: Token expired. Refreshing token...');
@@ -5360,22 +5387,26 @@
         //let periodicSyncHandler: ((event: Event) => void) | null = null;
         let cancelToken = { cancelled: false };
         function syncAndRetry(purpose, retryNum = 1) {
-            syncIfPossible(db, cloudOptions, cloudSchema, {
-                cancelToken,
-                retryImmediatelyOnFetchError: true,
-                purpose
-            }).catch((e) => {
-                console.error('error in syncIfPossible()', e);
-                if (cancelToken.cancelled) {
-                    stop();
-                }
-                else if (retryNum < 3) {
-                    // Mimic service worker sync event: retry 3 times
-                    // * first retry after 5 minutes
-                    // * second retry 15 minutes later
-                    setTimeout(() => syncAndRetry(purpose, retryNum + 1), [0, 5, 15][retryNum] * MINUTES);
-                }
-            });
+            // Use setTimeout() to get onto a clean stack and
+            // break free from possible active transaction:
+            setTimeout(() => {
+                syncIfPossible(db, cloudOptions, cloudSchema, {
+                    cancelToken,
+                    retryImmediatelyOnFetchError: true,
+                    purpose,
+                }).catch((e) => {
+                    console.error('error in syncIfPossible()', e);
+                    if (cancelToken.cancelled) {
+                        stop();
+                    }
+                    else if (retryNum < 3) {
+                        // Mimic service worker sync event: retry 3 times
+                        // * first retry after 5 minutes
+                        // * second retry 15 minutes later
+                        setTimeout(() => syncAndRetry(purpose, retryNum + 1), [0, 5, 15][retryNum] * MINUTES);
+                    }
+                });
+            }, 0);
         }
         const start = () => {
             // Sync eagerly whenever a change has happened (+ initially when there's no syncState yet)
@@ -5383,7 +5414,7 @@
             console.debug('Starting LocalSyncWorker', db.localSyncEvent['id']);
             localSyncEventSubscription = db.localSyncEvent.subscribe(({ purpose }) => {
                 try {
-                    syncAndRetry(purpose || "pull");
+                    syncAndRetry(purpose || 'pull');
                 }
                 catch (err) {
                     console.error('What-the....', err);
@@ -5961,6 +5992,7 @@
                     // Avoid race conditions.
                     managedDBs.delete(db.name);
                 }
+                console.debug(`Dexie Cloud SW: Closing Dexie instance for ${dbName}`);
                 db.dx.close();
                 return false;
             }
@@ -6007,7 +6039,7 @@
                 // Mimic background sync behavior - retry in X minutes on failure.
                 // But lesser timeout and more number of times.
                 const syncAndRetry = (num = 1) => {
-                    return syncDB(dbName, event.data.purpuse || "pull").catch(async (e) => {
+                    return syncDB(dbName, event.data.purpose || "pull").catch(async (e) => {
                         if (num === 3)
                             throw e;
                         await sleep(60000); // 1 minute