dexie 4.0.8 → 4.1.0-alpha.12

package/dist/dexie.js

@@ -4,7 +4,7 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 4.0.8, Wed Jul 10 2024
+ * Version 4.1.0-alpha.12, Wed Oct 16 2024
  *
  * https://dexie.org
  *
@@ -52,6 +52,33 @@
         };
         return __assign.apply(this, arguments);
     };
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    }
     function __spreadArray(to, from, pack) {
         if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
             if (ar || !(i in from)) {
@@ -1150,7 +1177,7 @@
         }
     }
 
-    var DEXIE_VERSION = '4.0.8';
+    var DEXIE_VERSION = '4.1.0-alpha.12';
     var maxString = String.fromCharCode(65535);
     var minKey = -Infinity;
     var INVALID_KEY_ARGUMENT = "Invalid key provided. Keys must be of type string, number, Date or Array<string | number | Date>.";
@@ -1268,6 +1295,98 @@
         return new Uint8Array(a);
     }
 
+    function getDocCache(db) {
+        var _a;
+        var _b;
+        return (_a = (_b = db._novip)['_docCache']) !== null && _a !== void 0 ? _a : (_b['_docCache'] = {
+            cache: {},
+            get size() {
+                return Object.keys(this.cache).length;
+            },
+            find: function (table, primaryKey, ydocProp) {
+                var cacheKey = getYDocCacheKey(table, primaryKey, ydocProp);
+                var docRef = this.cache[cacheKey];
+                return docRef ? docRef.deref() : undefined;
+            },
+            add: function (doc) {
+                var _a = doc.meta, parentTable = _a.parentTable, parentId = _a.parentId, parentProp = _a.parentProp;
+                if (!parentTable || !parentProp || parentId == null)
+                    throw new Error("Missing Dexie-related metadata in Y.Doc");
+                var cacheKey = getYDocCacheKey(parentTable, parentId, parentProp);
+                this.cache[cacheKey] = new WeakRef(doc);
+                docRegistry.register(doc, { cache: this.cache, key: cacheKey });
+            },
+            delete: function (doc) {
+                docRegistry.unregister(doc);
+                delete this.cache[getYDocCacheKey(doc.meta.parentTable, doc.meta.parentId, doc.meta.parentProp)];
+            },
+        });
+    }
+    var docRegistry = new FinalizationRegistry(function (_a) {
+        var cache = _a.cache, key = _a.key;
+        delete cache[key];
+    });
+    var destroyedDocs = new WeakSet();
+    function throwIfDestroyed(doc) {
+        if (destroyedDocs.has(doc))
+            throw new Error('Y.Doc has been destroyed');
+    }
+    function getYDocCacheKey(table, primaryKey, ydocProp) {
+        return "".concat(table, "[").concat(primaryKey, "].").concat(ydocProp);
+    }
+
+    function createYDocProperty(db, Y, table, prop, updatesTable) {
+        var pkKeyPath = table.schema.primKey.keyPath;
+        var docCache = getDocCache(db);
+        return {
+            set: function () {
+                throw new TypeError("Y.Doc properties are read-only");
+            },
+            get: function () {
+                var id = getByKeyPath(this, pkKeyPath);
+                var doc = docCache.find(table.name, id, prop);
+                if (doc)
+                    return doc;
+                doc = new Y.Doc({
+                    meta: {
+                        db: db,
+                        updatesTable: updatesTable,
+                        parentProp: prop,
+                        parentTable: table.name,
+                        parentId: id
+                    },
+                });
+                docCache.add(doc);
+                doc.on('destroy', function () {
+                    destroyedDocs.add(doc);
+                    docCache.delete(doc);
+                });
+                return doc;
+            },
+        };
+    }
+
+    function builtInDeletionTrigger(table, keys, res) {
+        var yProps = table.schema.yProps;
+        if (!yProps)
+            return res;
+        if (keys && res.numFailures > 0)
+            keys = keys.filter(function (_, i) { return !res.failures[i]; });
+        return Promise.all(yProps.map(function (_a) {
+            var updatesTable = _a.updatesTable;
+            return keys
+                ? table.db.table(updatesTable).where('k').anyOf(keys).delete()
+                : table.db.table(updatesTable).clear();
+        })).then(function () { return res; });
+    }
+
+    function getYLibrary(db) {
+        var Y = db._options.Y;
+        if (!Y)
+            throw new exceptions.MissingAPI('Y library not supplied to Dexie constructor');
+        return Y;
+    }
+
     var Table =  (function () {
         function Table() {
         }
@@ -1347,8 +1466,8 @@
             function equals(a, b) {
                 return idb.cmp(a, b) === 0;
             }
-            var _a = keyPaths.reduce(function (_a, keyPath) {
-                var prevIndex = _a[0], prevFilterFn = _a[1];
+            var _a = __read(keyPaths.reduce(function (_a, keyPath) {
+                var _b = __read(_a, 2), prevIndex = _b[0], prevFilterFn = _b[1];
                 var index = idxByName[keyPath];
                 var value = indexOrCrit[keyPath];
                 return [
@@ -1361,7 +1480,7 @@
                             } : function (x) { return equals(value, getByKeyPath(x, keyPath)); })
                         : prevFilterFn
                 ];
-            }, [null, null]), idx = _a[0], filterFunction = _a[1];
+            }, [null, null]), 2), idx = _a[0], filterFunction = _a[1];
             return idx ?
                 this.where(idx.name).equals(indexOrCrit[idx.keyPath])
                     .filter(filterFunction) :
@@ -1399,6 +1518,7 @@
             return this.toCollection().reverse();
         };
         Table.prototype.mapToClass = function (constructor) {
+            var _this = this;
             var _a = this, db = _a.db, tableName = _a.name;
             this.schema.mappedClass = constructor;
             if (constructor.prototype instanceof Entity) {
@@ -1416,6 +1536,21 @@
                     return class_1;
                 }(constructor));
             }
