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

package/dist/modern/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
  *
@@ -16,8 +16,8 @@
  * 
  */
 
-import Dexie, { PropModification, cmp, liveQuery } from 'dexie';
-import { Observable as Observable$1, BehaviorSubject, firstValueFrom, Subject, from as from$1, filter as filter$1, fromEvent, of, merge, Subscription as Subscription$1, throwError, combineLatest, map as map$1, share, timer as timer$1 } from 'rxjs';
+import Dexie, { PropModification, cmp, DexieYProvider, liveQuery } from 'dexie';
+import { Observable as Observable$1, BehaviorSubject, firstValueFrom, Subject, from as from$1, filter as filter$1, fromEvent, of, merge, mergeMap as mergeMap$1, Subscription as Subscription$1, throwError, combineLatest, map as map$1, share, timer as timer$1 } from 'rxjs';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -2242,6 +2242,1075 @@ function getDbNameFromDbUrl(dbUrl) {
         : 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)}`;
@@ -3308,7 +4377,7 @@ function updateSyncRateLimitDelays(db, res) {
 }
 
 //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
@@ -3346,6 +4415,7 @@ function syncWithServer(changes, syncState, baseRevs, db, databaseUrl, schema, c
                 : undefined,
             baseRevs,
             changes: encodeIdsForServer(db.dx.core.schema, currentUser, changes),
+            y,
         };
         console.debug('Sync request', syncRequest);
         db.syncStateChangedEvent.next({
@@ -3559,6 +4629,357 @@ function applyServerChanges(changes, db) {
     });
 }
 
+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 = 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
@@ -3647,10 +5068,11 @@ function _sync(db, options, schema, { isInitialSync, cancelToken, justCheckIfNee
         //
         // 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 = [
@@ -3660,11 +5082,11 @@ function _sync(db, options, schema, { isInitialSync, cancelToken, justCheckIfNee
                 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;
@@ -3679,12 +5101,12 @@ function _sync(db, options, schema, { isInitialSync, cancelToken, justCheckIfNee
         // 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
@@ -3776,17 +5198,35 @@ function _sync(db, options, schema, { isInitialSync, cancelToken, justCheckIfNee
             // 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
@@ -3839,6 +5279,18 @@ function deleteObjectsFromRemovedRealms(db, res, prevState) {
                 }
             }
         }
+        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) {
@@ -4148,6 +5600,7 @@ function DexieCloudDB(dx) {
         };
         Object.assign(db, helperMethods);
         db.messageConsumer = MessagesFromServerConsumer(db);
+        db.messageProducer = new Subject();
         wm$1.set(dx.cloud, db);
     }
     return db;
@@ -4483,24 +5936,6 @@ const safariVersion = isSafari
 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() {
@@ -4966,13 +6401,18 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                                 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,
                                 }
@@ -4986,14 +6426,14 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                                         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,
@@ -5021,7 +6461,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
                             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
@@ -5035,6 +6475,7 @@ function createMutationTrackingMiddleware({ currentUserObservable, db, }) {
 
 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) => {
@@ -5095,6 +6536,14 @@ function overrideParseStoresSpec(origFunc, dexie) {
             }
         });
         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;
     };
 }
@@ -5180,31 +6629,82 @@ class TokenExpiredError extends Error {
     }
 }
 
+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 merge(...yTableRecords.map(({ table, ydocProp, updatesTable }) => {
+        let currentUnsentFrom = 1;
+        return liveQuery(() => __awaiter(this, void 0, void 0, function* () {
+            const yTbl = db.table(updatesTable);
+            const unsentFrom = yield yTbl
+                .where({ i: DEXIE_CLOUD_SYNCER_ID })
+                .first()
+                .then((syncer) => (syncer === null || syncer === void 0 ? void 0 : syncer.unsentFrom) || 1);
+            currentUnsentFrom = Math.max(currentUnsentFrom, unsentFrom);
+            const addedUpdates = yield listUpdatesSince(yTbl, currentUnsentFrom);
+            // Update currentUnsentFrom to only listen for updates that will be newer than the ones we emitted.
+            currentUnsentFrom = Math.max(currentUnsentFrom, ...addedUpdates.map((update) => update.i + 1));
+            return addedUpdates
+                .filter((update) => update.f && update.f & 1) // Only include local updates
+                .map((update) => {
+                return {
+                    type: 'u-c',
+                    table,
+                    prop: ydocProp,
+                    k: update.k,
+                    u: update.u,
+                    i: update.i,
+                };
+            });
+        }));
+    })).pipe(
+    // Flatten the array of messages.
+    // If messageProducer emits empty array, nothing is emitted
+    // but if messageProducer emits array of messages, they are
+    // emitted one by one.
+    mergeMap$1((messages) => messages));
+}
+
+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 Observable$1 {
-    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 Subscription$1 {
-    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();
     }
@@ -5225,10 +6725,10 @@ class WSConnection extends Subscription$1 {
             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)
@@ -5261,7 +6761,8 @@ class WSConnection extends Subscription$1 {
                 //console.debug('SyncStatus: DUBB: Ooops it was closed!');
                 return;
             }
-            if (this.tokenExpiration && this.tokenExpiration < new Date()) {
+            const tokenExpiration = this.user.accessTokenExpiration;
+            if (tokenExpiration && tokenExpiration < new Date()) {
                 this.subscriber.error(new TokenExpiredError()); // Will be handled in connectWebSocket.ts.
                 return;
             }
@@ -5316,13 +6817,13 @@ class WSConnection extends Subscription$1 {
             searchParams.set('rev', this.rev);
             searchParams.set('realmsHash', this.realmSetHash);
             searchParams.set('clientId', this.clientIdentity);
-            if (this.token) {
-                searchParams.set('token', this.token);
+            if (this.user.accessToken) {
+                searchParams.set('token', this.user.accessToken);
             }
             // Connect the WebSocket to given url:
             console.debug('dexie-cloud WebSocket create');
             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;
@@ -5335,14 +6836,30 @@ class WSConnection extends Subscription$1 {
                 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 = 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);
                     }
                 }
@@ -5370,16 +6887,26 @@ class WSConnection extends Subscription$1 {
                         }
                     };
                 });
-                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);
@@ -5421,7 +6948,7 @@ function connectWebSocket(db) {
     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* () {
@@ -5432,6 +6959,7 @@ function connectWebSocket(db) {
             realmSetHash: yield computeRealmSetHash(syncState)
         });
     })));
+    const messageProducer = 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
@@ -5458,7 +6986,7 @@ function connectWebSocket(db) {
             // If no new entries, server won't bother the client. If new entries, server sends only those
             // and the baseRev of the last from same client-ID.
             if (userLogin) {
-                return new WSObservable(db.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 from$1([]);
@@ -6264,6 +7792,130 @@ const getInvitesObservable = associate((db) => {
     })), []);
 });
 
+function createYHandler(db) {
+    const awap = getAwarenessLibrary(db);
+    return (provider) => {
+        var _a;
+        const doc = provider.doc;
+        const { parentTable, parentId, parentProp, updatesTable } = doc.meta;
+        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) => 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,
 };
@@ -6293,8 +7945,9 @@ function dexieCloud(dexie) {
         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;
@@ -6303,7 +7956,7 @@ function dexieCloud(dexie) {
     const syncComplete = new Subject();
     dexie.cloud = {
         // @ts-ignore
-        version: "4.0.8",
+        version: "4.1.0-alpha.3",
         options: Object.assign({}, DEFAULT_OPTIONS),
         schema: null,
         get currentUserId() {
@@ -6449,6 +8102,7 @@ function dexieCloud(dexie) {
                         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) &&
@@ -6526,6 +8180,12 @@ function dexieCloud(dexie) {
                     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;
@@ -6598,7 +8258,7 @@ function dexieCloud(dexie) {
     }
 }
 // @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: