dexie-cloud-addon 4.0.8 → 4.1.0-alpha.3

package/dist/umd/service-worker.js

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.0.8, Tue Jun 04 2024
+ * Version 4.1.0-alpha.3, Fri Oct 11 2024
  *
  * https://dexie.org
  *
@@ -2245,6 +2245,1075 @@
             : url.pathname.split('/')[1];
     }
 
+    /**
+     * Common Math expressions.
+     *
+     * @module math
+     */
+
+    const floor = Math.floor;
+    const abs = Math.abs;
+
+    /**
+     * @function
+     * @param {number} a
+     * @param {number} b
+     * @return {number} The smaller element of a and b
+     */
+    const min = (a, b) => a < b ? a : b;
+
+    /**
+     * @function
+     * @param {number} a
+     * @param {number} b
+     * @return {number} The bigger element of a and b
+     */
+    const max = (a, b) => a > b ? a : b;
+
+    /**
+     * @param {number} n
+     * @return {boolean} Wether n is negative. This function also differentiates between -0 and +0
+     */
+    const isNegativeZero = n => n !== 0 ? n < 0 : 1 / n < 0;
+
+    /* eslint-env browser */
+
+    const BIT7 = 64;
+    const BIT8 = 128;
+    const BITS6 = 63;
+    const BITS7 = 127;
+    /**
+     * @type {number}
+     */
+    const BITS31 = 0x7FFFFFFF;
+
+    /**
+     * Utility helpers for working with numbers.
+     *
+     * @module number
+     */
+
+
+    const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+
+    /* c8 ignore next */
+    const isInteger = Number.isInteger || (num => typeof num === 'number' && isFinite(num) && floor(num) === num);
+
+    /**
+     * Utility module to work with Arrays.
+     *
+     * @module array
+     */
+
+
+    const isArray = Array.isArray;
+
+    /**
+     * @param {string} str
+     * @return {Uint8Array}
+     */
+    const _encodeUtf8Polyfill = str => {
+      const encodedString = unescape(encodeURIComponent(str));
+      const len = encodedString.length;
+      const buf = new Uint8Array(len);
+      for (let i = 0; i < len; i++) {
+        buf[i] = /** @type {number} */ (encodedString.codePointAt(i));
+      }
+      return buf
+    };
+
+    /* c8 ignore next */
+    const utf8TextEncoder = /** @type {TextEncoder} */ (typeof TextEncoder !== 'undefined' ? new TextEncoder() : null);
+
+    /**
+     * @param {string} str
+     * @return {Uint8Array}
+     */
+    const _encodeUtf8Native = str => utf8TextEncoder.encode(str);
+
+    /**
+     * @param {string} str
+     * @return {Uint8Array}
+     */
+    /* c8 ignore next */
+    const encodeUtf8 = utf8TextEncoder ? _encodeUtf8Native : _encodeUtf8Polyfill;
+
+    /* c8 ignore next */
+    let utf8TextDecoder = typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+
+    /* c8 ignore start */
+    if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
+      // Safari doesn't handle BOM correctly.
+      // This fixes a bug in Safari 13.0.5 where it produces a BOM the first time it is called.
+      // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the first call and
+      // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the second call
+      // Another issue is that from then on no BOM chars are recognized anymore
+      /* c8 ignore next */
+      utf8TextDecoder = null;
+    }
+
+    /**
+     * Efficient schema-less binary encoding with support for variable length encoding.
+     *
+     * Use [lib0/encoding] with [lib0/decoding]. Every encoding function has a corresponding decoding function.
+     *
+     * Encodes numbers in little-endian order (least to most significant byte order)
+     * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
+     * which is also used in Protocol Buffers.
+     *
+     * ```js
+     * // encoding step
+     * const encoder = encoding.createEncoder()
+     * encoding.writeVarUint(encoder, 256)
+     * encoding.writeVarString(encoder, 'Hello world!')
+     * const buf = encoding.toUint8Array(encoder)
+     * ```
+     *
+     * ```js
+     * // decoding step
+     * const decoder = decoding.createDecoder(buf)
+     * decoding.readVarUint(decoder) // => 256
+     * decoding.readVarString(decoder) // => 'Hello world!'
+     * decoding.hasContent(decoder) // => false - all data is read
+     * ```
+     *
+     * @module encoding
+     */
+
+
+    /**
+     * A BinaryEncoder handles the encoding to an Uint8Array.
+     */
+    class Encoder {
+      constructor () {
+        this.cpos = 0;
+        this.cbuf = new Uint8Array(100);
+        /**
+         * @type {Array<Uint8Array>}
+         */
+        this.bufs = [];
+      }
+    }
+
+    /**
+     * The current length of the encoded data.
+     *
+     * @function
+     * @param {Encoder} encoder
+     * @return {number}
+     */
+    const length = encoder => {
+      let len = encoder.cpos;
+      for (let i = 0; i < encoder.bufs.length; i++) {
+        len += encoder.bufs[i].length;
+      }
+      return len
+    };
+
+    /**
+     * Transform to Uint8Array.
+     *
+     * @function
+     * @param {Encoder} encoder
+     * @return {Uint8Array} The created ArrayBuffer.
+     */
+    const toUint8Array = encoder => {
+      const uint8arr = new Uint8Array(length(encoder));
+      let curPos = 0;
+      for (let i = 0; i < encoder.bufs.length; i++) {
+        const d = encoder.bufs[i];
+        uint8arr.set(d, curPos);
+        curPos += d.length;
+      }
+      uint8arr.set(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos), curPos);
+      return uint8arr
+    };
+
+    /**
+     * Verify that it is possible to write `len` bytes wtihout checking. If
+     * necessary, a new Buffer with the required length is attached.
+     *
+     * @param {Encoder} encoder
+     * @param {number} len
+     */
+    const verifyLen = (encoder, len) => {
+      const bufferLen = encoder.cbuf.length;
+      if (bufferLen - encoder.cpos < len) {
+        encoder.bufs.push(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos));
+        encoder.cbuf = new Uint8Array(max(bufferLen, len) * 2);
+        encoder.cpos = 0;
+      }
+    };
+
+    /**
+     * Write one byte to the encoder.
+     *
+     * @function
+     * @param {Encoder} encoder
+     * @param {number} num The byte that is to be encoded.
+     */
+    const write = (encoder, num) => {
+      const bufferLen = encoder.cbuf.length;
+      if (encoder.cpos === bufferLen) {
+        encoder.bufs.push(encoder.cbuf);
+        encoder.cbuf = new Uint8Array(bufferLen * 2);
+        encoder.cpos = 0;
+      }
+      encoder.cbuf[encoder.cpos++] = num;
+    };
+
+    /**
+     * Write a variable length unsigned integer. Max encodable integer is 2^53.
+     *
+     * @function
+     * @param {Encoder} encoder
+     * @param {number} num The number that is to be encoded.
+     */
+    const writeVarUint = (encoder, num) => {
+      while (num > BITS7) {
+        write(encoder, BIT8 | (BITS7 & num));
+        num = floor(num / 128); // shift >>> 7
+      }
+      write(encoder, BITS7 & num);
+    };
+
+    /**
+     * Write a variable length integer.
+     *
+     * We use the 7th bit instead for signaling that this is a negative number.
+     *
+     * @function
+     * @param {Encoder} encoder
+     * @param {number} num The number that is to be encoded.
+     */
+    const writeVarInt = (encoder, num) => {
+      const isNegative = isNegativeZero(num);
+      if (isNegative) {
+        num = -num;
+      }
+      //             |- whether to continue reading         |- whether is negative     |- number
+      write(encoder, (num > BITS6 ? BIT8 : 0) | (isNegative ? BIT7 : 0) | (BITS6 & num));
+      num = floor(num / 64); // shift >>> 6
+      // We don't need to consider the case of num === 0 so we can use a different
+      // pattern here than above.
+      while (num > 0) {
+        write(encoder, (num > BITS7 ? BIT8 : 0) | (BITS7 & num));
+        num = floor(num / 128); // shift >>> 7
+      }
+    };
+
+    /**
+     * A cache to store strings temporarily
+     */
+    const _strBuffer = new Uint8Array(30000);
+    const _maxStrBSize = _strBuffer.length / 3;
+
+    /**
+     * Write a variable length string.
+     *
+     * @function
+     * @param {Encoder} encoder
+     * @param {String} str The string that is to be encoded.
+     */
+    const _writeVarStringNative = (encoder, str) => {
+      if (str.length < _maxStrBSize) {
+        // We can encode the string into the existing buffer
+        /* c8 ignore next */
+        const written = utf8TextEncoder.encodeInto(str, _strBuffer).written || 0;
+        writeVarUint(encoder, written);
+        for (let i = 0; i < written; i++) {
+          write(encoder, _strBuffer[i]);
+        }
+      } else {
+        writeVarUint8Array(encoder, encodeUtf8(str));
+      }
+    };
+
+    /**
+     * Write a variable length string.
+     *
+     * @function
+     * @param {Encoder} encoder
+     * @param {String} str The string that is to be encoded.
+     */
+    const _writeVarStringPolyfill = (encoder, str) => {
+      const encodedString = unescape(encodeURIComponent(str));
+      const len = encodedString.length;
+      writeVarUint(encoder, len);
+      for (let i = 0; i < len; i++) {
+        write(encoder, /** @type {number} */ (encodedString.codePointAt(i)));
+      }
+    };
+
+    /**
+     * Write a variable length string.
+     *
+     * @function
+     * @param {Encoder} encoder
+     * @param {String} str The string that is to be encoded.
+     */
+    /* c8 ignore next */
+    const writeVarString = (utf8TextEncoder && /** @type {any} */ (utf8TextEncoder).encodeInto) ? _writeVarStringNative : _writeVarStringPolyfill;
+
+    /**
+     * Append fixed-length Uint8Array to the encoder.
+     *
+     * @function
+     * @param {Encoder} encoder
+     * @param {Uint8Array} uint8Array
+     */
+    const writeUint8Array = (encoder, uint8Array) => {
+      const bufferLen = encoder.cbuf.length;
+      const cpos = encoder.cpos;
+      const leftCopyLen = min(bufferLen - cpos, uint8Array.length);
+      const rightCopyLen = uint8Array.length - leftCopyLen;
+      encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos);
+      encoder.cpos += leftCopyLen;
+      if (rightCopyLen > 0) {
+        // Still something to write, write right half..
+        // Append new buffer
+        encoder.bufs.push(encoder.cbuf);
+        // must have at least size of remaining buffer
+        encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
+        // copy array
+        encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
+        encoder.cpos = rightCopyLen;
+      }
+    };
+
+    /**
+     * Append an Uint8Array to Encoder.
+     *
+     * @function
+     * @param {Encoder} encoder
+     * @param {Uint8Array} uint8Array
+     */
+    const writeVarUint8Array = (encoder, uint8Array) => {
+      writeVarUint(encoder, uint8Array.byteLength);
+      writeUint8Array(encoder, uint8Array);
+    };
+
+    /**
+     * Create an DataView of the next `len` bytes. Use it to write data after
+     * calling this function.
+     *
+     * ```js
+     * // write float32 using DataView
+     * const dv = writeOnDataView(encoder, 4)
+     * dv.setFloat32(0, 1.1)
+     * // read float32 using DataView
+     * const dv = readFromDataView(encoder, 4)
+     * dv.getFloat32(0) // => 1.100000023841858 (leaving it to the reader to find out why this is the correct result)
+     * ```
+     *
+     * @param {Encoder} encoder
+     * @param {number} len
+     * @return {DataView}
+     */
+    const writeOnDataView = (encoder, len) => {
+      verifyLen(encoder, len);
+      const dview = new DataView(encoder.cbuf.buffer, encoder.cpos, len);
+      encoder.cpos += len;
+      return dview
+    };
+
+    /**
+     * @param {Encoder} encoder
+     * @param {number} num
+     */
+    const writeFloat32 = (encoder, num) => writeOnDataView(encoder, 4).setFloat32(0, num, false);
+
+    /**
+     * @param {Encoder} encoder
+     * @param {number} num
+     */
+    const writeFloat64 = (encoder, num) => writeOnDataView(encoder, 8).setFloat64(0, num, false);
+
+    /**
+     * @param {Encoder} encoder
+     * @param {bigint} num
+     */
+    const writeBigInt64 = (encoder, num) => /** @type {any} */ (writeOnDataView(encoder, 8)).setBigInt64(0, num, false);
+
+    /**
+     * @param {Encoder} encoder
+     * @param {bigint} num
+     */
+    const writeBigUint64 = (encoder, num) => /** @type {any} */ (writeOnDataView(encoder, 8)).setBigUint64(0, num, false);
+
+    const floatTestBed = new DataView(new ArrayBuffer(4));
+    /**
+     * Check if a number can be encoded as a 32 bit float.
+     *
+     * @param {number} num
+     * @return {boolean}
+     */
+    const isFloat32 = num => {
+      floatTestBed.setFloat32(0, num);
+      return floatTestBed.getFloat32(0) === num
+    };
+
+    /**
+     * Encode data with efficient binary format.
+     *
+     * Differences to JSON:
+     * • Transforms data to a binary format (not to a string)
+     * • Encodes undefined, NaN, and ArrayBuffer (these can't be represented in JSON)
+     * • Numbers are efficiently encoded either as a variable length integer, as a
+     *   32 bit float, as a 64 bit float, or as a 64 bit bigint.
+     *
+     * Encoding table:
+     *
+     * | Data Type           | Prefix   | Encoding Method    | Comment |
+     * | ------------------- | -------- | ------------------ | ------- |
+     * | undefined           | 127      |                    | Functions, symbol, and everything that cannot be identified is encoded as undefined |
+     * | null                | 126      |                    | |
+     * | integer             | 125      | writeVarInt        | Only encodes 32 bit signed integers |
+     * | float32             | 124      | writeFloat32       | |
+     * | float64             | 123      | writeFloat64       | |
+     * | bigint              | 122      | writeBigInt64      | |
+     * | boolean (false)     | 121      |                    | True and false are different data types so we save the following byte |
+     * | boolean (true)      | 120      |                    | - 0b01111000 so the last bit determines whether true or false |
+     * | string              | 119      | writeVarString     | |
+     * | object<string,any>  | 118      | custom             | Writes {length} then {length} key-value pairs |
+     * | array<any>          | 117      | custom             | Writes {length} then {length} json values |
+     * | Uint8Array          | 116      | writeVarUint8Array | We use Uint8Array for any kind of binary data |
+     *
+     * Reasons for the decreasing prefix:
+     * We need the first bit for extendability (later we may want to encode the
+     * prefix with writeVarUint). The remaining 7 bits are divided as follows:
+     * [0-30]   the beginning of the data range is used for custom purposes
+     *          (defined by the function that uses this library)
+     * [31-127] the end of the data range is used for data encoding by
+     *          lib0/encoding.js
+     *
+     * @param {Encoder} encoder
+     * @param {undefined|null|number|bigint|boolean|string|Object<string,any>|Array<any>|Uint8Array} data
+     */
+    const writeAny = (encoder, data) => {
+      switch (typeof data) {
+        case 'string':
+          // TYPE 119: STRING
+          write(encoder, 119);
+          writeVarString(encoder, data);
+          break
+        case 'number':
+          if (isInteger(data) && abs(data) <= BITS31) {
+            // TYPE 125: INTEGER
+            write(encoder, 125);
+            writeVarInt(encoder, data);
+          } else if (isFloat32(data)) {
+            // TYPE 124: FLOAT32
+            write(encoder, 124);
+            writeFloat32(encoder, data);
+          } else {
+            // TYPE 123: FLOAT64
+            write(encoder, 123);
+            writeFloat64(encoder, data);
+          }
+          break
+        case 'bigint':
+          // TYPE 122: BigInt
+          write(encoder, 122);
+          writeBigInt64(encoder, data);
+          break
+        case 'object':
+          if (data === null) {
+            // TYPE 126: null
+            write(encoder, 126);
+          } else if (isArray(data)) {
+            // TYPE 117: Array
+            write(encoder, 117);
+            writeVarUint(encoder, data.length);
+            for (let i = 0; i < data.length; i++) {
+              writeAny(encoder, data[i]);
+            }
+          } else if (data instanceof Uint8Array) {
+            // TYPE 116: ArrayBuffer
+            write(encoder, 116);
+            writeVarUint8Array(encoder, data);
+          } else {
+            // TYPE 118: Object
+            write(encoder, 118);
+            const keys = Object.keys(data);
+            writeVarUint(encoder, keys.length);
+            for (let i = 0; i < keys.length; i++) {
+              const key = keys[i];
+              writeVarString(encoder, key);
+              writeAny(encoder, data[key]);
+            }
+          }
+          break
+        case 'boolean':
+          // TYPE 120/121: boolean (true/false)
+          write(encoder, data ? 120 : 121);
+          break
+        default:
+          // TYPE 127: undefined
+          write(encoder, 127);
+      }
+    };
+
+    function encodeYMessage(msg) {
+        const encoder = new Encoder();
+        writeVarString(encoder, msg.type);
+        writeVarString(encoder, msg.table);
+        writeVarString(encoder, msg.prop);
+        switch (msg.type) {
+            case 'u-ack':
+            case 'u-reject':
+                writeBigUint64(encoder, BigInt(msg.i));
+                break;
+            default:
+                writeAny(encoder, msg.k);
+                switch (msg.type) {
+                    case 'aware':
+                        writeVarUint8Array(encoder, msg.u);
+                        break;
+                    case 'doc-open':
+                        writeAny(encoder, msg.serverRev);
+                        writeAny(encoder, msg.sv);
+                        break;
+                    case 'doc-close':
+                        break;
+                    case 'sv':
+                        writeVarUint8Array(encoder, msg.sv);
+                        break;
+                    case 'u-c':
+                        writeVarUint8Array(encoder, msg.u);
+                        writeBigUint64(encoder, BigInt(msg.i));
+                        break;
+                    case 'u-s':
+                        writeVarUint8Array(encoder, msg.u);
+                        break;
+                }
+        }
+        return toUint8Array(encoder);
+    }
+
+    /**
+     * Error helpers.
+     *
+     * @module error
+     */
+
+    /**
+     * @param {string} s
+     * @return {Error}
+     */
+    /* c8 ignore next */
+    const create = s => new Error(s);
+
+    /**
+     * Efficient schema-less binary decoding with support for variable length encoding.
+     *
+     * Use [lib0/decoding] with [lib0/encoding]. Every encoding function has a corresponding decoding function.
+     *
+     * Encodes numbers in little-endian order (least to most significant byte order)
+     * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
+     * which is also used in Protocol Buffers.
+     *
+     * ```js
+     * // encoding step
+     * const encoder = encoding.createEncoder()
+     * encoding.writeVarUint(encoder, 256)
+     * encoding.writeVarString(encoder, 'Hello world!')
+     * const buf = encoding.toUint8Array(encoder)
+     * ```
+     *
+     * ```js
+     * // decoding step
+     * const decoder = decoding.createDecoder(buf)
+     * decoding.readVarUint(decoder) // => 256
+     * decoding.readVarString(decoder) // => 'Hello world!'
+     * decoding.hasContent(decoder) // => false - all data is read
+     * ```
+     *
+     * @module decoding
+     */
+
+
+    const errorUnexpectedEndOfArray = create('Unexpected end of array');
+    const errorIntegerOutOfRange = create('Integer out of Range');
+
+    /**
+     * A Decoder handles the decoding of an Uint8Array.
+     */
+    class Decoder {
+      /**
+       * @param {Uint8Array} uint8Array Binary data to decode
+       */
+      constructor (uint8Array) {
+        /**
+         * Decoding target.
+         *
+         * @type {Uint8Array}
+         */
+        this.arr = uint8Array;
+        /**
+         * Current decoding position.
+         *
+         * @type {number}
+         */
+        this.pos = 0;
+      }
+    }
+
+    /**
+     * @function
+     * @param {Decoder} decoder
+     * @return {boolean}
+     */
+    const hasContent = decoder => decoder.pos !== decoder.arr.length;
+
+    /**
+     * Create an Uint8Array view of the next `len` bytes and advance the position by `len`.
+     *
+     * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+     *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+     *
+     * @function
+     * @param {Decoder} decoder The decoder instance
+     * @param {number} len The length of bytes to read
+     * @return {Uint8Array}
+     */
+    const readUint8Array = (decoder, len) => {
+      const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
+      decoder.pos += len;
+      return view
+    };
+
+    /**
+     * Read variable length Uint8Array.
+     *
+     * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+     *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+     *
+     * @function
+     * @param {Decoder} decoder
+     * @return {Uint8Array}
+     */
+    const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint(decoder));
+
+    /**
+     * Read one byte as unsigned integer.
+     * @function
+     * @param {Decoder} decoder The decoder instance
+     * @return {number} Unsigned 8-bit integer
+     */
+    const readUint8 = decoder => decoder.arr[decoder.pos++];
+
+    /**
+     * Read unsigned integer (32bit) with variable length.
+     * 1/8th of the storage is used as encoding overhead.
+     *  * numbers < 2^7 is stored in one bytlength
+     *  * numbers < 2^14 is stored in two bylength
+     *
+     * @function
+     * @param {Decoder} decoder
+     * @return {number} An unsigned integer.length
+     */
+    const readVarUint = decoder => {
+      let num = 0;
+      let mult = 1;
+      const len = decoder.arr.length;
+      while (decoder.pos < len) {
+        const r = decoder.arr[decoder.pos++];
+        // num = num | ((r & binary.BITS7) << len)
+        num = num + (r & BITS7) * mult; // shift $r << (7*#iterations) and add it to num
+        mult *= 128; // next iteration, shift 7 "more" to the left
+        if (r < BIT8) {
+          return num
+        }
+        /* c8 ignore start */
+        if (num > MAX_SAFE_INTEGER) {
+          throw errorIntegerOutOfRange
+        }
+        /* c8 ignore stop */
+      }
+      throw errorUnexpectedEndOfArray
+    };
+
+    /**
+     * Read signed integer (32bit) with variable length.
+     * 1/8th of the storage is used as encoding overhead.
+     *  * numbers < 2^7 is stored in one bytlength
+     *  * numbers < 2^14 is stored in two bylength
+     * @todo This should probably create the inverse ~num if number is negative - but this would be a breaking change.
+     *
+     * @function
+     * @param {Decoder} decoder
+     * @return {number} An unsigned integer.length
+     */
+    const readVarInt = decoder => {
+      let r = decoder.arr[decoder.pos++];
+      let num = r & BITS6;
+      let mult = 64;
+      const sign = (r & BIT7) > 0 ? -1 : 1;
+      if ((r & BIT8) === 0) {
+        // don't continue reading
+        return sign * num
+      }
+      const len = decoder.arr.length;
+      while (decoder.pos < len) {
+        r = decoder.arr[decoder.pos++];
+        // num = num | ((r & binary.BITS7) << len)
+        num = num + (r & BITS7) * mult;
+        mult *= 128;
+        if (r < BIT8) {
+          return sign * num
+        }
+        /* c8 ignore start */
+        if (num > MAX_SAFE_INTEGER) {
+          throw errorIntegerOutOfRange
+        }
+        /* c8 ignore stop */
+      }
+      throw errorUnexpectedEndOfArray
+    };
+
+    /**
+     * We don't test this function anymore as we use native decoding/encoding by default now.
+     * Better not modify this anymore..
+     *
+     * Transforming utf8 to a string is pretty expensive. The code performs 10x better
+     * when String.fromCodePoint is fed with all characters as arguments.
+     * But most environments have a maximum number of arguments per functions.
+     * For effiency reasons we apply a maximum of 10000 characters at once.
+     *
+     * @function
+     * @param {Decoder} decoder
+     * @return {String} The read String.
+     */
+    /* c8 ignore start */
+    const _readVarStringPolyfill = decoder => {
+      let remainingLen = readVarUint(decoder);
+      if (remainingLen === 0) {
+        return ''
+      } else {
+        let encodedString = String.fromCodePoint(readUint8(decoder)); // remember to decrease remainingLen
+        if (--remainingLen < 100) { // do not create a Uint8Array for small strings
+          while (remainingLen--) {
+            encodedString += String.fromCodePoint(readUint8(decoder));
+          }
+        } else {
+          while (remainingLen > 0) {
+            const nextLen = remainingLen < 10000 ? remainingLen : 10000;
+            // this is dangerous, we create a fresh array view from the existing buffer
+            const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen);
+            decoder.pos += nextLen;
+            // Starting with ES5.1 we can supply a generic array-like object as arguments
+            encodedString += String.fromCodePoint.apply(null, /** @type {any} */ (bytes));
+            remainingLen -= nextLen;
+          }
+        }
+        return decodeURIComponent(escape(encodedString))
+      }
+    };
+    /* c8 ignore stop */
+
+    /**
+     * @function
+     * @param {Decoder} decoder
+     * @return {String} The read String
+     */
+    const _readVarStringNative = decoder =>
+      /** @type any */ (utf8TextDecoder).decode(readVarUint8Array(decoder));
+
+    /**
+     * Read string of variable length
+     * * varUint is used to store the length of the string
+     *
+     * @function
+     * @param {Decoder} decoder
+     * @return {String} The read String
+     *
+     */
+    /* c8 ignore next */
+    const readVarString = utf8TextDecoder ? _readVarStringNative : _readVarStringPolyfill;
+
+    /**
+     * @param {Decoder} decoder
+     * @param {number} len
+     * @return {DataView}
+     */
+    const readFromDataView = (decoder, len) => {
+      const dv = new DataView(decoder.arr.buffer, decoder.arr.byteOffset + decoder.pos, len);
+      decoder.pos += len;
+      return dv
+    };
+
+    /**
+     * @param {Decoder} decoder
+     */
+    const readFloat32 = decoder => readFromDataView(decoder, 4).getFloat32(0, false);
+
+    /**
+     * @param {Decoder} decoder
+     */
+    const readFloat64 = decoder => readFromDataView(decoder, 8).getFloat64(0, false);
+
+    /**
+     * @param {Decoder} decoder
+     */
+    const readBigInt64 = decoder => /** @type {any} */ (readFromDataView(decoder, 8)).getBigInt64(0, false);
+
+    /**
+     * @param {Decoder} decoder
+     */
+    const readBigUint64 = decoder => /** @type {any} */ (readFromDataView(decoder, 8)).getBigUint64(0, false);
+
+    /**
+     * @type {Array<function(Decoder):any>}
+     */
+    const readAnyLookupTable = [
+      decoder => undefined, // CASE 127: undefined
+      decoder => null, // CASE 126: null
+      readVarInt, // CASE 125: integer
+      readFloat32, // CASE 124: float32
+      readFloat64, // CASE 123: float64
+      readBigInt64, // CASE 122: bigint
+      decoder => false, // CASE 121: boolean (false)
+      decoder => true, // CASE 120: boolean (true)
+      readVarString, // CASE 119: string
+      decoder => { // CASE 118: object<string,any>
+        const len = readVarUint(decoder);
+        /**
+         * @type {Object<string,any>}
+         */
+        const obj = {};
+        for (let i = 0; i < len; i++) {
+          const key = readVarString(decoder);
+          obj[key] = readAny(decoder);
+        }
+        return obj
+      },
+      decoder => { // CASE 117: array<any>
+        const len = readVarUint(decoder);
+        const arr = [];
+        for (let i = 0; i < len; i++) {
+          arr.push(readAny(decoder));
+        }
+        return arr
+      },
+      readVarUint8Array // CASE 116: Uint8Array
+    ];
+
+    /**
+     * @param {Decoder} decoder
+     */
+    const readAny = decoder => readAnyLookupTable[127 - readUint8(decoder)](decoder);
+
+    function decodeYMessage(a) {
+        const decoder = new Decoder(a);
+        const type = readVarString(decoder);
+        const table = readVarString(decoder);
+        const prop = readVarString(decoder);
+        switch (type) {
+            case 'u-ack':
+            case 'u-reject':
+                return {
+                    type,
+                    table,
+                    prop,
+                    i: Number(readBigUint64(decoder)),
+                };
+            default: {
+                const k = readAny(decoder);
+                switch (type) {
+                    case 'in-sync':
+                        return { type, table, prop, k };
+                    case 'aware':
+                        return {
+                            type,
+                            table,
+                            prop,
+                            k,
+                            u: readVarUint8Array(decoder),
+                        };
+                    case 'doc-open':
+                        return {
+                            type,
+                            table,
+                            prop,
+                            k,
+                            serverRev: readAny(decoder),
+                            sv: readAny(decoder),
+                        };
+                    case 'doc-close':
+                        return { type, table, prop, k };
+                    case 'sv':
+                        return {
+                            type,
+                            table,
+                            prop,
+                            k,
+                            sv: readVarUint8Array(decoder),
+                        };
+                    case 'u-c':
+                        return {
+                            type,
+                            table,
+                            prop,
+                            k,
+                            u: readVarUint8Array(decoder),
+                            i: Number(readBigUint64(decoder)),
+                        };
+                    case 'u-s':
+                        return {
+                            type,
+                            table,
+                            prop,
+                            k,
+                            u: readVarUint8Array(decoder)
+                        };
+                    default:
+                        throw new TypeError(`Unknown message type: ${type}`);
+                }
+            }
+        }
+    }
+
+    async function asyncIterablePipeline(source, ...stages) {
+        var _a, e_1, _b, _c;
+        // Chain generators by sending outdata from one to another
+        let result = source(); // Start with the source generator
+        for (let i = 0; i < stages.length; i++) {
+            result = stages[i](result); // Pass on the result to next generator
+        }
+        try {
+            // Start running the machine. If the last stage is a sink, it will consume the data and never emit anything
+            // to us here...
+            for (var _d = true, result_1 = __asyncValues(result), result_1_1; result_1_1 = await result_1.next(), _a = result_1_1.done, !_a; _d = true) {
+                _c = result_1_1.value;
+                _d = false;
+                const chunk = _c;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = result_1.return)) await _b.call(result_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+
+    function consumeChunkedBinaryStream(source) {
+        return __asyncGenerator(this, arguments, function* consumeChunkedBinaryStream_1() {
+            var _a, e_1, _b, _c;
+            let state = 0;
+            let sizeBuf = new Uint8Array(4);
+            let sizeBufPos = 0;
+            let bufs = [];
+            let len = 0;
+            try {
+                for (var _d = true, source_1 = __asyncValues(source), source_1_1; source_1_1 = yield __await(source_1.next()), _a = source_1_1.done, !_a; _d = true) {
+                    _c = source_1_1.value;
+                    _d = false;
+                    const chunk = _c;
+                    const dw = new DataView(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+                    let pos = 0;
+                    while (pos < chunk.byteLength) {
+                        switch (state) {
+                            case 0:
+                                // Beginning of a size header
+                                if (pos + 4 > chunk.byteLength) {
+                                    for (const b of chunk.slice(pos)) {
+                                        if (sizeBufPos === 4)
+                                            break;
+                                        sizeBuf[sizeBufPos++] = b;
+                                        ++pos;
+                                    }
+                                    if (sizeBufPos < 4) {
+                                        // Need more bytes in order to read length.
+                                        // Will go out from while loop as well because pos is defenitely = chunk.byteLength here.
+                                        break;
+                                    }
+                                }
+                                else if (sizeBufPos > 0 && sizeBufPos < 4) {
+                                    for (const b of chunk.slice(pos, pos + 4 - sizeBufPos)) {
+                                        sizeBuf[sizeBufPos++] = b;
+                                        ++pos;
+                                    }
+                                }
+                            // Intentional fall-through...
+                            case 1:
+                                len =
+                                    sizeBufPos === 4
+                                        ? new DataView(sizeBuf.buffer, 0, 4).getUint32(0, false)
+                                        : dw.getUint32(pos, false);
+                                if (sizeBufPos)
+                                    sizeBufPos = 0; // in this case pos is already forwarded
+                                else
+                                    pos += 4; // else pos is not yet forwarded - that's why we do it now
+                            // Intentional fall-through...
+                            case 2:
+                                // Eat the chunk
+                                if (pos >= chunk.byteLength) {
+                                    state = 2;
+                                    break;
+                                }
+                                if (pos + len > chunk.byteLength) {
+                                    bufs.push(chunk.slice(pos));
+                                    len -= (chunk.byteLength - pos);
+                                    state = 2;
+                                    pos = chunk.byteLength; // will break while loop.
+                                }
+                                else {
+                                    if (bufs.length > 0) {
+                                        const concats = new Uint8Array(bufs.reduce((p, c) => p + c.byteLength, len));
+                                        let p = 0;
+                                        for (const buf of bufs) {
+                                            concats.set(buf, p);
+                                            p += buf.byteLength;
+                                        }
+                                        concats.set(chunk.slice(pos, pos + len), p);
+                                        bufs = [];
+                                        yield yield __await(concats);
+                                    }
+                                    else {
+                                        yield yield __await(chunk.slice(pos, pos + len));
+                                    }
+                                    pos += len;
+                                    state = 0;
+                                }
+                                break;
+                        }
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = source_1.return)) yield __await(_b.call(source_1));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        });
+    }
+
+    function getFetchResponseBodyGenerator(res) {
+        return function () {
+            return __asyncGenerator(this, arguments, function* () {
+                if (!res.body)
+                    throw new Error("Response body is not readable");
+                const reader = res.body.getReader();
+                try {
+                    while (true) {
+                        const { done, value } = yield __await(reader.read());
+                        if (done)
+                            return yield __await(void 0);
+                        yield yield __await(value);
+                    }
+                }
+                finally {
+                    reader.releaseLock();
+                }
+            });
+        };
+    }
+
     function listSyncifiedChanges(tablesToSyncify, currentUser, schema, alreadySyncedRealms) {
         return __awaiter(this, void 0, void 0, function* () {
             const txid = `upload-${randomString$1(8)}`;
@@ -3311,7 +4380,7 @@
     }
 
     //import {BisonWebStreamReader} from "dreambase-library/dist/typeson-simplified/BisonWebStreamReader";
-    function syncWithServer(changes, syncState, baseRevs, db, databaseUrl, schema, clientIdentity, currentUser) {
+    function syncWithServer(changes, y, syncState, baseRevs, db, databaseUrl, schema, clientIdentity, currentUser) {
         return __awaiter(this, void 0, void 0, function* () {
             //
             // Push changes to server using fetch
@@ -3349,6 +4418,7 @@
                     : undefined,
                 baseRevs,
                 changes: encodeIdsForServer(db.dx.core.schema, currentUser, changes),
+                y,
             };
             console.debug('Sync request', syncRequest);
             db.syncStateChangedEvent.next({
@@ -3562,6 +4632,357 @@
         });
     }
 
+    const DEXIE_CLOUD_SYNCER_ID = 'dexie-cloud-syncer';
+
+    function listUpdatesSince(yTable, sinceIncluding) {
+        return yTable
+            .where('i')
+            .between(sinceIncluding, Infinity, true)
+            .toArray();
+    }
+
+    function $Y(db) {
+        const $Y = db.dx._options.Y;
+        if (!$Y)
+            throw new Error('Y library not supplied to Dexie constructor');
+        return $Y;
+    }
+
+    /** Queries the local database for YMessages to send to server.
+     *
+     * There are 2 messages that this function can provide:
+     *   YUpdateFromClientRequest ( for local updates )
+     *   YStateVector ( for state vector of foreign updates so that server can reduce the number of udpates to send back )
+     *
+     * Notice that we do not do a step 1 sync phase here to get a state vector from the server. Reason we can avoid
+     * the 2-step sync is that we are client-server and not client-client here and we keep track of the client changes
+     * sent to server by letting server acknowledge them. There is always a chance that some client update has already
+     * been sent and that the client failed to receive the ack. However, if this happens it does not matter - the change
+     * would be sent again and Yjs handles duplicate changes anyway. And it's rare so we earn the cost of roundtrips by
+     * avoiding the step1 sync and instead keep track of this in the `unsentFrom` property of the SyncState.
+     *
+     * @param db
+     * @returns
+     */
+    function listYClientMessagesAndStateVector(db, tablesToSync) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = [];
+            const lastUpdateIds = {};
+            for (const table of tablesToSync) {
+                if (table.schema.yProps) {
+                    for (const yProp of table.schema.yProps) {
+                        const Y = $Y(db); // This is how we retrieve the user-provided Y library
+                        const yTable = db.table(yProp.updatesTable); // the updates-table for this combo of table+propName
+                        const syncState = (yield yTable.get(DEXIE_CLOUD_SYNCER_ID));
+                        // unsentFrom = the `i` value of updates that aren't yet sent to server (or at least not acked by the server yet)
+                        const unsentFrom = (syncState === null || syncState === void 0 ? void 0 : syncState.unsentFrom) || 1;
+                        // receivedUntil = the `i` value of updates that both we and the server knows we already have (we know it by the outcome from last syncWithServer() because server keep track of its revision numbers
+                        const receivedUntil = (syncState === null || syncState === void 0 ? void 0 : syncState.receivedUntil) || 0;
+                        // Compute the least value of these two (but since receivedUntil is inclusive we need to add +1 to it)
+                        const unsyncedFrom = Math.min(unsentFrom, receivedUntil + 1);
+                        // Query all these updates for all docs of this table+prop combination
+                        const updates = yield listUpdatesSince(yTable, unsyncedFrom);
+                        if (updates.length > 0)
+                            lastUpdateIds[yTable.name] = updates[updates.length - 1].i;
+                        // Now sort them by document and whether they are local or not + ignore local updates already sent:
+                        const perDoc = {};
+                        for (const update of updates) {
+                            // Sort updates into buckets of the doc primary key + the flag (whether it's local or foreign)
+                            const isLocal = ((update.f || 0) & 0x01) === 0x01;
+                            if (isLocal && update.i < unsentFrom)
+                                continue; // This local update has already been sent and acked.
+                            const docKey = JSON.stringify(update.k) + '/' + isLocal;
+                            let entry = perDoc[docKey];
+                            if (!entry) {
+                                perDoc[docKey] = entry = {
+                                    i: update.i,
+                                    k: update.k,
+                                    isLocal,
+                                    u: [],
+                                };
+                                entry.u.push(update.u);
+                            }
+                            else {
+                                entry.u.push(update.u);
+                                entry.i = Math.max(update.i, entry.i);
+                            }
+                        }
+                        // Now, go through all these and:
+                        // * For local updates, compute a merged update per document.
+                        // * For foreign updates, compute a state vector to pass to server, so that server can
+                        //   avoid re-sending updates that we already have (they might have been sent of websocket
+                        //   and when that happens, we do not mark them in any way nor do we update receivedUntil -
+                        //   we only update receivedUntil after a "full sync" (syncWithServer()))
+                        for (const { k, isLocal, u, i } of Object.values(perDoc)) {
+                            const mergedUpdate = u.length === 1 ? u[0] : Y.mergeUpdatesV2(u);
+                            if (isLocal) {
+                                result.push({
+                                    type: 'u-c',
+                                    table: table.name,
+                                    prop: yProp.prop,
+                                    k,
+                                    u: mergedUpdate,
+                                    i,
+                                });
+                            }
+                            else {
+                                const stateVector = Y.encodeStateVectorFromUpdateV2(mergedUpdate);
+                                result.push({
+                                    type: 'sv',
+                                    table: table.name,
+                                    prop: yProp.prop,
+                                    k,
+                                    sv: stateVector,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            return {
+                yMessages: result,
+                lastUpdateIds
+            };
+        });
+    }
+
+    function getUpdatesTable(db, table, ydocProp) {
+        var _a, _b, _c;
+        const utbl = (_c = (_b = (_a = db.table(table)) === null || _a === void 0 ? void 0 : _a.schema.yProps) === null || _b === void 0 ? void 0 : _b.find(p => p.prop === ydocProp)) === null || _c === void 0 ? void 0 : _c.updatesTable;
+        if (!utbl)
+            throw new Error(`No updatesTable found for ${table}.${ydocProp}`);
+        return db.table(utbl);
+    }
+
+    function applyYServerMessages(yMessages, db) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = {};
+            for (const m of yMessages) {
+                switch (m.type) {
+                    case 'u-s': {
+                        const utbl = getUpdatesTable(db, m.table, m.prop);
+                        result[utbl.name] = yield utbl.add({
+                            k: m.k,
+                            u: m.u,
+                        });
+                        break;
+                    }
+                    case 'u-ack': {
+                        const utbl = getUpdatesTable(db, m.table, m.prop);
+                        yield db.transaction('rw', utbl, (tx) => __awaiter(this, void 0, void 0, function* () {
+                            let syncer = (yield tx
+                                .table(utbl.name)
+                                .get(DEXIE_CLOUD_SYNCER_ID));
+                            yield tx.table(utbl.name).put(Object.assign(Object.assign({}, (syncer || { i: DEXIE_CLOUD_SYNCER_ID })), { unsentFrom: Math.max((syncer === null || syncer === void 0 ? void 0 : syncer.unsentFrom) || 1, m.i + 1) }));
+                        }));
+                        break;
+                    }
+                    case 'u-reject': {
+                        // Acces control or constraint rejected the update.
+                        // We delete it. It's not going to be sent again.
+                        // What's missing is a way to notify consumers, such as Tiptap editor, that the update was rejected.
+                        // This is only an issue when the document is open. We could find the open document and
+                        // in a perfect world, we should send a reverse update to the open document to undo the change.
+                        // See my question in https://discuss.yjs.dev/t/generate-an-inverse-update/2765
+                        console.debug(`Y update rejected. Deleting it.`);
+                        const utbl = getUpdatesTable(db, m.table, m.prop);
+                        yield utbl.delete(m.i);
+                        break;
+                    }
+                    case 'in-sync': {
+                        const doc = Dexie.DexieYProvider.getDocCache(db.dx).find(m.table, m.k, m.prop);
+                        if (doc && !doc.isSynced) {
+                            doc.emit('sync', [true]);
+                        }
+                        break;
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    function updateYSyncStates(lastUpdateIdsBeforeSync, receivedUntilsAfterSync, db, serverRevision) {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            // We want to update unsentFrom for each yTable to the value specified in first argument
+            //  because we got those values before we synced with server and here we are back from server
+            //  that has successfully received all those messages - no matter if the last update was a client or server update,
+            //  we can safely store unsentFrom to a value of the last update + 1 here.
+            // We also want to update receivedUntil for each yTable to the value specified in the second argument,
+            //  because that contains the highest resulted id of each update from server after storing it.
+            // We could do these two tasks separately, but that would require two update calls on the same YSyncState, so
+            // to optimize the dexie calls, we merge these two maps into a single one so we can do a single update request
+            // per yTable.
+            const mergedSpec = {};
+            for (const [yTable, lastUpdateId] of Object.entries(lastUpdateIdsBeforeSync)) {
+                (_a = mergedSpec[yTable]) !== null && _a !== void 0 ? _a : (mergedSpec[yTable] = {});
+                mergedSpec[yTable].unsentFrom = lastUpdateId + 1;
+            }
+            for (const [yTable, lastUpdateId] of Object.entries(receivedUntilsAfterSync)) {
+                (_b = mergedSpec[yTable]) !== null && _b !== void 0 ? _b : (mergedSpec[yTable] = {});
+                mergedSpec[yTable].receivedUntil = lastUpdateId;
+            }
+            // Now go through all yTables and update their YSyncStates:
+            const allYTables = Object.values(db.dx._dbSchema)
+                .filter((tblSchema) => tblSchema.yProps)
+                .map((tblSchema) => tblSchema.yProps.map((yProp) => yProp.updatesTable))
+                .flat();
+            for (const yTable of allYTables) {
+                const mergedEntry = mergedSpec[yTable];
+                const unsentFrom = (_c = mergedEntry === null || mergedEntry === void 0 ? void 0 : mergedEntry.unsentFrom) !== null && _c !== void 0 ? _c : 1;
+                const receivedUntil = (_e = (_d = mergedEntry === null || mergedEntry === void 0 ? void 0 : mergedEntry.receivedUntil) !== null && _d !== void 0 ? _d : 
+                // from local because we are in the same parent transaction (in sync.ts) that
+                // applied all updates from the server
+                (yield db
+                    .table(yTable)
+                    .where('i')
+                    .between(1, Infinity) // Because i might be string DEXIE_CLOUD_SYNCER_ID if not a number.
+                    .reverse()
+                    .limit(1)
+                    .primaryKeys())[0]) !== null && _e !== void 0 ? _e : 0;
+                // We're already in a transaction, but for the sake of
+                // code readability and correctness, let's launch an atomic sub transaction:
+                yield db.transaction('rw', yTable, () => __awaiter(this, void 0, void 0, function* () {
+                    const state = yield db
+                        .table(yTable)
+                        .get(DEXIE_CLOUD_SYNCER_ID);
+                    if (!state) {
+                        yield db.table(yTable).add({
+                            i: DEXIE_CLOUD_SYNCER_ID,
+                            unsentFrom,
+                            receivedUntil,
+                            serverRev: serverRevision,
+                        });
+                    }
+                    else {
+                        state.unsentFrom = Math.max(unsentFrom, state.unsentFrom || 1);
+                        state.receivedUntil = Math.max(receivedUntil, state.receivedUntil || 0);
+                        state.serverRev = serverRevision;
+                        yield db.table(yTable).put(state);
+                    }
+                }));
+            }
+        });
+    }
+
+    const BINSTREAM_TYPE_REALMID = 1;
+    const BINSTREAM_TYPE_TABLE_AND_PROP = 2;
+    const BINSTREAM_TYPE_DOCUMENT = 3;
+    function downloadYDocsFromServer(db, databaseUrl, { yDownloadedRealms, realms }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yDownloadedRealms &&
+                realms &&
+                realms.every((realmId) => yDownloadedRealms[realmId] === '*')) {
+                return; // Already done!
+            }
+            console.debug('Downloading Y.Docs from added realms');
+            const user = yield loadAccessToken(db);
+            const headers = {
+                'Content-Type': 'application/json',
+                Accept: 'application/octet-stream',
+            };
+            if (user) {
+                headers.Authorization = `Bearer ${user.accessToken}`;
+            }
+            const res = yield fetch(`${databaseUrl}/y/download`, {
+                body: TSON.stringify({ downloadedRealms: yDownloadedRealms || {} }),
+                method: 'POST',
+                headers,
+                credentials: 'include',
+            });
+            if (!res.ok) {
+                throw new Error(`Failed to download Yjs documents from server. Status: ${res.status}`);
+            }
+            yield asyncIterablePipeline(getFetchResponseBodyGenerator(res), consumeChunkedBinaryStream, consumeDownloadChunks);
+            function consumeDownloadChunks(chunks) {
+                return __asyncGenerator(this, arguments, function* consumeDownloadChunks_1() {
+                    var _a, e_1, _b, _c;
+                    let currentRealmId = null;
+                    let currentTable = null;
+                    let currentProp = null;
+                    let docsToInsert = [];
+                    function storeCollectedDocs(completedRealm) {
+                        return __awaiter(this, void 0, void 0, function* () {
+                            const lastDoc = docsToInsert[docsToInsert.length - 1];
+                            if (docsToInsert.length > 0) {
+                                if (!currentRealmId || !currentTable || !currentProp) {
+                                    throw new Error(`Protocol error from ${databaseUrl}/y/download`);
+                                }
+                                const yTable = getUpdatesTable(db, currentTable, currentProp);
+                                yield yTable.bulkAdd(docsToInsert);
+                                docsToInsert = [];
+                            }
+                            if (currentRealmId &&
+                                ((currentTable && currentProp && lastDoc) || completedRealm)) {
+                                yield db.$syncState.update('syncState', (syncState) => {
+                                    const yDownloadedRealms = syncState.yDownloadedRealms || {};
+                                    yDownloadedRealms[currentRealmId] = completedRealm
+                                        ? '*'
+                                        : {
+                                            tbl: currentTable,
+                                            prop: currentProp,
+                                            key: lastDoc.k,
+                                        };
+                                    syncState.yDownloadedRealms = yDownloadedRealms;
+                                });
+                            }
+                        });
+                    }
+                    try {
+                        try {
+                            for (var _d = true, chunks_1 = __asyncValues(chunks), chunks_1_1; chunks_1_1 = yield __await(chunks_1.next()), _a = chunks_1_1.done, !_a; _d = true) {
+                                _c = chunks_1_1.value;
+                                _d = false;
+                                const chunk = _c;
+                                const decoder = new Decoder(chunk);
+                                while (hasContent(decoder)) {
+                                    switch (readUint8(decoder)) {
+                                        case BINSTREAM_TYPE_REALMID:
+                                            yield __await(storeCollectedDocs(true));
+                                            currentRealmId = readVarString(decoder);
+                                            break;
+                                        case BINSTREAM_TYPE_TABLE_AND_PROP:
+                                            yield __await(storeCollectedDocs(false)); // still on same realm
+                                            currentTable = readVarString(decoder);
+                                            currentProp = readVarString(decoder);
+                                            break;
+                                        case BINSTREAM_TYPE_DOCUMENT: {
+                                            const k = readAny(decoder);
+                                            const u = readVarUint8Array(decoder);
+                                            docsToInsert.push({
+                                                k,
+                                                u,
+                                            });
+                                            break;
+                                        }
+                                    }
+                                }
+                                yield __await(storeCollectedDocs(false)); // Chunk full - migth still be on same realm
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (!_d && !_a && (_b = chunks_1.return)) yield __await(_b.call(chunks_1));
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        yield __await(storeCollectedDocs(true)); // Everything downloaded - finalize last downloaded realm to "*"
+                    }
+                    catch (error) {
+                        if (!(error instanceof Dexie.DexieError)) {
+                            // Network error might have happened.
+                            // Store what we've collected so far:
+                            yield __await(storeCollectedDocs(false));
+                        }
+                        throw error;
+                    }
+                });
+            }
+        });
+    }
+
     const CURRENT_SYNC_WORKER = 'currentSyncWorker';
     function sync(db, options, schema, syncOptions) {
         return _sync
@@ -3650,10 +5071,11 @@
             //
             // List changes to sync
             //
-            const [clientChangeSet, syncState, baseRevs] = yield db.transaction('r', db.tables, () => __awaiter(this, void 0, void 0, function* () {
+            const [clientChangeSet, syncState, baseRevs, { yMessages, lastUpdateIds }] = yield db.transaction('r', db.tables, () => __awaiter(this, void 0, void 0, function* () {
                 const syncState = yield db.getPersistedSyncState();
                 const baseRevs = yield db.$baseRevs.toArray();
                 let clientChanges = yield listClientChanges(mutationTables);
+                const yResults = yield listYClientMessagesAndStateVector(db, tablesToSync);
                 throwIfCancelled(cancelToken);
                 if (doSyncify) {
                     const alreadySyncedRealms = [
@@ -3663,11 +5085,11 @@
                     const syncificationInserts = yield listSyncifiedChanges(tablesToSyncify, currentUser, schema, alreadySyncedRealms);
                     throwIfCancelled(cancelToken);
                     clientChanges = clientChanges.concat(syncificationInserts);
-                    return [clientChanges, syncState, baseRevs];
+                    return [clientChanges, syncState, baseRevs, yResults];
                 }
-                return [clientChanges, syncState, baseRevs];
+                return [clientChanges, syncState, baseRevs, yResults];
             }));
-            const pushSyncIsNeeded = clientChangeSet.some((set) => set.muts.some((mut) => mut.keys.length > 0));
+            const pushSyncIsNeeded = clientChangeSet.some((set) => set.muts.some((mut) => mut.keys.length > 0)) || yMessages.some(m => m.type === 'u-c');
             if (justCheckIfNeeded) {
                 console.debug('Sync is needed:', pushSyncIsNeeded);
                 return pushSyncIsNeeded;
@@ -3682,12 +5104,12 @@
             // Push changes to server
             //
             throwIfCancelled(cancelToken);
-            const res = yield syncWithServer(clientChangeSet, syncState, baseRevs, db, databaseUrl, schema, clientIdentity, currentUser);
+            const res = yield syncWithServer(clientChangeSet, yMessages, syncState, baseRevs, db, databaseUrl, schema, clientIdentity, currentUser);
             console.debug('Sync response', res);
             //
             // Apply changes locally and clear old change entries:
             //
-            const done = yield db.transaction('rw', db.tables, (tx) => __awaiter(this, void 0, void 0, function* () {
+            const { done, newSyncState } = yield db.transaction('rw', db.tables, (tx) => __awaiter(this, void 0, void 0, function* () {
                 // @ts-ignore
                 tx.idbtrans.disableChangeTracking = true;
                 // @ts-ignore
@@ -3779,17 +5201,35 @@
                 // apply server changes
                 //
                 yield applyServerChanges(filteredChanges, db);
+                if (res.yMessages) {
+                    //
+                    // apply yMessages
+                    //
+                    const receivedUntils = yield applyYServerMessages(res.yMessages, db);
+                    //
+                    // update Y SyncStates
+                    //
+                    yield updateYSyncStates(lastUpdateIds, receivedUntils, db, res.serverRevision);
+                }
                 //
-                // Update syncState
+                // Update regular syncState
                 //
                 db.$syncState.put(newSyncState, 'syncState');
-                return addedClientChanges.length === 0;
+                return {
+                    done: addedClientChanges.length === 0,
+                    newSyncState
+                };
             }));
             if (!done) {
                 console.debug('MORE SYNC NEEDED. Go for it again!');
                 yield checkSyncRateLimitDelay(db);
                 return yield _sync(db, options, schema, { isInitialSync, cancelToken });
             }
+            const usingYProps = Object.values(schema).some(tbl => { var _a; return (_a = tbl.yProps) === null || _a === void 0 ? void 0 : _a.length; });
+            const serverSupportsYprops = !!res.yMessages;
+            if (usingYProps && serverSupportsYprops) {
+                yield downloadYDocsFromServer(db, databaseUrl, newSyncState);
+            }
             console.debug('SYNC DONE', { isInitialSync });
             db.syncCompleteEvent.next();
             return false; // Not needed anymore
@@ -3842,6 +5282,18 @@
                     }
                 }
             }
+            if (rejectedRealms.size > 0) {
+                // Remove rejected/deleted realms from yDownloadedRealms because of the following use case:
+                // 1. User becomes added to the realm
+                // 2. User syncs and all documents of the realm is downloaded (downloadYDocsFromServer.ts)
+                // 3. User leaves the realm and all docs are deleted locally (built-in-trigger of deleting their rows in this file)
+                // 4. User is yet again added to the realm. At this point, we must make sure the docs are not considered already downloaded.
+                const updateSpec = {};
+                for (const realmId of rejectedRealms) {
+                    updateSpec[`yDownloadedRealms.${realmId}`] = undefined; // Setting to undefined will delete the property
+                }
+                yield db.$syncState.update('syncState', updateSpec);
+            }
         });
     }
     function filterServerChangesThroughAddedClientChanges(serverChanges, addedClientChanges) {
@@ -4151,6 +5603,7 @@
             };
             Object.assign(db, helperMethods);
             db.messageConsumer = MessagesFromServerConsumer(db);
+            db.messageProducer = new rxjs.Subject();
             wm$1.set(dx.cloud, db);
         }
         return db;
@@ -4486,24 +5939,6 @@
     const DISABLE_SERVICEWORKER_STRATEGY = (isSafari && safariVersion <= 605) || // Disable for Safari for now.
         isFirefox; // Disable for Firefox for now. Seems to have a bug in reading CryptoKeys from IDB from service workers
 
-    /* Helper function to subscribe to database close no matter if it was unexpectedly closed or manually using db.close()
-     */
-    function dbOnClosed(db, handler) {
-        db.on.close.subscribe(handler);
-        // @ts-ignore
-        const origClose = db._close;
-        // @ts-ignore
-        db._close = function () {
-            origClose.call(this);
-            handler();
-        };
-        return () => {
-            db.on.close.unsubscribe(handler);
-            // @ts-ignore
-            db._close = origClose;
-        };
-    }
-
     const IS_SERVICE_WORKER = typeof self !== "undefined" && "clients" in self && !self.document;
 
     function throwVersionIncrementNeeded() {
@@ -4969,13 +6404,18 @@
                                     values = values.filter((_, idx) => !failures[idx]);
                                 }
                                 const ts = Date.now();
+                                // Canonicalize req.criteria.index to null if it's on the primary key.
+                                const criteria = 'criteria' in req && req.criteria
+                                    ? Object.assign(Object.assign({}, req.criteria), { index: req.criteria.index === schema.primaryKey.keyPath // Use null to inform server that criteria is on primary key
+                                            ? null // This will disable the server from trying to log consistent operations where it shouldnt.
+                                            : req.criteria.index }) : undefined;
                                 const mut = req.type === 'delete'
                                     ? {
                                         type: 'delete',
                                         ts,
                                         opNo,
                                         keys,
-                                        criteria: req.criteria,
+                                        criteria,
                                         txid,
                                         userId,
                                     }
@@ -4989,14 +6429,14 @@
                                             userId,
                                             values,
                                         }
-                                        : req.criteria && req.changeSpec
+                                        : criteria && req.changeSpec
                                             ? {
                                                 // Common changeSpec for all keys
                                                 type: 'modify',
                                                 ts,
                                                 opNo,
                                                 keys,
-                                                criteria: req.criteria,
+                                                criteria,
                                                 changeSpec: req.changeSpec,
                                                 txid,
                                                 userId,
@@ -5024,7 +6464,7 @@
                                 if ('isAdditionalChunk' in req && req.isAdditionalChunk) {
                                     mut.isAdditionalChunk = true;
                                 }
-                                return keys.length > 0 || ('criteria' in req && req.criteria)
+                                return keys.length > 0 || criteria
                                     ? mutsTable
                                         .mutate({ type: 'add', trans, values: [mut] }) // Log entry
                                         .then(() => res) // Return original response
@@ -5038,6 +6478,7 @@
 
     function overrideParseStoresSpec(origFunc, dexie) {
         return function (stores, dbSchema) {
+            var _a;
             const storesClone = Object.assign(Object.assign({}, DEXIE_CLOUD_SCHEMA), stores);
             // Merge indexes of DEXIE_CLOUD_SCHEMA with stores
             Object.keys(DEXIE_CLOUD_SCHEMA).forEach((tableName) => {
@@ -5098,6 +6539,14 @@
                 }
             });
             const rv = origFunc.call(this, storesClone, dbSchema);
+            for (const [tableName, spec] of Object.entries(dbSchema)) {
+                if ((_a = spec.yProps) === null || _a === void 0 ? void 0 : _a.length) {
+                    const cloudTableSchema = cloudSchema[tableName];
+                    if (cloudTableSchema) {
+                        cloudTableSchema.yProps = spec.yProps.map((yProp) => yProp.prop);
+                    }
+                }
+            }
             return rv;
         };
     }
@@ -5183,31 +6632,82 @@
         }
     }
 
+    function createYClientUpdateObservable(db) {
+        const yTableRecords = flatten(db.tables
+            .filter((table) => { var _a, _b; return ((_b = (_a = db.cloud.schema) === null || _a === void 0 ? void 0 : _a[table.name]) === null || _b === void 0 ? void 0 : _b.markedForSync) && table.schema.yProps; })
+            .map((table) => table.schema.yProps.map((p) => ({
+            table: table.name,
+            ydocProp: p.prop,
+            updatesTable: p.updatesTable,
+        }))));
+        return rxjs.merge(...yTableRecords.map(({ table, ydocProp, updatesTable }) => {
+            let currentUnsentFrom = 1;
+            return Dexie.liveQuery(() => __awaiter(this, void 0, void 0, function* () {
+                const yTbl = db.table(updatesTable);
+                const unsentFrom = yield yTbl
+                    .where({ i: DEXIE_CLOUD_SYNCER_ID })
+                    .first()
+                    .then((syncer) => (syncer === null || syncer === void 0 ? void 0 : syncer.unsentFrom) || 1);
+                currentUnsentFrom = Math.max(currentUnsentFrom, unsentFrom);
+                const addedUpdates = yield listUpdatesSince(yTbl, currentUnsentFrom);
+                // Update currentUnsentFrom to only listen for updates that will be newer than the ones we emitted.
+                currentUnsentFrom = Math.max(currentUnsentFrom, ...addedUpdates.map((update) => update.i + 1));
+                return addedUpdates
+                    .filter((update) => update.f && update.f & 1) // Only include local updates
+                    .map((update) => {
+                    return {
+                        type: 'u-c',
+                        table,
+                        prop: ydocProp,
+                        k: update.k,
+                        u: update.u,
+                        i: update.i,
+                    };
+                });
+            }));
+        })).pipe(
+        // Flatten the array of messages.
+        // If messageProducer emits empty array, nothing is emitted
+        // but if messageProducer emits array of messages, they are
+        // emitted one by one.
+        rxjs.mergeMap((messages) => messages));
+    }
+
+    function getAwarenessLibrary(db) {
+        var _a, _b;
+        if (!((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.awarenessProtocol)) {
+            throw new Dexie.MissingAPIError('awarenessProtocol was not provided to db.cloud.configure(). Please import * as awarenessProtocol from "y-protocols/awareness".');
+        }
+        return (_b = db.cloud.options) === null || _b === void 0 ? void 0 : _b.awarenessProtocol;
+    }
+    const awarenessWeakMap = new WeakMap();
+    const getDocAwareness = (doc) => awarenessWeakMap.get(doc);
+
     const SERVER_PING_TIMEOUT = 20000;
     const CLIENT_PING_INTERVAL = 30000;
     const FAIL_RETRY_WAIT_TIME = 60000;
     class WSObservable extends rxjs.Observable {
-        constructor(databaseUrl, rev, realmSetHash, clientIdentity, messageProducer, webSocketStatus, token, tokenExpiration) {
-            super((subscriber) => new WSConnection(databaseUrl, rev, realmSetHash, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus));
+        constructor(db, rev, realmSetHash, clientIdentity, messageProducer, webSocketStatus, user) {
+            super((subscriber) => new WSConnection(db, rev, realmSetHash, clientIdentity, user, subscriber, messageProducer, webSocketStatus));
         }
     }
     let counter = 0;
     class WSConnection extends rxjs.Subscription {
-        constructor(databaseUrl, rev, realmSetHash, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus) {
+        constructor(db, rev, realmSetHash, clientIdentity, user, subscriber, messageProducer, webSocketStatus) {
             super(() => this.teardown());
             this.id = ++counter;
+            this.subscriptions = new Set();
             this.reconnecting = false;
-            console.debug('New WebSocket Connection', this.id, token ? 'authorized' : 'unauthorized');
-            this.databaseUrl = databaseUrl;
+            console.debug('New WebSocket Connection', this.id, user.accessToken ? 'authorized' : 'unauthorized');
+            this.db = db;
+            this.databaseUrl = db.cloud.options.databaseUrl;
             this.rev = rev;
             this.realmSetHash = realmSetHash;
             this.clientIdentity = clientIdentity;
-            this.token = token;
-            this.tokenExpiration = tokenExpiration;
+            this.user = user;
             this.subscriber = subscriber;
             this.lastUserActivity = new Date();
             this.messageProducer = messageProducer;
-            this.messageProducerSubscription = null;
             this.webSocketStatus = webSocketStatus;
             this.connect();
         }
@@ -5228,10 +6728,10 @@
                 catch (_a) { }
             }
             this.ws = null;
-            if (this.messageProducerSubscription) {
-                this.messageProducerSubscription.unsubscribe();
-                this.messageProducerSubscription = null;
+            for (const sub of this.subscriptions) {
+                sub.unsubscribe();
             }
+            this.subscriptions.clear();
         }
         reconnect() {
             if (this.reconnecting)
@@ -5264,7 +6764,8 @@
                     //console.debug('SyncStatus: DUBB: Ooops it was closed!');
                     return;
                 }
-                if (this.tokenExpiration && this.tokenExpiration < new Date()) {
+                const tokenExpiration = this.user.accessTokenExpiration;
+                if (tokenExpiration && tokenExpiration < new Date()) {
                     this.subscriber.error(new TokenExpiredError()); // Will be handled in connectWebSocket.ts.
                     return;
                 }
@@ -5319,13 +6820,13 @@
                 searchParams.set('rev', this.rev);
                 searchParams.set('realmsHash', this.realmSetHash);
                 searchParams.set('clientId', this.clientIdentity);
-                if (this.token) {
-                    searchParams.set('token', this.token);
+                if (this.user.accessToken) {
+                    searchParams.set('token', this.user.accessToken);
                 }
                 // Connect the WebSocket to given url:
                 console.debug('dexie-cloud WebSocket create');
                 const ws = (this.ws = new WebSocket(`${wsUrl}/changes?${searchParams}`));
-                //ws.binaryType = "arraybuffer"; // For future when subscribing to actual changes.
+                ws.binaryType = "arraybuffer";
                 ws.onclose = (event) => {
                     if (!this.pinger)
                         return;
@@ -5338,14 +6839,30 @@
                     console.debug('dexie-cloud WebSocket onmessage', event.data);
                     this.lastServerActivity = new Date();
                     try {
-                        const msg = TSON.parse(event.data);
+                        const msg = typeof event.data === 'string'
+                            ? TSON.parse(event.data)
+                            : decodeYMessage(new Uint8Array(event.data));
                         if (msg.type === 'error') {
                             throw new Error(`Error message from dexie-cloud: ${msg.error}`);
                         }
-                        if (msg.type === 'rev') {
+                        else if (msg.type === 'rev') {
                             this.rev = msg.rev; // No meaning but seems reasonable.
                         }
-                        if (msg.type !== 'pong') {
+                        else if (msg.type === 'aware') {
+                            const docCache = Dexie.DexieYProvider.getDocCache(this.db.dx);
+                            const doc = docCache.find(msg.table, msg.k, msg.prop);
+                            if (doc) {
+                                const awareness = getDocAwareness(doc);
+                                if (awareness) {
+                                    const awap = getAwarenessLibrary(this.db);
+                                    awap.applyAwarenessUpdate(awareness, msg.u, 'server');
+                                }
+                            }
+                        }
+                        else if (msg.type === 'u-ack' || msg.type === 'u-reject' || msg.type === 'u-s' || msg.type === 'in-sync') {
+                            applyYServerMessages([msg], this.db);
+                        }
+                        else if (msg.type !== 'pong') {
                             this.subscriber.next(msg);
                         }
                     }
@@ -5373,16 +6890,26 @@
                             }
                         };
                     });
-                    this.messageProducerSubscription = this.messageProducer.subscribe((msg) => {
-                        var _a;
+                    this.subscriptions.add(this.messageProducer.subscribe((msg) => {
+                        var _a, _b;
                         if (!this.closed) {
                             if (msg.type === 'ready' &&
                                 this.webSocketStatus.value !== 'connected') {
                                 this.webSocketStatus.next('connected');
                             }
-                            (_a = this.ws) === null || _a === void 0 ? void 0 : _a.send(TSON.stringify(msg));
+                            if (msg.type === 'ready') {
+                                (_a = this.ws) === null || _a === void 0 ? void 0 : _a.send(TSON.stringify(msg));
+                            }
+                            else {
+                                // If it's not a "ready" message, it's an YMessage.
+                                // YMessages can be sent binary encoded.
+                                (_b = this.ws) === null || _b === void 0 ? void 0 : _b.send(encodeYMessage(msg));
+                            }
                         }
-                    });
+                    }));
+                    if (this.user.isLoggedIn && !isEagerSyncDisabled(this.db)) {
+                        this.subscriptions.add(createYClientUpdateObservable(this.db).subscribe(this.db.messageProducer));
+                    }
                 }
                 catch (error) {
                     this.pauseUntil = new Date(Date.now() + FAIL_RETRY_WAIT_TIME);
@@ -5424,7 +6951,7 @@
         if (!((_a = db.cloud.options) === null || _a === void 0 ? void 0 : _a.databaseUrl)) {
             throw new Error(`No database URL to connect WebSocket to`);
         }
-        const messageProducer = db.messageConsumer.readyToServe.pipe(filter((isReady) => isReady), // When consumer is ready for new messages, produce such a message to inform server about it
+        const readyForChangesMessage = db.messageConsumer.readyToServe.pipe(filter((isReady) => isReady), // When consumer is ready for new messages, produce such a message to inform server about it
         switchMap(() => db.getPersistedSyncState()), // We need the info on which server revision we are at:
         filter((syncState) => syncState && syncState.serverRevision), // We wont send anything to server before inital sync has taken place
         switchMap((syncState) => __awaiter(this, void 0, void 0, function* () {
@@ -5435,6 +6962,7 @@
                 realmSetHash: yield computeRealmSetHash(syncState)
             });
         })));
+        const messageProducer = rxjs.merge(readyForChangesMessage, db.messageProducer);
         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
@@ -5461,7 +6989,7 @@
                 // If no new entries, server won't bother the client. If new entries, server sends only those
                 // and the baseRev of the last from same client-ID.
                 if (userLogin) {
-                    return new WSObservable(db.cloud.options.databaseUrl, db.cloud.persistedSyncState.value.serverRevision, realmSetHash, db.cloud.persistedSyncState.value.clientIdentity, messageProducer, db.cloud.webSocketStatus, userLogin.accessToken, userLogin.accessTokenExpiration);
+                    return new WSObservable(db, db.cloud.persistedSyncState.value.serverRevision, realmSetHash, db.cloud.persistedSyncState.value.clientIdentity, messageProducer, db.cloud.webSocketStatus, userLogin);
                 }
                 else {
                     return rxjs.from([]);
@@ -6267,6 +7795,130 @@
         })), []);
     });
 
+    function createYHandler(db) {
+        const awap = getAwarenessLibrary(db);
+        return (provider) => {
+            var _a;
+            const doc = provider.doc;
+            const { parentTable, parentId, parentProp, updatesTable } = doc.meta;
+            if (!((_a = db.cloud.schema) === null || _a === void 0 ? void 0 : _a[parentTable].markedForSync)) {
+                return; // The table that holds the doc is not marked for sync - leave it to dexie. No syncing, no awareness.
+            }
+            let awareness = new awap.Awareness(doc);
+            awarenessWeakMap.set(doc, awareness);
+            provider.awareness = awareness;
+            awareness.on('update', ({ added, updated, removed }, origin) => {
+                // Send the update
+                const changedClients = added.concat(updated).concat(removed);
+                const user = db.cloud.currentUser.value;
+                if (origin !== 'server' && user.isLoggedIn && !isEagerSyncDisabled(db)) {
+                    const update = awap.encodeAwarenessUpdate(awareness, changedClients);
+                    db.messageProducer.next({
+                        type: 'aware',
+                        table: parentTable,
+                        prop: parentProp,
+                        k: doc.meta.parentId,
+                        u: update,
+                    });
+                    if (provider.destroyed) {
+                        // We're called from awareness.on('destroy') that did
+                        // removeAwarenessStates. 
+                        // It's time to also send the doc-close message that dexie-cloud understands
+                        // and uses to stop subscribing for updates and awareness updates and brings
+                        // down the cached information in memory on the WS connection for this.
+                        db.messageProducer.next({
+                            type: 'doc-close',
+                            table: parentTable,
+                            prop: parentProp,
+                            k: doc.meta.parentId
+                        });
+                    }
+                }
+            });
+            awareness.on('destroy', () => {
+                // Signal to server that this provider is destroyed (the update event will be triggered, which
+                // in turn will trigger db.messageProducer that will send the message to the server if WS is connected)
+                awap.removeAwarenessStates(awareness, [doc.clientID], 'provider destroyed');
+            });
+            // Now wait til document is loaded and then open the document on the server
+            provider.on('load', () => __awaiter(this, void 0, void 0, function* () {
+                if (provider.destroyed)
+                    return;
+                let connected = false;
+                let currentFlowId = 1;
+                const subscription = db.cloud.webSocketStatus.subscribe((wsStatus) => {
+                    if (provider.destroyed)
+                        return;
+                    // Keep "connected" state in a variable so we can check it after async operations
+                    connected = wsStatus === 'connected';
+                    // We are or got connected. Open the document on the server.
+                    const user = db.cloud.currentUser.value;
+                    if (wsStatus === "connected" && user.isLoggedIn && !isEagerSyncDisabled(db)) {
+                        ++currentFlowId;
+                        openDocumentOnServer().catch(error => {
+                            console.warn(`Error catched in createYHandler.ts: ${error}`);
+                        });
+                    }
+                });
+                // Wait until WebSocket is connected
+                provider.addCleanupHandler(subscription);
+                /** Sends an 'doc-open' message to server whenever websocket becomes
+                 * connected, or if it is already connected.
+                 * The flow is aborted in case websocket is disconnected while querying
+                 * information required to compute the state vector. Flow is also
+                 * aborted in case document or provider has been destroyed during
+                 * the async parts of the task.
+                 *
+                 * The state vector is only computed from the updates that have occured
+                 * after the last full sync - which could very often be zero - in which
+                 * case no state vector is sent (then the server already knows us by
+                 * revision)
+                 *
+                 * When server gets the doc-open message, it will authorized us for
+                 * whether we are allowed to read / write to this document, and then
+                 * keep the cached information in memory on the WS connection for this
+                 * particular document, as well as subscribe to updates and awareness updates
+                 * from other clients on the document.
+                 */
+                function openDocumentOnServer(wsStatus) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const myFlow = currentFlowId; // So we can abort when a new flow is started
+                        const yTbl = db.table(updatesTable);
+                        const syncState = yield yTbl.get(DEXIE_CLOUD_SYNCER_ID);
+                        // After every await, check if we still should be working on this task.
+                        if (provider.destroyed || currentFlowId !== myFlow || !connected)
+                            return;
+                        const receivedUntil = (syncState === null || syncState === void 0 ? void 0 : syncState.receivedUntil) || 0;
+                        const docOpenMsg = {
+                            type: 'doc-open',
+                            table: parentTable,
+                            prop: parentProp,
+                            k: parentId,
+                            serverRev: syncState === null || syncState === void 0 ? void 0 : syncState.serverRev,
+                        };
+                        const serverUpdatesSinceLastSync = yield yTbl
+                            .where('i')
+                            .between(receivedUntil, Infinity, false)
+                            .filter((update) => Dexie.cmp(update.k, parentId) === 0 && // Only updates for this document
+                            ((update.f || 0) & 1) === 0 // Don't include local changes
+                        )
+                            .toArray();
+                        // After every await, check if we still should be working on this task.
+                        if (provider.destroyed || currentFlowId !== myFlow || !connected)
+                            return;
+                        if (serverUpdatesSinceLastSync.length > 0) {
+                            const Y = $Y(db); // Get the Yjs library from Dexie constructor options
+                            const mergedUpdate = Y.mergeUpdatesV2(serverUpdatesSinceLastSync.map((update) => update.u));
+                            const stateVector = Y.encodeStateVectorFromUpdateV2(mergedUpdate);
+                            docOpenMsg.sv = stateVector;
+                        }
+                        db.messageProducer.next(docOpenMsg);
+                    });
+                }
+            }));
+        };
+    }
+
     const DEFAULT_OPTIONS = {
         nameSuffix: true,
     };
@@ -6296,8 +7948,9 @@
             if (closed)
                 throw new Dexie.DatabaseClosedError();
         }
-        dbOnClosed(dexie, () => {
+        dexie.once('close', () => {
             subscriptions.forEach((subscription) => subscription.unsubscribe());
+            subscriptions.splice(0, subscriptions.length);
             closed = true;
             localSyncWorker && localSyncWorker.stop();
             localSyncWorker = null;
@@ -6306,7 +7959,7 @@
         const syncComplete = new rxjs.Subject();
         dexie.cloud = {
             // @ts-ignore
-            version: "4.0.8",
+            version: "4.1.0-alpha.3",
             options: Object.assign({}, DEFAULT_OPTIONS),
             schema: null,
             get currentUserId() {
@@ -6452,6 +8105,7 @@
                             throw new Error(`Internal error`); // options cannot be null if configuredProgramatically is set.
                         const newPersistedOptions = Object.assign({}, options);
                         delete newPersistedOptions.fetchTokens;
+                        delete newPersistedOptions.awarenessProtocol;
                         yield db.$syncState.put(newPersistedOptions, 'options');
                     }
                     if (((_h = db.cloud.options) === null || _h === void 0 ? void 0 : _h.tryUseServiceWorker) &&
@@ -6529,6 +8183,12 @@
                         currentUserEmitter.pipe(skip(1), take(1)),
                         db.cloud.persistedSyncState.pipe(skip(1), take(1)),
                     ]));
+                    const yHandler = createYHandler(db);
+                    db.dx.on('y', yHandler);
+                    db.dx.once('close', () => {
+                        var _a;
+                        (_a = db.dx.on.y) === null || _a === void 0 ? void 0 : _a.unsubscribe(yHandler);
+                    });
                 }
                 // HERE: If requireAuth, do athentication now.
                 let changedUser = false;
@@ -6601,7 +8261,7 @@
         }
     }
     // @ts-ignore
-    dexieCloud.version = "4.0.8";
+    dexieCloud.version = "4.1.0-alpha.3";
     Dexie.Cloud = dexieCloud;
 
     // In case the SW lives for a while, let it reuse already opened connections: