dexie 4.0.8 → 4.1.0-alpha.2

package/dist/dexie.mjs

@@ -4,7 +4,7 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 4.0.8, Wed Jul 10 2024
+ * Version 4.1.0-alpha.2, Fri Oct 04 2024
  *
  * https://dexie.org
  *
@@ -46,6 +46,33 @@ var __assign = function() {
     };
     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)) {
@@ -1144,7 +1171,7 @@ function tempTransaction(db, mode, storeNames, fn) {
     }
 }
 
-var DEXIE_VERSION = '4.0.8';
+var DEXIE_VERSION = '4.1.0-alpha.2';
 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>.";
@@ -1262,6 +1289,95 @@ function getUint8Array(a) {
     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 {
+        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() {
     }
@@ -1341,8 +1457,8 @@ var Table =  (function () {
         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 [
@@ -1355,7 +1471,7 @@ var Table =  (function () {
                         } : 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) :
@@ -1393,6 +1509,7 @@ var Table =  (function () {
         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) {
@@ -1410,6 +1527,20 @@ var Table =  (function () {
                 return class_1;
             }(constructor));
         }
+        if (this.schema.yProps) {
+            var Y_1 = getYLibrary(db);
+            constructor =  (function (_super) {
+                __extends(class_2, _super);
+                function class_2() {
+                    return _super !== null && _super.apply(this, arguments) || this;
+                }
+                return class_2;
+            }(constructor));
+            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); });
@@ -1491,12 +1622,14 @@ var Table =  (function () {
     };
     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) {
@@ -1569,20 +1702,30 @@ var Table =  (function () {
                 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);
@@ -1602,17 +1745,27 @@ var Table =  (function () {
                     }
                 })
                     .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);
                 });
@@ -1623,7 +1776,8 @@ var Table =  (function () {
         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)
@@ -1807,7 +1961,7 @@ var PropModification =  (function () {
         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;
@@ -2140,52 +2294,65 @@ var Collection =  (function () {
             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) {
@@ -2203,14 +2370,15 @@ var Collection =  (function () {
                                 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);
                         });
                     });
@@ -2226,6 +2394,7 @@ var Collection =  (function () {
     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) {
@@ -2234,7 +2403,7 @@ var Collection =  (function () {
                 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;
@@ -2836,6 +3005,13 @@ var Transaction =  (function () {
 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;
@@ -2871,7 +3047,7 @@ function createTransactionConstructor(db) {
     });
 }
 
-function createIndexSpec(name, keyPath, unique, multi, auto, compound, isPrimKey) {
+function createIndexSpec(name, keyPath, unique, multi, auto, compound, isPrimKey, type) {
     return {
         name: name,
         keyPath: keyPath,
@@ -2879,7 +3055,8 @@ function createIndexSpec(name, keyPath, unique, multi, auto, compound, isPrimKey
         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) {
@@ -2888,13 +3065,17 @@ function nameFromKeyPath(keyPath) {
         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]; }),
     };
 }
 
@@ -3047,11 +3228,11 @@ function createDBCore(db, IdbKeyRange, tmpTrans) {
                         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 ?
@@ -3376,6 +3557,7 @@ function runUpgraders(db, oldVersion, idbUpgradeTrans, reject) {
     });
 }
 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');
@@ -3395,11 +3577,20 @@ function patchCurrentVersion(db, idbUpgradeTrans) {
             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) {
@@ -3638,10 +3829,15 @@ function adjustToExistingIndexNames(db, schema, idbtrans) {
 }
 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);
     });
 }
 
@@ -3649,40 +3845,66 @@ 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);
+            }
+        });
         return this;
     };
     Version.prototype.upgrade = function (upgradeFunction) {
@@ -3961,19 +4183,29 @@ function signalSubscribersLazily(part, optimistic) {
     }
 }
 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);