+            if (this.schema.yProps) {
+                var Y_1 = getYLibrary(db);
+                var DBObjectWithYProps =  (function (_super) {
+                    __extends(DBObjectWithYProps, _super);
+                    function DBObjectWithYProps() {
+                        return _super !== null && _super.apply(this, arguments) || this;
+                    }
+                    return DBObjectWithYProps;
+                }(constructor));
+                constructor = DBObjectWithYProps;
+                this.schema.yProps.forEach(function (_a) {
+                    var prop = _a.prop, updatesTable = _a.updatesTable;
+                    Object.defineProperty(constructor.prototype, prop, createYDocProperty(db, Y_1, _this, prop, updatesTable));
+                });
+            }
             var inheritedProps = new Set();
             for (var proto = constructor.prototype; proto; proto = getProto(proto)) {
                 Object.getOwnPropertyNames(proto).forEach(function (propName) { return inheritedProps.add(propName); });
@@ -1497,12 +1632,14 @@
         };
         Table.prototype.delete = function (key) {
             var _this = this;
-            return this._trans('readwrite', function (trans) { return _this.core.mutate({ trans: trans, type: 'delete', keys: [key] }); })
-                .then(function (res) { return res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined; });
+            return this._trans('readwrite', function (trans) { return _this.core.mutate({ trans: trans, type: 'delete', keys: [key] })
+                .then(function (res) { return builtInDeletionTrigger(_this, [key], res); })
+                .then(function (res) { return res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined; }); });
         };
         Table.prototype.clear = function () {
             var _this = this;
-            return this._trans('readwrite', function (trans) { return _this.core.mutate({ trans: trans, type: 'deleteRange', range: AnyRange }); })
+            return this._trans('readwrite', function (trans) { return _this.core.mutate({ trans: trans, type: 'deleteRange', range: AnyRange })
+                .then(function (res) { return builtInDeletionTrigger(_this, null, res); }); })
                 .then(function (res) { return res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined; });
         };
         Table.prototype.bulkGet = function (keys) {
@@ -1575,20 +1712,30 @@
                     var resultKeys = [];
                     var resultObjs = [];
                     keysAndChanges.forEach(function (_a, idx) {
+                        var e_1, _b;
                         var key = _a.key, changes = _a.changes;
                         var obj = objs[idx];
                         if (obj) {
-                            for (var _i = 0, _b = Object.keys(changes); _i < _b.length; _i++) {
-                                var keyPath = _b[_i];
-                                var value = changes[keyPath];
-                                if (keyPath === _this.schema.primKey.keyPath) {
-                                    if (cmp(value, key) !== 0) {
-                                        throw new exceptions.Constraint("Cannot update primary key in bulkUpdate()");
+                            try {
+                                for (var _c = __values(Object.keys(changes)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                    var keyPath = _d.value;
+                                    var value = changes[keyPath];
+                                    if (keyPath === _this.schema.primKey.keyPath) {
+                                        if (cmp(value, key) !== 0) {
+                                            throw new exceptions.Constraint("Cannot update primary key in bulkUpdate()");
+                                        }
+                                    }
+                                    else {
+                                        setByKeyPath(obj, keyPath, value);
                                     }
                                 }
-                                else {
-                                    setByKeyPath(obj, keyPath, value);
+                            }
+                            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                            finally {
+                                try {
+                                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
                                 }
+                                finally { if (e_1) throw e_1.error; }
                             }
                             offsetMap.push(idx);
                             resultKeys.push(key);
@@ -1608,17 +1755,27 @@
                         }
                     })
                         .then(function (_a) {
+                        var e_2, _b;
                         var numFailures = _a.numFailures, failures = _a.failures;
                         if (numFailures === 0)
                             return numEntries;
-                        for (var _i = 0, _b = Object.keys(failures); _i < _b.length; _i++) {
-                            var offset = _b[_i];
-                            var mappedOffset = offsetMap[Number(offset)];
-                            if (mappedOffset != null) {
-                                var failure = failures[offset];
-                                delete failures[offset];
-                                failures[mappedOffset] = failure;
+                        try {
+                            for (var _c = __values(Object.keys(failures)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                var offset = _d.value;
+                                var mappedOffset = offsetMap[Number(offset)];
+                                if (mappedOffset != null) {
+                                    var failure = failures[offset];
+                                    delete failures[offset];
+                                    failures[mappedOffset] = failure;
+                                }
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
                             }
+                            finally { if (e_2) throw e_2.error; }
                         }
                         throw new BulkError("".concat(_this.name, ".bulkUpdate(): ").concat(numFailures, " of ").concat(numEntries, " operations failed"), failures);
                     });
@@ -1629,7 +1786,8 @@
             var _this = this;
             var numKeys = keys.length;
             return this._trans('readwrite', function (trans) {
-                return _this.core.mutate({ trans: trans, type: 'delete', keys: keys });
+                return _this.core.mutate({ trans: trans, type: 'delete', keys: keys })
+                    .then(function (res) { return builtInDeletionTrigger(_this, keys, res); });
             }).then(function (_a) {
                 var numFailures = _a.numFailures, lastResult = _a.lastResult, failures = _a.failures;
                 if (numFailures === 0)
@@ -1813,7 +1971,7 @@
             if (this.add !== undefined) {
                 var term = this.add;
                 if (isArray(term)) {
-                    return __spreadArray(__spreadArray([], (isArray(value) ? value : []), true), term, true).sort();
+                    return __spreadArray(__spreadArray([], __read((isArray(value) ? value : [])), false), __read(term), false).sort();
                 }
                 if (typeof term === 'number')
                     return (Number(value) || 0) + term;
@@ -2146,52 +2304,65 @@
                 var successCount = 0;
                 var failedKeys = [];
                 var applyMutateResult = function (expectedCount, res) {
+                    var e_1, _a;
                     var failures = res.failures, numFailures = res.numFailures;
                     successCount += expectedCount - numFailures;
-                    for (var _i = 0, _a = keys(failures); _i < _a.length; _i++) {
-                        var pos = _a[_i];
-                        totalFailures.push(failures[pos]);
+                    try {
+                        for (var _b = __values(keys(failures)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                            var pos = _c.value;
+                            totalFailures.push(failures[pos]);
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                        }
+                        finally { if (e_1) throw e_1.error; }
                     }
                 };
+                var isUnconditionalDelete = changes === deleteCallback;
                 return _this.clone().primaryKeys().then(function (keys) {
                     var criteria = isPlainKeyRange(ctx) &&
                         ctx.limit === Infinity &&
-                        (typeof changes !== 'function' || changes === deleteCallback) && {
+                        (typeof changes !== 'function' || isUnconditionalDelete) && {
                         index: ctx.index,
                         range: ctx.range
                     };
                     var nextChunk = function (offset) {
                         var count = Math.min(limit, keys.length - offset);
-                        return coreTable.getMany({
+                        var keysInChunk = keys.slice(offset, offset + count);
+                        return (isUnconditionalDelete ? Promise.resolve([]) : coreTable.getMany({
                             trans: trans,
-                            keys: keys.slice(offset, offset + count),
+                            keys: keysInChunk,
                             cache: "immutable"
-                        }).then(function (values) {
+                        })).then(function (values) {
                             var addValues = [];
                             var putValues = [];
                             var putKeys = outbound ? [] : null;
-                            var deleteKeys = [];
-                            for (var i = 0; i < count; ++i) {
-                                var origValue = values[i];
-                                var ctx_1 = {
-                                    value: deepClone(origValue),
-                                    primKey: keys[offset + i]
-                                };
-                                if (modifyer.call(ctx_1, ctx_1.value, ctx_1) !== false) {
-                                    if (ctx_1.value == null) {
-                                        deleteKeys.push(keys[offset + i]);
-                                    }
-                                    else if (!outbound && cmp(extractKey(origValue), extractKey(ctx_1.value)) !== 0) {
-                                        deleteKeys.push(keys[offset + i]);
-                                        addValues.push(ctx_1.value);
-                                    }
-                                    else {
-                                        putValues.push(ctx_1.value);
-                                        if (outbound)
-                                            putKeys.push(keys[offset + i]);
+                            var deleteKeys = isUnconditionalDelete ? keysInChunk : [];
+                            if (!isUnconditionalDelete)
+                                for (var i = 0; i < count; ++i) {
+                                    var origValue = values[i];
+                                    var ctx_1 = {
+                                        value: deepClone(origValue),
+                                        primKey: keys[offset + i]
+                                    };
+                                    if (modifyer.call(ctx_1, ctx_1.value, ctx_1) !== false) {
+                                        if (ctx_1.value == null) {
+                                            deleteKeys.push(keys[offset + i]);
+                                        }
+                                        else if (!outbound && cmp(extractKey(origValue), extractKey(ctx_1.value)) !== 0) {
+                                            deleteKeys.push(keys[offset + i]);
+                                            addValues.push(ctx_1.value);
+                                        }
+                                        else {
+                                            putValues.push(ctx_1.value);
+                                            if (outbound)
+                                                putKeys.push(keys[offset + i]);
+                                        }
                                     }
                                 }
-                            }
                             return Promise.resolve(addValues.length > 0 &&
                                 coreTable.mutate({ trans: trans, type: 'add', values: addValues })
                                     .then(function (res) {
@@ -2209,14 +2380,15 @@
                                     changeSpec: typeof changes !== 'function'
                                         && changes,
                                     isAdditionalChunk: offset > 0
-                                }).then(function (res) { return applyMutateResult(putValues.length, res); }); }).then(function () { return (deleteKeys.length > 0 || (criteria && changes === deleteCallback)) &&
+                                }).then(function (res) { return applyMutateResult(putValues.length, res); }); }).then(function () { return (deleteKeys.length > 0 || (criteria && isUnconditionalDelete)) &&
                                 coreTable.mutate({
                                     trans: trans,
                                     type: 'delete',
                                     keys: deleteKeys,
                                     criteria: criteria,
                                     isAdditionalChunk: offset > 0
-                                }).then(function (res) { return applyMutateResult(deleteKeys.length, res); }); }).then(function () {
+                                }).then(function (res) { return builtInDeletionTrigger(ctx.table, deleteKeys, res); })
+                                    .then(function (res) { return applyMutateResult(deleteKeys.length, res); }); }).then(function () {
                                 return keys.length > offset + count && nextChunk(offset + limit);
                             });
                         });
@@ -2232,6 +2404,7 @@
         Collection.prototype.delete = function () {
             var ctx = this._ctx, range = ctx.range;
             if (isPlainKeyRange(ctx) &&
+                !ctx.table.schema.yProps &&
                 (ctx.isPrimKey || range.type === 3 ))
              {
                 return this._write(function (trans) {
@@ -2240,7 +2413,7 @@
                     return ctx.table.core.count({ trans: trans, query: { index: primaryKey, range: coreRange } }).then(function (count) {
                         return ctx.table.core.mutate({ trans: trans, type: 'deleteRange', range: coreRange })
                             .then(function (_a) {
-                            var failures = _a.failures; _a.lastResult; _a.results; var numFailures = _a.numFailures;
+                            var failures = _a.failures, numFailures = _a.numFailures;
                             if (numFailures)
                                 throw new ModifyError("Could not delete some values", Object.keys(failures).map(function (pos) { return failures[pos]; }), count - numFailures);
                             return count - numFailures;
@@ -2842,6 +3015,13 @@
     function createTransactionConstructor(db) {
         return makeClassConstructor(Transaction.prototype, function Transaction(mode, storeNames, dbschema, chromeTransactionDurability, parent) {
             var _this = this;
+            if (mode !== 'readonly')
+                storeNames.forEach(function (storeName) {
+                    var _a;
+                    var yProps = (_a = dbschema[storeName]) === null || _a === void 0 ? void 0 : _a.yProps;
+                    if (yProps)
+                        storeNames = storeNames.concat(yProps.map(function (p) { return p.updatesTable; }));
+                });
             this.db = db;
             this.mode = mode;
             this.storeNames = storeNames;
@@ -2877,7 +3057,7 @@
         });
     }
 
-    function createIndexSpec(name, keyPath, unique, multi, auto, compound, isPrimKey) {
+    function createIndexSpec(name, keyPath, unique, multi, auto, compound, isPrimKey, type) {
         return {
             name: name,
             keyPath: keyPath,
@@ -2885,7 +3065,8 @@
             multi: multi,
             auto: auto,
             compound: compound,
-            src: (unique && !isPrimKey ? '&' : '') + (multi ? '*' : '') + (auto ? "++" : "") + nameFromKeyPath(keyPath)
+            src: (unique && !isPrimKey ? '&' : '') + (multi ? '*' : '') + (auto ? "++" : "") + nameFromKeyPath(keyPath),
+            type: type
         };
     }
     function nameFromKeyPath(keyPath) {
@@ -2894,13 +3075,17 @@
             keyPath ? ('[' + [].join.call(keyPath, '+') + ']') : "";
     }
 
-    function createTableSchema(name, primKey, indexes) {
+    function createTableSchema(name, primKey, indexes, yProps) {
         return {
             name: name,
             primKey: primKey,
             indexes: indexes,
             mappedClass: null,
-            idxByName: arrayToObject(indexes, function (index) { return [index.name, index]; })
+            yProps: yProps === null || yProps === void 0 ? void 0 : yProps.map(function (prop) { return ({
+                prop: prop,
+                updatesTable: "$".concat(name, ".").concat(prop, "_updates"),
+            }); }),
+            idxByName: arrayToObject(indexes, function (index) { return [index.name, index]; }),
         };
     }
 
@@ -3053,11 +3238,11 @@
                             reqs.push(req = store.delete(makeIDBKeyRange(range)));
                     }
                     else {
-                        var _a = isAddOrPut ?
+                        var _a = __read(isAddOrPut ?
                             outbound ?
                                 [values, keys] :
                                 [values, null] :
-                            [keys, null], args1 = _a[0], args2 = _a[1];
+                            [keys, null], 2), args1 = _a[0], args2 = _a[1];
                         if (isAddOrPut) {
                             for (var i = 0; i < length; ++i) {
                                 reqs.push(req = (args2 && args2[i] !== undefined ?
@@ -3382,6 +3567,7 @@
         });
     }
     function patchCurrentVersion(db, idbUpgradeTrans) {
+        var e_1, _a;
         createMissingTables(db._dbSchema, idbUpgradeTrans);
         if (idbUpgradeTrans.db.version % 10 === 0 && !idbUpgradeTrans.objectStoreNames.contains('$meta')) {
             idbUpgradeTrans.db.createObjectStore('$meta').add(Math.ceil((idbUpgradeTrans.db.version / 10) - 1), 'version');
@@ -3401,11 +3587,20 @@
                 addIndex(store, idx);
             });
         };
-        for (var _i = 0, _a = diff.change; _i < _a.length; _i++) {
-            var tableChange = _a[_i];
-            var state_1 = _loop_1(tableChange);
-            if (typeof state_1 === "object")
-                return state_1.value;
+        try {
+            for (var _b = __values(diff.change), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tableChange = _c.value;
+                var state_1 = _loop_1(tableChange);
+                if (typeof state_1 === "object")
+                    return state_1.value;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
         }
     }
     function getExistingVersion(db, trans, oldVersion) {
@@ -3644,51 +3839,169 @@
     }
     function parseIndexSyntax(primKeyAndIndexes) {
         return primKeyAndIndexes.split(',').map(function (index, indexNum) {
-            index = index.trim();
+            var _a;
+            var typeSplit = index.split(':');
+            var type = (_a = typeSplit[1]) === null || _a === void 0 ? void 0 : _a.trim();
+            index = typeSplit[0].trim();
+            if (type && type !== 'Y')
+                throw new exceptions.Schema("Unsupported type '".concat(type, "'"));
             var name = index.replace(/([&*]|\+\+)/g, "");
             var keyPath = /^\[/.test(name) ? name.match(/^\[(.*)\]$/)[1].split('+') : name;
-            return createIndexSpec(name, keyPath || null, /\&/.test(index), /\*/.test(index), /\+\+/.test(index), isArray(keyPath), indexNum === 0);
+            return createIndexSpec(name, keyPath || null, /\&/.test(index), /\*/.test(index), /\+\+/.test(index), isArray(keyPath), indexNum === 0, type);
         });
     }
 
+    var EMPTY_ARRAY = [];
+    function createYjsMiddleware(dbSchema, Y) {
+        return {
+            stack: 'dbcore',
+            name: 'yjsMiddleware',
+            level: 50,
+            create: function (downCore) {
+                return (__assign(__assign({}, downCore), { table: function (tableName) {
+                        var downTable = downCore.table(tableName);
+                        var dbTableSchema = dbSchema[tableName];
+                        var yProps = dbTableSchema.yProps;
+                        if (!yProps || yProps.length === 0)
+                            return downTable;
+                        var tableMiddleware = __assign(__assign({}, downTable), { mutate: function (req) {
+                                if (req.type !== 'add' && req.type !== 'put')
+                                    return downTable.mutate(req);
+                                var reqClone = req;
+                                var updateSources = yProps
+                                    .map(function (p) { return ({
+                                    p: p,
+                                    entries: req.values.flatMap(function (value, iter) {
+                                        if (!value || typeof value !== 'object')
+                                            throw new TypeError("Table ".concat(tableName, " (with Y-properties) must only contain objects"));
+                                        if (!hasOwn(value, p.prop))
+                                            return [];
+                                        if (reqClone === req)
+                                            reqClone = __assign(__assign({}, req), { values: req.values.map(function (v) { return (__assign({}, v)); }) });
+                                        delete reqClone.values[iter][p.prop];
+                                        var doc = value[p.prop];
+                                        if (doc === null)
+                                            throw new TypeError("Cannot set Y property to null");
+                                        if (doc === undefined)
+                                            return EMPTY_ARRAY;
+                                        if (typeof doc !== 'object' || !('whenLoaded' in doc)) {
+                                            throw new TypeError("Y properties can only be inited with an Y.Doc instance or undefined to create an empty Y.Doc");
+                                        }
+                                        if (req.type === 'put')
+                                            throw new TypeError("Setting ".concat(tableName, ".").concat(p.prop, " (declared as ").concat(p.prop, ":Y) is only allowed when inserting new objects using db.").concat(tableName, ".add(), not put() or update()."));
+                                        if (Y.encodeStateVector(doc).length === 1) {
+                                            return EMPTY_ARRAY;
+                                        }
+                                        return {
+                                            iter: iter,
+                                            u: Y.encodeStateAsUpdateV2(doc),
+                                        };
+                                    }),
+                                }); })
+                                    .filter(function (_a) {
+                                    var entries = _a.entries;
+                                    return entries.length > 0;
+                                });
+                                if (req === reqClone)
+                                    return downTable.mutate(req);
+                                return downTable.mutate(reqClone).then(function (res) {
+                                    if (updateSources.length === 0)
+                                        return res;
+                                    return Promise.all(updateSources.map(function (_a) {
+                                        var p = _a.p, entries = _a.entries;
+                                        var updatesTable = downCore.table(p.updatesTable);
+                                        var updatesToInsert = entries.map(function (_a) {
+                                            var iter = _a.iter, u = _a.u;
+                                            return ({
+                                                k: res.results[iter],
+                                                u: u,
+                                                f: 1,
+                                            });
+                                        });
+                                        return updatesTable.mutate({
+                                            type: 'add',
+                                            values: updatesToInsert,
+                                            trans: req.trans,
+                                        });
+                                    })).then(function () { return res; });
+                                });
+                            } });
+                        return tableMiddleware;
+                    } }));
+            },
+        };
+    }
+
     var Version =  (function () {
         function Version() {
         }
         Version.prototype._parseStoresSpec = function (stores, outSchema) {
+            var _this = this;
             keys(stores).forEach(function (tableName) {
+                var e_1, _a, _b;
                 if (stores[tableName] !== null) {
                     var indexes = parseIndexSyntax(stores[tableName]);
+                    var yProps = indexes.filter(function (idx) { return idx.type === 'Y'; }).map(function (idx) { return idx.name; });
+                    indexes = indexes.filter(function (idx) { return idx.type !== 'Y'; });
                     var primKey = indexes.shift();
+                    if (!primKey) {
+                        throw new exceptions.Schema('Invalid schema for table ' + tableName + ': ' + stores[tableName]);
+                    }
                     primKey.unique = true;
                     if (primKey.multi)
-                        throw new exceptions.Schema("Primary key cannot be multi-valued");
+                        throw new exceptions.Schema('Primary key cannot be multiEntry*');
                     indexes.forEach(function (idx) {
                         if (idx.auto)
-                            throw new exceptions.Schema("Only primary key can be marked as autoIncrement (++)");
+                            throw new exceptions.Schema('Only primary key can be marked as autoIncrement (++)');
                         if (!idx.keyPath)
-                            throw new exceptions.Schema("Index must have a name and cannot be an empty string");
+                            throw new exceptions.Schema('Index must have a name and cannot be an empty string');
                     });
-                    outSchema[tableName] = createTableSchema(tableName, primKey, indexes);
+                    var tblSchema = createTableSchema(tableName, primKey, indexes, yProps.length ? yProps : undefined);
+                    outSchema[tableName] = tblSchema;
+                    try {
+                        for (var _c = __values(tblSchema.yProps || []), _d = _c.next(); !_d.done; _d = _c.next()) {
+                            var yProp = _d.value;
+                            _this._parseStoresSpec((_b = {}, _b[yProp.updatesTable] = '++i,k', _b), outSchema);
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
                 }
             });
         };
         Version.prototype.stores = function (stores) {
             var db = this.db;
-            this._cfg.storesSource = this._cfg.storesSource ?
-                extend(this._cfg.storesSource, stores) :
-                stores;
+            this._cfg.storesSource = this._cfg.storesSource
+                ? extend(this._cfg.storesSource, stores)
+                : stores;
             var versions = db._versions;
             var storesSpec = {};
             var dbschema = {};
             versions.forEach(function (version) {
                 extend(storesSpec, version._cfg.storesSource);
-                dbschema = (version._cfg.dbschema = {});
+                dbschema = version._cfg.dbschema = {};
                 version._parseStoresSpec(storesSpec, dbschema);
             });
             db._dbSchema = dbschema;
             removeTablesApi(db, [db._allTables, db, db.Transaction.prototype]);
             setApiOnPlace(db, [db._allTables, db, db.Transaction.prototype, this._cfg.tables], keys(dbschema), dbschema);
             db._storeNames = keys(dbschema);
+            db._storeNames.forEach(function (tableName) {
+                if (dbschema[tableName].yProps) {
+                    db.table(tableName).mapToClass(dbschema[tableName].mappedClass || Object);
+                }
+            });
+            if (Object.values(dbschema).some(function (table) { return table.yProps; })) {
+                db.use(createYjsMiddleware(dbschema, getYLibrary(db)));
+            }
+            else {
+                db.unuse({ stack: 'dbcore', name: 'yjsMiddleware' });
+            }
             return this;
         };
         Version.prototype.upgrade = function (upgradeFunction) {
@@ -3967,19 +4280,29 @@
         }
     }
     function signalSubscribersNow(updatedParts, deleteAffectedCacheEntries) {
+        var e_1, _a;
         if (deleteAffectedCacheEntries === void 0) { deleteAffectedCacheEntries = false; }
         var queriesToSignal = new Set();
         if (updatedParts.all) {
-            for (var _i = 0, _a = Object.values(cache); _i < _a.length; _i++) {
-                var tblCache = _a[_i];
-                collectTableSubscribers(tblCache, updatedParts, queriesToSignal, deleteAffectedCacheEntries);
+            try {
+                for (var _b = __values(Object.values(cache)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var tblCache = _c.value;
+                    collectTableSubscribers(tblCache, updatedParts, queriesToSignal, deleteAffectedCacheEntries);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
             }
         }
         else {
             for (var key in updatedParts) {
                 var parts = /^idb\:\/\/(.*)\/(.*)\//.exec(key);
                 if (parts) {
-                    var dbName = parts[1], tableName = parts[2];
+                    var _d = __read(parts, 3), dbName = _d[1], tableName = _d[2];
                     var tblCache = cache["idb://".concat(dbName, "/").concat(tableName)];
                     if (tblCache)
                         collectTableSubscribers(tblCache, updatedParts, queriesToSignal, deleteAffectedCacheEntries);
@@ -3989,26 +4312,54 @@
         queriesToSignal.forEach(function (requery) { return requery(); });
     }
     function collectTableSubscribers(tblCache, updatedParts, outQueriesToSignal, deleteAffectedCacheEntries) {
+        var e_2, _a, e_3, _b, e_4, _c;
         var updatedEntryLists = [];
-        for (var _i = 0, _a = Object.entries(tblCache.queries.query); _i < _a.length; _i++) {
-            var _b = _a[_i], indexName = _b[0], entries = _b[1];
-            var filteredEntries = [];
-            for (var _c = 0, entries_1 = entries; _c < entries_1.length; _c++) {
-                var entry = entries_1[_c];
-                if (obsSetsOverlap(updatedParts, entry.obsSet)) {
-                    entry.subscribers.forEach(function (requery) { return outQueriesToSignal.add(requery); });
+        try {
+            for (var _d = __values(Object.entries(tblCache.queries.query)), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var _f = __read(_e.value, 2), indexName = _f[0], entries = _f[1];
+                var filteredEntries = [];
+                try {
+                    for (var entries_1 = (e_3 = void 0, __values(entries)), entries_1_1 = entries_1.next(); !entries_1_1.done; entries_1_1 = entries_1.next()) {
+                        var entry = entries_1_1.value;
+                        if (obsSetsOverlap(updatedParts, entry.obsSet)) {
+                            entry.subscribers.forEach(function (requery) { return outQueriesToSignal.add(requery); });
+                        }
+                        else if (deleteAffectedCacheEntries) {
+                            filteredEntries.push(entry);
+                        }
+                    }
                 }
-                else if (deleteAffectedCacheEntries) {
-                    filteredEntries.push(entry);
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (entries_1_1 && !entries_1_1.done && (_b = entries_1.return)) _b.call(entries_1);
+                    }
+                    finally { if (e_3) throw e_3.error; }
                 }
+                if (deleteAffectedCacheEntries)
+                    updatedEntryLists.push([indexName, filteredEntries]);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
             }
-            if (deleteAffectedCacheEntries)
-                updatedEntryLists.push([indexName, filteredEntries]);
+            finally { if (e_2) throw e_2.error; }
         }
         if (deleteAffectedCacheEntries) {
-            for (var _d = 0, updatedEntryLists_1 = updatedEntryLists; _d < updatedEntryLists_1.length; _d++) {
-                var _e = updatedEntryLists_1[_d], indexName = _e[0], filteredEntries = _e[1];
-                tblCache.queries.query[indexName] = filteredEntries;
+            try {
+                for (var updatedEntryLists_1 = __values(updatedEntryLists), updatedEntryLists_1_1 = updatedEntryLists_1.next(); !updatedEntryLists_1_1.done; updatedEntryLists_1_1 = updatedEntryLists_1.next()) {
+                    var _g = __read(updatedEntryLists_1_1.value, 2), indexName = _g[0], filteredEntries = _g[1];
+                    tblCache.queries.query[indexName] = filteredEntries;
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (updatedEntryLists_1_1 && !updatedEntryLists_1_1.done && (_c = updatedEntryLists_1.return)) _c.call(updatedEntryLists_1);
+                }
+                finally { if (e_4) throw e_4.error; }
             }
         }
     }
@@ -4259,6 +4610,7 @@
     }
     function createVirtualIndexMiddleware(down) {
         return __assign(__assign({}, down), { table: function (tableName) {
+                var e_1, _a;
                 var table = down.table(tableName);
                 var schema = table.schema;
                 var indexLookup = {};
@@ -4286,9 +4638,18 @@
                 }
                 var primaryKey = addVirtualIndexes(schema.primaryKey.keyPath, 0, schema.primaryKey);
                 indexLookup[":id"] = [primaryKey];
-                for (var _i = 0, _a = schema.indexes; _i < _a.length; _i++) {
-                    var index = _a[_i];
-                    addVirtualIndexes(index.keyPath, 0, index);
+                try {
+                    for (var _b = __values(schema.indexes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var index = _c.value;
+                        addVirtualIndexes(index.keyPath, 0, index);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
                 }
                 function findBestIndex(keyPath) {
                     var result = indexLookup[getKeyPathAlias(keyPath)];
@@ -4448,9 +4809,9 @@
                                 throw new Error("Keys missing");
                             req = req.type === 'add' || req.type === 'put' ? __assign(__assign({}, req), { keys: keys }) : __assign({}, req);
                             if (req.type !== 'delete')
-                                req.values = __spreadArray([], req.values, true);
+                                req.values = __spreadArray([], __read(req.values), false);
                             if (req.keys)
-                                req.keys = __spreadArray([], req.keys, true);
+                                req.keys = __spreadArray([], __read(req.keys), false);
                             return getExistingValues(downTable, req, keys).then(function (existingValues) {
                                 var contexts = keys.map(function (key, i) {
                                     var existingValue = existingValues[i];
@@ -4639,13 +5000,13 @@
                             var pkRangeSet = getRangeSet("");
                             var delsRangeSet = getRangeSet(":dels");
                             var type = req.type;
-                            var _a = req.type === "deleteRange"
+                            var _a = __read(req.type === "deleteRange"
                                 ? [req.range]
                                 : req.type === "delete"
                                     ? [req.keys]
                                     : req.values.length < 50
                                         ? [getEffectiveKeys(primaryKey, req).filter(function (id) { return id; }), req.values]
-                                        : [], keys = _a[0], newObjs = _a[1];
+                                        : [], 2), keys = _a[0], newObjs = _a[1];
                             var oldCache = req.trans["_cache"];
                             if (isArray(keys)) {
                                 pkRangeSet.addKeys(keys);
@@ -4714,7 +5075,7 @@
                                 };
                                 var pkRangeSet_1 = getRangeSet("");
                                 var delsRangeSet_1 = getRangeSet(":dels");
-                                var _a = readSubscribers[method](req), queriedIndex = _a[0], queriedRanges = _a[1];
+                                var _a = __read(readSubscribers[method](req), 2), queriedIndex = _a[0], queriedRanges = _a[1];
                                 if (method === 'query' && queriedIndex.isPrimaryKey && !req.values) {
                                     delsRangeSet_1.add(queriedRanges);
                                 }
@@ -5038,60 +5399,106 @@
                         var ac_1 = new AbortController();
                         var signal = ac_1.signal;
                         var endTransaction = function (wasCommitted) { return function () {
+                            var e_1, _a, e_2, _b, e_3, _c, e_4, _d, e_5, _e;
                             ac_1.abort();
                             if (mode === 'readwrite') {
                                 var affectedSubscribers_1 = new Set();
-                                for (var _i = 0, stores_1 = stores; _i < stores_1.length; _i++) {
-                                    var storeName = stores_1[_i];
-                                    var tblCache = cache["idb://".concat(dbName, "/").concat(storeName)];
-                                    if (tblCache) {
-                                        var table = core.table(storeName);
-                                        var ops = tblCache.optimisticOps.filter(function (op) { return op.trans === idbtrans; });
-                                        if (idbtrans._explicit && wasCommitted && idbtrans.mutatedParts) {
-                                            for (var _a = 0, _b = Object.values(tblCache.queries.query); _a < _b.length; _a++) {
-                                                var entries = _b[_a];
-                                                for (var _c = 0, _d = entries.slice(); _c < _d.length; _c++) {
-                                                    var entry = _d[_c];
-                                                    if (obsSetsOverlap(entry.obsSet, idbtrans.mutatedParts)) {
-                                                        delArrayItem(entries, entry);
-                                                        entry.subscribers.forEach(function (requery) { return affectedSubscribers_1.add(requery); });
+                                try {
+                                    for (var stores_1 = __values(stores), stores_1_1 = stores_1.next(); !stores_1_1.done; stores_1_1 = stores_1.next()) {
+                                        var storeName = stores_1_1.value;
+                                        var tblCache = cache["idb://".concat(dbName, "/").concat(storeName)];
+                                        if (tblCache) {
+                                            var table = core.table(storeName);
+                                            var ops = tblCache.optimisticOps.filter(function (op) { return op.trans === idbtrans; });
+                                            if (idbtrans._explicit && wasCommitted && idbtrans.mutatedParts) {
+                                                try {
+                                                    for (var _f = (e_2 = void 0, __values(Object.values(tblCache.queries.query))), _g = _f.next(); !_g.done; _g = _f.next()) {
+                                                        var entries = _g.value;
+                                                        try {
+                                                            for (var _h = (e_3 = void 0, __values(entries.slice())), _j = _h.next(); !_j.done; _j = _h.next()) {
+                                                                var entry = _j.value;
+                                                                if (obsSetsOverlap(entry.obsSet, idbtrans.mutatedParts)) {
+                                                                    delArrayItem(entries, entry);
+                                                                    entry.subscribers.forEach(function (requery) { return affectedSubscribers_1.add(requery); });
+                                                                }
+                                                            }
+                                                        }
+                                                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                                                        finally {
+                                                            try {
+                                                                if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                                                            }
+                                                            finally { if (e_3) throw e_3.error; }
+                                                        }
+                                                    }
+                                                }
+                                                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                                finally {
+                                                    try {
+                                                        if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
                                                     }
+                                                    finally { if (e_2) throw e_2.error; }
                                                 }
                                             }
-                                        }
-                                        else if (ops.length > 0) {
-                                            tblCache.optimisticOps = tblCache.optimisticOps.filter(function (op) { return op.trans !== idbtrans; });
-                                            for (var _e = 0, _f = Object.values(tblCache.queries.query); _e < _f.length; _e++) {
-                                                var entries = _f[_e];
-                                                for (var _g = 0, _h = entries.slice(); _g < _h.length; _g++) {
-                                                    var entry = _h[_g];
-                                                    if (entry.res != null &&
-                                                        idbtrans.mutatedParts
+                                            else if (ops.length > 0) {
+                                                tblCache.optimisticOps = tblCache.optimisticOps.filter(function (op) { return op.trans !== idbtrans; });
+                                                try {
+                                                    for (var _k = (e_4 = void 0, __values(Object.values(tblCache.queries.query))), _l = _k.next(); !_l.done; _l = _k.next()) {
+                                                        var entries = _l.value;
+                                                        try {
+                                                            for (var _m = (e_5 = void 0, __values(entries.slice())), _o = _m.next(); !_o.done; _o = _m.next()) {
+                                                                var entry = _o.value;
+                                                                if (entry.res != null &&
+                                                                    idbtrans.mutatedParts
     ) {
-                                                        if (wasCommitted && !entry.dirty) {
-                                                            var freezeResults = Object.isFrozen(entry.res);
-                                                            var modRes = applyOptimisticOps(entry.res, entry.req, ops, table, entry, freezeResults);
-                                                            if (entry.dirty) {
-                                                                delArrayItem(entries, entry);
-                                                                entry.subscribers.forEach(function (requery) { return affectedSubscribers_1.add(requery); });
-                                                            }
-                                                            else if (modRes !== entry.res) {
-                                                                entry.res = modRes;
-                                                                entry.promise = DexiePromise.resolve({ result: modRes });
+                                                                    if (wasCommitted && !entry.dirty) {
+                                                                        var freezeResults = Object.isFrozen(entry.res);
+                                                                        var modRes = applyOptimisticOps(entry.res, entry.req, ops, table, entry, freezeResults);
+                                                                        if (entry.dirty) {
+                                                                            delArrayItem(entries, entry);
+                                                                            entry.subscribers.forEach(function (requery) { return affectedSubscribers_1.add(requery); });
+                                                                        }
+                                                                        else if (modRes !== entry.res) {
+                                                                            entry.res = modRes;
+                                                                            entry.promise = DexiePromise.resolve({ result: modRes });
+                                                                        }
+                                                                    }
+                                                                    else {
+                                                                        if (entry.dirty) {
+                                                                            delArrayItem(entries, entry);
+                                                                        }
+                                                                        entry.subscribers.forEach(function (requery) { return affectedSubscribers_1.add(requery); });
+                                                                    }
+                                                                }
                                                             }
                                                         }
-                                                        else {
-                                                            if (entry.dirty) {
-                                                                delArrayItem(entries, entry);
+                                                        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                                                        finally {
+                                                            try {
+                                                                if (_o && !_o.done && (_e = _m.return)) _e.call(_m);
                                                             }
-                                                            entry.subscribers.forEach(function (requery) { return affectedSubscribers_1.add(requery); });
+                                                            finally { if (e_5) throw e_5.error; }
                                                         }
                                                     }
                                                 }
+                                                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                                                finally {
+                                                    try {
+                                                        if (_l && !_l.done && (_d = _k.return)) _d.call(_k);
+                                                    }
+                                                    finally { if (e_4) throw e_4.error; }
+                                                }
                                             }
                                         }
                                     }
                                 }
+                                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                                finally {
+                                    try {
+                                        if (stores_1_1 && !stores_1_1.done && (_a = stores_1.return)) _a.call(stores_1);
+                                    }
+                                    finally { if (e_1) throw e_1.error; }
+                                }
                                 affectedSubscribers_1.forEach(function (requery) { return requery(); });
                             }
                         }; };
@@ -5161,7 +5568,7 @@
                                 return downTable.query(req);
                             var freezeResults = ((_a = PSD.trans) === null || _a === void 0 ? void 0 : _a.db._options.cache) === 'immutable';
                             var _b = PSD, requery = _b.requery, signal = _b.signal;
-                            var _c = findCompatibleQuery(dbName, tableName, 'query', req), cacheEntry = _c[0], exactMatch = _c[1], tblCache = _c[2], container = _c[3];
+                            var _c = __read(findCompatibleQuery(dbName, tableName, 'query', req), 4), cacheEntry = _c[0], exactMatch = _c[1], tblCache = _c[2], container = _c[3];
                             if (cacheEntry && exactMatch) {
                                 cacheEntry.obsSet = req.obsSet;
                             }
@@ -5235,6 +5642,181 @@
         });
     }
 
+    function compressYDocs(db, interval) {
+        var e_1, _a, e_2, _b;
+        var p = Promise.resolve();
+        try {
+            for (var _c = __values(db.tables), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var table = _d.value;
+                var _loop_1 = function (yProp) {
+                    p = p.then(function () { return compressYDocsTable(db, yProp, interval); });
+                };
+                try {
+                    for (var _e = (e_2 = void 0, __values(table.schema.yProps || [])), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var yProp = _f.value;
+                        _loop_1(yProp);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return p;
+    }
+    function compressYDocsTable(db, _a, skipIfRunnedSince
+    ) {
+        var updatesTable = _a.updatesTable;
+        var updTbl = db.table(updatesTable);
+        return Promise.all([
+            updTbl
+                .where('i')
+                .startsWith('')
+                .toArray(),
+            db.transaction('rw', updatesTable, function () {
+                return updTbl.get(0).then(function (lastCompressed) {
+                    if (lastCompressed &&
+                        skipIfRunnedSince &&
+                        lastCompressed.lastRun.getTime() > Date.now() - skipIfRunnedSince) {
+                        return null;
+                    }
+                    lastCompressed = lastCompressed || { i: 0, lastCompressed: 0 };
+                    return updTbl
+                        .put(__assign(__assign({}, lastCompressed), { lastRun: new Date() }))
+                        .then(function () { return lastCompressed; });
+                });
+            }),
+        ]).then(function (_a) {
+            var _b = __read(_a, 2), syncers = _b[0], stamp = _b[1];
+            if (!stamp)
+                return;
+            var lastCompressedUpdate = stamp.lastCompressed;
+            var unsyncedFrom = Math.min.apply(Math, __spreadArray([], __read(syncers.map(function (s) {
+                return Math.min(s.unsentFrom || Infinity, s.receivedUntil != null ? s.receivedUntil + 1 : Infinity);
+            })), false));
+            return updTbl
+                .where('i')
+                .between(lastCompressedUpdate, Infinity, false)
+                .toArray(function (addedUpdates) {
+                var e_3, _a;
+                if (addedUpdates.length === 0)
+                    return;
+                var docsToCompress = [];
+                var lastUpdateToCompress = lastCompressedUpdate;
+                var _loop_2 = function (j) {
+                    var updateRow = addedUpdates[j];
+                    var i = updateRow.i, f = updateRow.f, k = updateRow.k;
+                    if (i >= unsyncedFrom && f & 0x01)
+                        return "break";
+                    var entry = docsToCompress.find(function (entry) { return cmp(entry.docId, k) === 0; });
+                    if (entry)
+                        entry.updates.push(updateRow);
+                    else
+                        docsToCompress.push({ docId: k, updates: [updateRow] });
+                    lastUpdateToCompress = i;
+                };
+                for (var j = 0; j < addedUpdates.length; ++j) {
+                    var state_1 = _loop_2(j);
+                    if (state_1 === "break")
+                        break;
+                }
+                if (lastUpdateToCompress === lastCompressedUpdate)
+                    return;
+                var p = Promise.resolve();
+                var _loop_3 = function (docId, updates) {
+                    p = p.then(function () {
+                        return compressUpdatesForDoc(db, updatesTable, docId, updates);
+                    });
+                };
+                try {
+                    for (var docsToCompress_1 = __values(docsToCompress), docsToCompress_1_1 = docsToCompress_1.next(); !docsToCompress_1_1.done; docsToCompress_1_1 = docsToCompress_1.next()) {
+                        var _b = docsToCompress_1_1.value, docId = _b.docId, updates = _b.updates;
+                        _loop_3(docId, updates);
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (docsToCompress_1_1 && !docsToCompress_1_1.done && (_a = docsToCompress_1.return)) _a.call(docsToCompress_1);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+                return p.then(function () {
+                    return db.transaction('rw', updTbl, function () {
+                        return updTbl.get(0).then(function (current) {
+                            if (current && lastUpdateToCompress <= current.lastCompressed) {
+                                return;
+                            }
+                            return updTbl.put(__assign(__assign({}, current), { lastCompressed: lastUpdateToCompress }));
+                        });
+                    });
+                });
+            });
+        });
+    }
+    function compressUpdatesForDoc(db, updatesTable, parentId, addedUpdatesToCompress) {
+        if (addedUpdatesToCompress.length < 1)
+            throw new Error('Invalid input');
+        return db.transaction('rw', updatesTable, function (tx) {
+            var updTbl = tx.table(updatesTable);
+            return updTbl.where({ k: parentId }).first(function (mainUpdate) {
+                var updates = [mainUpdate].concat(addedUpdatesToCompress.filter(function (u) { return u.i !== mainUpdate.i; }));
+                var Y = getYLibrary(db);
+                var doc = new Y.Doc({ gc: true });
+                updates.forEach(function (update) {
+                    Y.applyUpdateV2(doc, update.u);
+                });
+                var compressedUpdate = Y.encodeStateAsUpdateV2(doc);
+                var lastUpdate = updates.pop();
+                return updTbl
+                    .put({
+                    i: lastUpdate.i,
+                    k: parentId,
+                    u: compressedUpdate,
+                })
+                    .then(function () { return updTbl.bulkDelete(updates.map(function (update) { return update.i; })); });
+            });
+        });
+    }
+
+    var GC_DELAY = 10000;
+    var GC_INTERVAL = 300000;
+    function periodicGC(db) {
+        var timer = null;
+        db.on('ready', function (db) {
+            if (db.tables.some(function (tbl) { return tbl.schema.yProps; })) {
+                var gc_1 = function () {
+                    if (!db.isOpen())
+                        return;
+                    compressYDocs(db, GC_INTERVAL).catch(function (err) {
+                        if (err && err.name === 'DatabaseClosedError')
+                            return;
+                        console.debug('Error during periodic GC', err);
+                    }).then(function () {
+                        timer = setTimeout(gc_1, GC_INTERVAL);
+                    });
+                };
+                timer = setTimeout(gc_1, GC_DELAY);
+            }
+        }, true);
+        db.on('close', function () {
+            if (timer)
+                clearTimeout(timer);
+            timer = null;
+        });
+    }
+
     var Dexie$1 =  (function () {
         function Dexie(name, options) {
             var _this = this;
@@ -5276,7 +5858,18 @@
             });
             this._state = state;
             this.name = name;
-            this.on = Events(this, "populate", "blocked", "versionchange", "close", { ready: [promisableChain, nop] });
+            this.on = Events(this, "populate", "blocked", "versionchange", "close", "y", { ready: [promisableChain, nop] });
+            this.once = function (event, callback) {
+                var fn = function () {
+                    var args = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        args[_i] = arguments[_i];
+                    }
+                    _this.on(event).unsubscribe(fn);
+                    callback.apply(_this, args);
+                };
+                return _this.on(event, fn);
+            };
             this.on.ready.subscribe = override(this.on.ready.subscribe, function (subscribe) {
                 return function (subscriber, bSticky) {
                     Dexie.vip(function () {
@@ -5355,6 +5948,8 @@
                 }
             });
             this.vip = vipDB;
+            if ((options === null || options === void 0 ? void 0 : options.Y) && (options === null || options === void 0 ? void 0 : options.gc) !== false)
+                periodicGC(this);
             addons.forEach(function (addon) { return addon(_this); });
         }
         Dexie.prototype.version = function (versionNumber) {
@@ -5417,6 +6012,7 @@
             function () { return dexieOpen(_this); });
         };
         Dexie.prototype._close = function () {
+            this.on.close.fire(new CustomEvent('close'));
             var state = this._state;
             var idx = connections.indexOf(this);
             if (idx >= 0)
@@ -5574,6 +6170,9 @@
             }
             return this._allTables[tableName];
         };
+        Dexie.prototype.gc = function () {
+            return compressYDocs(this);
+        };
         return Dexie;
     }());
 
@@ -5874,6 +6473,175 @@
         return new PropModification({ replacePrefix: [a, b] });
     }
 
+    function observeYDocUpdates(provider, doc, db, parentTableName, updatesTableName, parentId, Y) {
+        var lastUpdateId = 0;
+        var initial = true;
+        var subscription = liveQuery(function () {
+            throwIfDestroyed(doc);
+            var updatesTable = db.table(updatesTableName);
+            return Promise.all([
+                (lastUpdateId > 0
+                    ? updatesTable
+                        .where('i')
+                        .between(lastUpdateId, Infinity, false)
+                        .toArray()
+                        .then(function (updates) {
+                        return updates.filter(function (update) { return cmp(update.k, parentId) === 0; });
+                    })
+                    : updatesTable.where({ k: parentId }).toArray()).then(function (updates) {
+                    return updates;
+                }),
+                db.table(parentTableName).where(':id').equals(parentId).toArray(),
+            ]);
+        }).subscribe(function (_a) {
+            var _b = __read(_a, 2), updates = _b[0], parentRow = _b[1];
+            if (updates.length > 0)
+                lastUpdateId = updates[updates.length - 1].i;
+            if (parentRow.length === 0) {
+                doc.destroy();
+                return;
+            }
+            throwIfDestroyed(doc);
+            if (updates.length > 0) {
+                Y.transact(doc, function () {
+                    updates.forEach(function (update) {
+                        try {
+                            DexieYProvider.currentUpdateRow = update;
+                            Y.applyUpdateV2(doc, update.u);
+                        }
+                        finally {
+                            DexieYProvider.currentUpdateRow = null;
+                        }
+                    });
+                }, provider, false);
+            }
+            if (initial) {
+                initial = false;
+                doc.emit('load', [doc]);
+            }
+        }, function (error) {
+            provider.on('error').fire(error);
+        });
+        var onUpdate = function (update, origin) {
+            if (origin === provider)
+                return;
+            db.table(updatesTableName)
+                .add({
+                k: parentId,
+                u: update,
+                f: 1,
+            })
+                .then(function (i) {
+                if (i === lastUpdateId - 1)
+                    ++lastUpdateId;
+            })
+                .catch(function (error) {
+                provider.on('error').fire(error);
+            });
+        };
+        var stopObserving = function () {
+            subscription.unsubscribe();
+            doc.off('updateV2', onUpdate);
+            doc.off('destroy', stopObserving);
+        };
+        doc.on('updateV2', onUpdate);
+        doc.on('destroy', stopObserving);
+        return stopObserving;
+    }
+
+    var wm = new WeakMap();
+    function createEvents() {
+        return Events(null, 'load', 'sync', 'error');
+    }
+    var DexieYProvider =  (function () {
+        function DexieYProvider(doc) {
+            var _this = this;
+            this.refCount = 1;
+            this.cleanupHandlers = [];
+            this.destroyed = false;
+            this.on = createEvents();
+            this.doc = doc;
+            this.off = function (name, f) { var _a; return (_a = _this.on[name]) === null || _a === void 0 ? void 0 : _a.unsubscribe(f); };
+            this.whenLoaded = new Promise(function (resolve, reject) {
+                _this.on('load', resolve);
+                _this.on('error', reject);
+            });
+            this.whenSynced = new Promise(function (resolve, reject) {
+                _this.on('sync', resolve);
+                _this.on('error', reject);
+            });
+            if ('dispose' in Symbol) {
+                this[Symbol.dispose] =
+                    function () { return DexieYProvider.release(doc); };
+            }
+            doc.on('load', function () { return _this.on('load').fire(); });
+            doc.on('sync', function (sync) { return sync !== false && _this.on('sync').fire(); });
+            doc.on('destroy', this.destroy.bind(this));
+            var _a = doc.meta || {}, db = _a.db, parentTable = _a.parentTable, parentId = _a.parentId, updatesTable = _a.updatesTable;
+            if (db && parentTable && updatesTable) {
+                if (!db.table(parentTable) || !db.table(updatesTable)) {
+                    throw new Error("Table ".concat(parentTable, " or ").concat(updatesTable, " not found in db"));
+                }
+                throwIfDestroyed(doc);
+                var Y = getYLibrary(db);
+                this.stopObserving = observeYDocUpdates(this, doc, db, parentTable, updatesTable, parentId, Y);
+                db.on.y.fire(this, Y);
+            }
+        }
+        DexieYProvider.load = function (doc) {
+            var p = wm.get(doc);
+            if (p) {
+                ++p.refCount;
+            }
+            else {
+                p = new DexieYProvider(doc);
+                wm.set(doc, p);
+            }
+            return p;
+        };
+        DexieYProvider.release = function (doc, options) {
+            if (destroyedDocs.has(doc))
+                return;
+            var p = wm.get(doc);
+            if (p) {
+                if (--p.refCount <= 0) {
+                    if (isNaN(options === null || options === void 0 ? void 0 : options.gracePeriod)) {
+                        doc.destroy();
+                    }
+                    else {
+                        setTimeout(function () { return p.refCount || doc.destroy(); },
+                        options.gracePeriod
+                        );
+                    }
+                }
+            }
+            else {
+                doc.destroy();
+            }
+        };
+        DexieYProvider.for = function (doc) {
+            return wm.get(doc);
+        };
+        DexieYProvider.prototype.destroy = function () {
+            var _a;
+            wm.delete(this.doc);
+            this.doc = null;
+            this.destroyed = true;
+            this.refCount = 0;
+            (_a = this.stopObserving) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.on = createEvents();
+            this.cleanupHandlers.forEach(function (cleanup) { return cleanup(); });
+        };
+        DexieYProvider.prototype.addCleanupHandler = function (cleanupHandler) {
+            this.cleanupHandlers.push(typeof cleanupHandler === 'function'
+                ? cleanupHandler
+                : function () { return cleanupHandler.unsubscribe(); });
+        };
+        DexieYProvider.getDocCache = getDocCache;
+        DexieYProvider.currentUpdateRow = null;
+        return DexieYProvider;
+    }());
+
     DexiePromise.rejectionMapper = mapError;
     setDebug(debug);
 
@@ -5891,7 +6659,8 @@
         'default': Dexie$1,
         RangeSet: RangeSet,
         mergeRanges: mergeRanges,
-        rangesOverlap: rangesOverlap
+        rangesOverlap: rangesOverlap,
+        DexieYProvider: DexieYProvider
     });
 
     __assign(Dexie$1, namedExports, { default: Dexie$1 });