@luvio/environments 0.106.0 → 0.108.0

package/dist/es/es2018/environments.js

@@ -419,6 +419,7 @@ function isUnfulfilledSnapshot(cachedSnapshotResult) {
 function makeDurable(environment, { durableStore, instrumentation }) {
     let ingestStagingStore = null;
     const durableTTLStore = new DurableTTLStore(durableStore);
+    const mergeKeysPromiseMap = new Map();
     let initializationPromise = new Promise((resolve) => {
         const finish = () => {
             resolve();
@@ -677,52 +678,84 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         }
         return {};
     };
-    const handleSuccessResponse = function (ingestAndBroadcastFunc, getResponseCacheKeysFunc, existingRecords) {
+    const handleSuccessResponse = async function (ingestAndBroadcastFunc, getResponseCacheKeysFunc) {
         validateNotDisposed();
         const cacheKeySet = getResponseCacheKeysFunc();
-        const cacheKeys = new Set(keys(cacheKeySet));
+        const cacheKeySetKeys = keys(cacheKeySet);
         const keysToRevive = {};
-        cacheKeys.forEach((cacheKey) => {
-            const key = cacheKeySet[cacheKey];
-            if (key.mergeable === true &&
-                (existingRecords === undefined || existingRecords[cacheKey] === undefined)) {
-                keysToRevive[cacheKey] = true;
+        for (const cacheKeySetKey of cacheKeySetKeys) {
+            const cacheKey = cacheKeySet[cacheKeySetKey];
+            if (cacheKey.mergeable === true) {
+                keysToRevive[cacheKeySetKey] = true;
             }
-        });
-        const ingestAndPublish = (revivedRecords) => {
-            const toPrime = existingRecords !== undefined
-                ? { ...revivedRecords, ...existingRecords }
-                : revivedRecords;
-            ingestStagingStore = buildIngestStagingStore(environment);
-            ingestStagingStore.records = toPrime;
-            const snapshotFromMemoryIngest = ingestAndBroadcastFunc();
-            return publishChangesToDurableStore().then(() => {
-                if (snapshotFromMemoryIngest === undefined) {
-                    return undefined;
+        }
+        let snapshotFromMemoryIngest = undefined;
+        const keysAsArray = keys(keysToRevive);
+        if (keysAsArray.length > 0) {
+            // if we need to do an L2 read then L2 write then we need to synchronize
+            // our read/merge/ingest/write Promise based on the keys so we don't
+            // stomp over any data
+            const readWritePromise = (async () => {
+                const pendingPromises = [];
+                for (const key of keysAsArray) {
+                    const pendingPromise = mergeKeysPromiseMap.get(key);
+                    if (pendingPromise !== undefined) {
+                        // IMPORTANT: while on the synchronous code path we get a
+                        // handle to pendingPromise and push it onto the array.
+                        // This is important because later in this synchronous code
+                        // path we will upsert readWritePromise into the
+                        // mergeKeysPromiseMap (essentially overwriting pendingPromise
+                        // in the map).
+                        pendingPromises.push(pendingPromise);
+                    }
                 }
-                if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
-                    return snapshotFromMemoryIngest;
+                await Promise.all(pendingPromises);
+                const entries = await durableStore.getEntries(keysAsArray, DefaultDurableSegment);
+                ingestStagingStore = buildIngestStagingStore(environment);
+                publishDurableStoreEntries(entries, ingestStagingStore.publish.bind(ingestStagingStore), 
+                // we don't need to prime metadata
+                () => { });
+                snapshotFromMemoryIngest = ingestAndBroadcastFunc();
+                await publishChangesToDurableStore();
+            })();
+            for (const key of keysAsArray) {
+                // we are overwriting the previous promise at this key, but that
+                // is ok because we got a handle to it earlier (see the IMPORTANT
+                // comment about 35 lines up)
+                mergeKeysPromiseMap.set(key, readWritePromise);
+            }
+            try {
+                await readWritePromise;
+            }
+            finally {
+                for (const key of keysAsArray) {
+                    const pendingPromise = mergeKeysPromiseMap.get(key);
+                    // cleanup the entry from the map if this is the last promise
+                    // for that key
+                    if (pendingPromise === readWritePromise) {
+                        mergeKeysPromiseMap.delete(key);
+                    }
                 }
-                // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
-                return reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(snapshotFromMemoryIngest.select, environment.createSnapshot, snapshotFromMemoryIngest.refresh)).then((result) => {
-                    return result.snapshot;
-                });
-            });
-        };
-        if (keys(keysToRevive).length === 0) {
-            return ingestAndPublish({});
+            }
         }
-        return durableStore
-            .getEntries(keys(keysToRevive), DefaultDurableSegment)
-            .then((entries) => {
-            const existingL2Records = create(null);
-            publishDurableStoreEntries(entries, (key, record) => {
-                existingL2Records[key] = record;
-            }, 
-            // we don't need to prime metadata
-            () => { });
-            return ingestAndPublish(existingL2Records);
-        });
+        else {
+            // we aren't doing any merging so we don't have to synchronize, the
+            // underlying DurableStore implementation takes care of R/W sync
+            // so all we have to do is ingest then write to L2
+            ingestStagingStore = buildIngestStagingStore(environment);
+            snapshotFromMemoryIngest = ingestAndBroadcastFunc();
+            await publishChangesToDurableStore();
+        }
+        if (snapshotFromMemoryIngest === undefined) {
+            return undefined;
+        }
+        if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
+            return snapshotFromMemoryIngest;
+        }
+        // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
+        const { select, refresh } = snapshotFromMemoryIngest;
+        const result = await reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(select, environment.createSnapshot, refresh));
+        return result.snapshot;
     };
     const handleErrorResponse = function (ingestAndBroadcastFunc) {
         validateNotDisposed();

package/dist/es/es2018/makeDurable.d.ts

@@ -1,4 +1,4 @@
-import type { CacheKeySet, Environment, RecordSource, Snapshot, InMemoryStore } from '@luvio/engine';
+import type { Environment, RecordSource, InMemoryStore } from '@luvio/engine';
 import type { DurableStore } from './DurableStore';
 import type { InstrumentationFunction } from './makeDurable/error';
 import type { TTLOverridesMap } from './DurableTTLStore';
@@ -25,12 +25,6 @@ export interface DurableEnvironment extends Environment {
      * flow, otherwise returns an empty object.
      */
     getIngestStagingStoreMetadata(): InMemoryStore['metadata'];
-    /**
-     * Overload of Environment.handleSuccessResponse that takes in an optional
-     * RecordSource to "prime" the ingest staging store with before calling
-     * ingest. Useful for merge-able record types
-     */
-    handleSuccessResponse<IngestionReturnType extends Snapshot<D, V> | undefined, D, V = unknown>(ingestAndBroadcastFunc: () => IngestionReturnType, getResponseCacheKeysFunc: () => CacheKeySet, existingRecords?: RecordSource): IngestionReturnType | Promise<IngestionReturnType>;
 }
 export declare const AdapterContextSegment = "ADAPTER-CONTEXT";
 export declare const ADAPTER_CONTEXT_ID_SUFFIX = "__NAMED_CONTEXT";

package/dist/umd/es2018/environments.js

@@ -423,6 +423,7 @@
     function makeDurable(environment, { durableStore, instrumentation }) {
         let ingestStagingStore = null;
         const durableTTLStore = new DurableTTLStore(durableStore);
+        const mergeKeysPromiseMap = new Map();
         let initializationPromise = new Promise((resolve) => {
             const finish = () => {
                 resolve();
@@ -681,52 +682,84 @@
             }
             return {};
         };
-        const handleSuccessResponse = function (ingestAndBroadcastFunc, getResponseCacheKeysFunc, existingRecords) {
+        const handleSuccessResponse = async function (ingestAndBroadcastFunc, getResponseCacheKeysFunc) {
             validateNotDisposed();
             const cacheKeySet = getResponseCacheKeysFunc();
-            const cacheKeys = new Set(keys(cacheKeySet));
+            const cacheKeySetKeys = keys(cacheKeySet);
             const keysToRevive = {};
-            cacheKeys.forEach((cacheKey) => {
-                const key = cacheKeySet[cacheKey];
-                if (key.mergeable === true &&
-                    (existingRecords === undefined || existingRecords[cacheKey] === undefined)) {
-                    keysToRevive[cacheKey] = true;
+            for (const cacheKeySetKey of cacheKeySetKeys) {
+                const cacheKey = cacheKeySet[cacheKeySetKey];
+                if (cacheKey.mergeable === true) {
+                    keysToRevive[cacheKeySetKey] = true;
                 }
-            });
-            const ingestAndPublish = (revivedRecords) => {
-                const toPrime = existingRecords !== undefined
-                    ? { ...revivedRecords, ...existingRecords }
-                    : revivedRecords;
-                ingestStagingStore = buildIngestStagingStore(environment);
-                ingestStagingStore.records = toPrime;
-                const snapshotFromMemoryIngest = ingestAndBroadcastFunc();
-                return publishChangesToDurableStore().then(() => {
-                    if (snapshotFromMemoryIngest === undefined) {
-                        return undefined;
+            }
+            let snapshotFromMemoryIngest = undefined;
+            const keysAsArray = keys(keysToRevive);
+            if (keysAsArray.length > 0) {
+                // if we need to do an L2 read then L2 write then we need to synchronize
+                // our read/merge/ingest/write Promise based on the keys so we don't
+                // stomp over any data
+                const readWritePromise = (async () => {
+                    const pendingPromises = [];
+                    for (const key of keysAsArray) {
+                        const pendingPromise = mergeKeysPromiseMap.get(key);
+                        if (pendingPromise !== undefined) {
+                            // IMPORTANT: while on the synchronous code path we get a
+                            // handle to pendingPromise and push it onto the array.
+                            // This is important because later in this synchronous code
+                            // path we will upsert readWritePromise into the
+                            // mergeKeysPromiseMap (essentially overwriting pendingPromise
+                            // in the map).
+                            pendingPromises.push(pendingPromise);
+                        }
                     }
-                    if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
-                        return snapshotFromMemoryIngest;
+                    await Promise.all(pendingPromises);
+                    const entries = await durableStore.getEntries(keysAsArray, DefaultDurableSegment);
+                    ingestStagingStore = buildIngestStagingStore(environment);
+                    publishDurableStoreEntries(entries, ingestStagingStore.publish.bind(ingestStagingStore), 
+                    // we don't need to prime metadata
+                    () => { });
+                    snapshotFromMemoryIngest = ingestAndBroadcastFunc();
+                    await publishChangesToDurableStore();
+                })();
+                for (const key of keysAsArray) {
+                    // we are overwriting the previous promise at this key, but that
+                    // is ok because we got a handle to it earlier (see the IMPORTANT
+                    // comment about 35 lines up)
+                    mergeKeysPromiseMap.set(key, readWritePromise);
+                }
+                try {
+                    await readWritePromise;
+                }
+                finally {
+                    for (const key of keysAsArray) {
+                        const pendingPromise = mergeKeysPromiseMap.get(key);
+                        // cleanup the entry from the map if this is the last promise
+                        // for that key
+                        if (pendingPromise === readWritePromise) {
+                            mergeKeysPromiseMap.delete(key);
+                        }
                     }
-                    // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
-                    return reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(snapshotFromMemoryIngest.select, environment.createSnapshot, snapshotFromMemoryIngest.refresh)).then((result) => {
-                        return result.snapshot;
-                    });
-                });
-            };
-            if (keys(keysToRevive).length === 0) {
-                return ingestAndPublish({});
+                }
             }
-            return durableStore
-                .getEntries(keys(keysToRevive), DefaultDurableSegment)
-                .then((entries) => {
-                const existingL2Records = create(null);
-                publishDurableStoreEntries(entries, (key, record) => {
-                    existingL2Records[key] = record;
-                }, 
-                // we don't need to prime metadata
-                () => { });
-                return ingestAndPublish(existingL2Records);
-            });
+            else {
+                // we aren't doing any merging so we don't have to synchronize, the
+                // underlying DurableStore implementation takes care of R/W sync
+                // so all we have to do is ingest then write to L2
+                ingestStagingStore = buildIngestStagingStore(environment);
+                snapshotFromMemoryIngest = ingestAndBroadcastFunc();
+                await publishChangesToDurableStore();
+            }
+            if (snapshotFromMemoryIngest === undefined) {
+                return undefined;
+            }
+            if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
+                return snapshotFromMemoryIngest;
+            }
+            // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
+            const { select, refresh } = snapshotFromMemoryIngest;
+            const result = await reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(select, environment.createSnapshot, refresh));
+            return result.snapshot;
         };
         const handleErrorResponse = function (ingestAndBroadcastFunc) {
             validateNotDisposed();

package/dist/umd/es2018/makeDurable.d.ts

@@ -1,4 +1,4 @@
-import type { CacheKeySet, Environment, RecordSource, Snapshot, InMemoryStore } from '@luvio/engine';
+import type { Environment, RecordSource, InMemoryStore } from '@luvio/engine';
 import type { DurableStore } from './DurableStore';
 import type { InstrumentationFunction } from './makeDurable/error';
 import type { TTLOverridesMap } from './DurableTTLStore';
@@ -25,12 +25,6 @@ export interface DurableEnvironment extends Environment {
      * flow, otherwise returns an empty object.
      */
     getIngestStagingStoreMetadata(): InMemoryStore['metadata'];
-    /**
-     * Overload of Environment.handleSuccessResponse that takes in an optional
-     * RecordSource to "prime" the ingest staging store with before calling
-     * ingest. Useful for merge-able record types
-     */
-    handleSuccessResponse<IngestionReturnType extends Snapshot<D, V> | undefined, D, V = unknown>(ingestAndBroadcastFunc: () => IngestionReturnType, getResponseCacheKeysFunc: () => CacheKeySet, existingRecords?: RecordSource): IngestionReturnType | Promise<IngestionReturnType>;
 }
 export declare const AdapterContextSegment = "ADAPTER-CONTEXT";
 export declare const ADAPTER_CONTEXT_ID_SUFFIX = "__NAMED_CONTEXT";

package/dist/umd/es5/environments.js

@@ -516,6 +516,7 @@
         var durableStore = _a.durableStore, instrumentation = _a.instrumentation;
         var ingestStagingStore = null;
         var durableTTLStore = new DurableTTLStore(durableStore);
+        var mergeKeysPromiseMap = new Map();
         var initializationPromise = new Promise(function (resolve) {
             var finish = function () {
                 resolve();
@@ -779,52 +780,114 @@
             }
             return {};
         };
-        var handleSuccessResponse = function (ingestAndBroadcastFunc, getResponseCacheKeysFunc, existingRecords) {
-            validateNotDisposed();
-            var cacheKeySet = getResponseCacheKeysFunc();
-            var cacheKeys = new Set(keys(cacheKeySet));
-            var keysToRevive = {};
-            cacheKeys.forEach(function (cacheKey) {
-                var key = cacheKeySet[cacheKey];
-                if (key.mergeable === true &&
-                    (existingRecords === undefined || existingRecords[cacheKey] === undefined)) {
-                    keysToRevive[cacheKey] = true;
-                }
-            });
-            var ingestAndPublish = function (revivedRecords) {
-                var toPrime = existingRecords !== undefined
-                    ? __assign(__assign({}, revivedRecords), existingRecords) : revivedRecords;
-                ingestStagingStore = buildIngestStagingStore(environment);
-                ingestStagingStore.records = toPrime;
-                var snapshotFromMemoryIngest = ingestAndBroadcastFunc();
-                return publishChangesToDurableStore().then(function () {
-                    if (snapshotFromMemoryIngest === undefined) {
-                        return undefined;
-                    }
-                    if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
-                        return snapshotFromMemoryIngest;
+        var handleSuccessResponse = function (ingestAndBroadcastFunc, getResponseCacheKeysFunc) {
+            return __awaiter(this, void 0, void 0, function () {
+                var cacheKeySet, cacheKeySetKeys, keysToRevive, _i, cacheKeySetKeys_1, cacheKeySetKey, cacheKey, snapshotFromMemoryIngest, keysAsArray, readWritePromise, _a, keysAsArray_1, key, _b, keysAsArray_2, key, pendingPromise, _c, select, refresh, result;
+                var _this = this;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            validateNotDisposed();
+                            cacheKeySet = getResponseCacheKeysFunc();
+                            cacheKeySetKeys = keys(cacheKeySet);
+                            keysToRevive = {};
+                            for (_i = 0, cacheKeySetKeys_1 = cacheKeySetKeys; _i < cacheKeySetKeys_1.length; _i++) {
+                                cacheKeySetKey = cacheKeySetKeys_1[_i];
+                                cacheKey = cacheKeySet[cacheKeySetKey];
+                                if (cacheKey.mergeable === true) {
+                                    keysToRevive[cacheKeySetKey] = true;
+                                }
+                            }
+                            snapshotFromMemoryIngest = undefined;
+                            keysAsArray = keys(keysToRevive);
+                            if (!(keysAsArray.length > 0)) return [3 /*break*/, 5];
+                            readWritePromise = (function () { return __awaiter(_this, void 0, void 0, function () {
+                                var pendingPromises, _i, keysAsArray_3, key, pendingPromise, entries;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            pendingPromises = [];
+                                            for (_i = 0, keysAsArray_3 = keysAsArray; _i < keysAsArray_3.length; _i++) {
+                                                key = keysAsArray_3[_i];
+                                                pendingPromise = mergeKeysPromiseMap.get(key);
+                                                if (pendingPromise !== undefined) {
+                                                    // IMPORTANT: while on the synchronous code path we get a
+                                                    // handle to pendingPromise and push it onto the array.
+                                                    // This is important because later in this synchronous code
+                                                    // path we will upsert readWritePromise into the
+                                                    // mergeKeysPromiseMap (essentially overwriting pendingPromise
+                                                    // in the map).
+                                                    pendingPromises.push(pendingPromise);
+                                                }
+                                            }
+                                            return [4 /*yield*/, Promise.all(pendingPromises)];
+                                        case 1:
+                                            _a.sent();
+                                            return [4 /*yield*/, durableStore.getEntries(keysAsArray, DefaultDurableSegment)];
+                                        case 2:
+                                            entries = _a.sent();
+                                            ingestStagingStore = buildIngestStagingStore(environment);
+                                            publishDurableStoreEntries(entries, ingestStagingStore.publish.bind(ingestStagingStore), 
+                                            // we don't need to prime metadata
+                                            function () { });
+                                            snapshotFromMemoryIngest = ingestAndBroadcastFunc();
+                                            return [4 /*yield*/, publishChangesToDurableStore()];
+                                        case 3:
+                                            _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); })();
+                            for (_a = 0, keysAsArray_1 = keysAsArray; _a < keysAsArray_1.length; _a++) {
+                                key = keysAsArray_1[_a];
+                                // we are overwriting the previous promise at this key, but that
+                                // is ok because we got a handle to it earlier (see the IMPORTANT
+                                // comment about 35 lines up)
+                                mergeKeysPromiseMap.set(key, readWritePromise);
+                            }
+                            _d.label = 1;
+                        case 1:
+                            _d.trys.push([1, , 3, 4]);
+                            return [4 /*yield*/, readWritePromise];
+                        case 2:
+                            _d.sent();
+                            return [3 /*break*/, 4];
+                        case 3:
+                            for (_b = 0, keysAsArray_2 = keysAsArray; _b < keysAsArray_2.length; _b++) {
+                                key = keysAsArray_2[_b];
+                                pendingPromise = mergeKeysPromiseMap.get(key);
+                                // cleanup the entry from the map if this is the last promise
+                                // for that key
+                                if (pendingPromise === readWritePromise) {
+                                    mergeKeysPromiseMap.delete(key);
+                                }
+                            }
+                            return [7 /*endfinally*/];
+                        case 4: return [3 /*break*/, 7];
+                        case 5:
+                            // we aren't doing any merging so we don't have to synchronize, the
+                            // underlying DurableStore implementation takes care of R/W sync
+                            // so all we have to do is ingest then write to L2
+                            ingestStagingStore = buildIngestStagingStore(environment);
+                            snapshotFromMemoryIngest = ingestAndBroadcastFunc();
+                            return [4 /*yield*/, publishChangesToDurableStore()];
+                        case 6:
+                            _d.sent();
+                            _d.label = 7;
+                        case 7:
+                            if (snapshotFromMemoryIngest === undefined) {
+                                return [2 /*return*/, undefined];
+                            }
+                            if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
+                                return [2 /*return*/, snapshotFromMemoryIngest];
+                            }
+                            _c = snapshotFromMemoryIngest, select = _c.select, refresh = _c.refresh;
+                            return [4 /*yield*/, reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, function () { return environment.storeLookup(select, environment.createSnapshot, refresh); })];
+                        case 8:
+                            result = _d.sent();
+                            return [2 /*return*/, result.snapshot];
                     }
-                    // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
-                    return reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, function () {
-                        return environment.storeLookup(snapshotFromMemoryIngest.select, environment.createSnapshot, snapshotFromMemoryIngest.refresh);
-                    }).then(function (result) {
-                        return result.snapshot;
-                    });
                 });
-            };
-            if (keys(keysToRevive).length === 0) {
-                return ingestAndPublish({});
-            }
-            return durableStore
-                .getEntries(keys(keysToRevive), DefaultDurableSegment)
-                .then(function (entries) {
-                var existingL2Records = create(null);
-                publishDurableStoreEntries(entries, function (key, record) {
-                    existingL2Records[key] = record;
-                }, 
-                // we don't need to prime metadata
-                function () { });
-                return ingestAndPublish(existingL2Records);
             });
         };
         var handleErrorResponse = function (ingestAndBroadcastFunc) {

package/dist/umd/es5/makeDurable.d.ts

@@ -1,4 +1,4 @@
-import type { CacheKeySet, Environment, RecordSource, Snapshot, InMemoryStore } from '@luvio/engine';
+import type { Environment, RecordSource, InMemoryStore } from '@luvio/engine';
 import type { DurableStore } from './DurableStore';
 import type { InstrumentationFunction } from './makeDurable/error';
 import type { TTLOverridesMap } from './DurableTTLStore';
@@ -25,12 +25,6 @@ export interface DurableEnvironment extends Environment {
      * flow, otherwise returns an empty object.
      */
     getIngestStagingStoreMetadata(): InMemoryStore['metadata'];
-    /**
-     * Overload of Environment.handleSuccessResponse that takes in an optional
-     * RecordSource to "prime" the ingest staging store with before calling
-     * ingest. Useful for merge-able record types
-     */
-    handleSuccessResponse<IngestionReturnType extends Snapshot<D, V> | undefined, D, V = unknown>(ingestAndBroadcastFunc: () => IngestionReturnType, getResponseCacheKeysFunc: () => CacheKeySet, existingRecords?: RecordSource): IngestionReturnType | Promise<IngestionReturnType>;
 }
 export declare const AdapterContextSegment = "ADAPTER-CONTEXT";
 export declare const ADAPTER_CONTEXT_ID_SUFFIX = "__NAMED_CONTEXT";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luvio/environments",
-    "version": "0.106.0",
+    "version": "0.108.0",
     "description": "Luvio Environments",
     "repository": {
         "type": "git",
@@ -23,7 +23,7 @@
         "watch": "yarn build --watch"
     },
     "dependencies": {
-        "@luvio/engine": "0.106.0"
+        "@luvio/engine": "0.108.0"
     },
     "bundlesize": [
         {