@@ -3983,26 +4215,54 @@ function signalSubscribersNow(updatedParts, deleteAffectedCacheEntries) {
     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; }
         }
     }
 }
@@ -4253,6 +4513,7 @@ function pad(a, value, count) {
 }
 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 = {};
@@ -4280,9 +4541,18 @@ function createVirtualIndexMiddleware(down) {
             }
             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)];
@@ -4442,9 +4712,9 @@ var hooksMiddleware = {
                             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];
@@ -4633,13 +4903,13 @@ var observabilityMiddleware = {
                         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);
@@ -4708,7 +4978,7 @@ var observabilityMiddleware = {
                             };
                             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);
                             }
@@ -5032,60 +5302,106 @@ var cacheMiddleware = {
                     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(); });
                         }
                     }; };
@@ -5155,7 +5471,7 @@ var cacheMiddleware = {
                             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;
                         }
@@ -5229,6 +5545,169 @@ function vipify(target, vipDb) {
     });
 }
 
+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 <= 1)
+                return;
+            var docsToCompress = [];
+            var lastUpdateToCompress = lastCompressedUpdate + 1;
+            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;
+            }
+            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) {
+                        return updTbl.put(__assign(__assign({}, current), { lastCompressed: Math.max(lastUpdateToCompress, (current === null || current === void 0 ? void 0 : current.lastCompressed) || 0) }));
+                    });
+                });
+            });
+        });
+    });
+}
+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);
+            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 INTERVAL = 10000;
+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, INTERVAL).catch(function (err) {
+                    console.debug('Error during periodic GC', err);
+                }).then(function () {
+                    timer = setTimeout(gc_1, INTERVAL);
+                });
+            };
+            timer = setTimeout(gc_1, INTERVAL);
+        }
+    }, true);
+    db.on('close', function () {
+        if (timer)
+            clearTimeout(timer);
+        timer = null;
+    });
+}
+
 var Dexie$1 =  (function () {
     function Dexie(name, options) {
         var _this = this;
@@ -5270,7 +5749,18 @@ var Dexie$1 =  (function () {
         });
         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 () {
@@ -5349,6 +5839,8 @@ var Dexie$1 =  (function () {
             }
         });
         this.vip = vipDB;
+        if (options === null || options === void 0 ? void 0 : options.Y)
+            periodicGC(this);
         addons.forEach(function (addon) { return addon(_this); });
     }
     Dexie.prototype.version = function (versionNumber) {
@@ -5411,6 +5903,7 @@ var Dexie$1 =  (function () {
         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)
@@ -5568,6 +6061,9 @@ var Dexie$1 =  (function () {
         }
         return this._allTables[tableName];
     };
+    Dexie.prototype.gc = function () {
+        return compressYDocs(this);
+    };
     return Dexie;
 }());
 
@@ -5868,8 +6364,176 @@ function replacePrefix(a, b) {
     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) {
+                if (updates.length > 0)
+                    lastUpdateId = updates[updates.length - 1].i;
+                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 (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;
+        var _a = (doc || {}).meta, db = _a.db, parentTable = _a.parentTable, parentId = _a.parentId, updatesTable = _a.updatesTable;
+        if (!db || !parentTable || !updatesTable)
+            throw new Error('Y.Doc not generated by Dexie');
+        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.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] = this.dispose;
+        }
+        this.stopObserving = observeYDocUpdates(this, doc, db, parentTable, updatesTable, parentId, Y);
+        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));
+        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);
 
-export { Dexie$1 as Dexie, Entity, PropModSymbol, PropModification, RangeSet, add, cmp, Dexie$1 as default, liveQuery, mergeRanges, rangesOverlap, remove, replacePrefix };
+export { Dexie$1 as Dexie, DexieYProvider, Entity, PropModSymbol, PropModification, RangeSet, add, cmp, Dexie$1 as default, liveQuery, mergeRanges, rangesOverlap, remove, replacePrefix };
 //# sourceMappingURL=dexie.mjs.map