@luvio/environments 0.134.2 → 0.135.1

package/dist/es/es2018/environments.js

@@ -1,4 +1,4 @@
-import { emitAdapterEvent, StoreKeyMap, buildStaleWhileRevalidateImplementation, Reader, StoreKeySet } from '@luvio/engine';
+import { StoreKeySet, serializeStructuredKey, emitAdapterEvent, StoreKeyMap, buildStaleWhileRevalidateImplementation, Reader } from '@luvio/engine';
 
 // the last version the metadata shape was altered
 const DURABLE_METADATA_VERSION = '0.111.0';
@@ -81,7 +81,7 @@ function isStoreEntryError(storeRecord) {
  * @returns
  */
 function publishDurableStoreEntries(durableRecords, publish, publishMetadata) {
-    const revivedKeys = create(null);
+    const revivedKeys = new StoreKeySet();
     let hadUnexpectedShape = false;
     if (durableRecords === undefined) {
         return { revivedKeys, hadUnexpectedShape };
@@ -119,7 +119,7 @@ function publishDurableStoreEntries(durableRecords, publish, publishMetadata) {
             deepFreeze(data.error);
         }
         publish(key, data);
-        revivedKeys[key] = true;
+        revivedKeys.add(key);
     }
     return { revivedKeys, hadUnexpectedShape };
 }
@@ -143,9 +143,10 @@ unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics =
     }
     // in case L1 store changes/deallocs a record while we are doing the async read
     // we attempt to read all keys from L2 - so combine recordId with any seenRecords
-    const keysToReviveSet = assign({ [recordId]: true }, seenRecords);
-    const keysToRevive = keys(keysToReviveSet);
-    const canonicalKeys = keysToRevive.map((x) => baseEnvironment.storeGetCanonicalKey(x));
+    const keysToReviveSet = new StoreKeySet().add(recordId);
+    keysToReviveSet.merge(seenRecords);
+    const keysToRevive = keysToReviveSet.keysAsArray();
+    const canonicalKeys = keysToRevive.map((x) => serializeStructuredKey(baseEnvironment.storeGetCanonicalKey(x)));
     const start = Date.now();
     const { l2Trips } = reviveMetrics;
     return durableStore.getEntries(canonicalKeys, DefaultDurableSegment).then((durableRecords) => {
@@ -163,7 +164,7 @@ unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics =
         if (hadUnexpectedShape === true) {
             return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
         }
-        if (keys(revivedKeys).length === 0) {
+        if (revivedKeys.size() === 0) {
             // durable store doesn't have what we asked for so return L1 snapshot
             return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
         }
@@ -178,16 +179,19 @@ unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics =
             // have to check if the new snapshot has any additional seenRecords
             // and revive again if so
             const { seenRecords: newSnapshotSeenRecords, recordId: newSnapshotRecordId } = snapshot;
-            const newKeysToReviveSet = assign({ [newSnapshotRecordId]: true }, newSnapshotSeenRecords);
-            const newKeys = keys(newKeysToReviveSet);
+            const newKeysToReviveSet = new StoreKeySet();
+            newKeysToReviveSet.add(newSnapshotRecordId);
+            newKeysToReviveSet.merge(newSnapshotSeenRecords);
+            const newKeys = newKeysToReviveSet.keysAsArray();
             // in case DS returned additional entries we combine the requested
             // and returned keys
-            const alreadyRequestedOrRevivedSet = assign(keysToReviveSet, revivedKeys);
+            const alreadyRequestedOrRevivedSet = keysToReviveSet;
+            alreadyRequestedOrRevivedSet.merge(revivedKeys);
             // if there's any seen keys in the newly rebuilt snapshot that
             // haven't already been requested or returned then revive again
             for (let i = 0, len = newKeys.length; i < len; i++) {
                 const newSnapshotSeenKey = newKeys[i];
-                if (alreadyRequestedOrRevivedSet[newSnapshotSeenKey] !== true) {
+                if (!alreadyRequestedOrRevivedSet.has(newSnapshotSeenKey)) {
                     return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics);
                 }
             }
@@ -737,7 +741,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     const handleSuccessResponse = async function (ingestAndBroadcastFunc, getResponseCacheKeysFunc) {
         validateNotDisposed();
         const cacheKeyMap = getResponseCacheKeysFunc();
-        const cacheKeyMapKeys = Array.from(cacheKeyMap.keys());
+        const cacheKeyMapKeys = cacheKeyMap.keysAsArray();
         const keysToRevive = new StoreKeySet();
         for (const cacheKeyMapKey of cacheKeyMapKeys) {
             const cacheKey = cacheKeyMap.get(cacheKeyMapKey);
@@ -746,7 +750,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             }
         }
         let snapshotFromMemoryIngest = undefined;
-        // Once these are structured keys, we will call the serializeStructuredKey() utility method
+        // To-do: Once these are structured keys, will need to support them throughout durable logic W-12356727
         const keysToReviveAsArray = Array.from(keysToRevive.keysAsStrings());
         if (keysToReviveAsArray.length > 0) {
             // if we need to do an L2 read then L2 write then we need to synchronize
@@ -770,7 +774,13 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                 const entries = await durableStore.getEntries(keysToReviveAsArray, DefaultDurableSegment);
                 ingestStagingStore = buildIngestStagingStore(environment);
                 publishDurableStoreEntries(entries, (key, record) => {
-                    ingestStagingStore.fallbackStringKeyInMemoryStore.records[key] = record;
+                    if (typeof key === 'string') {
+                        ingestStagingStore.fallbackStringKeyInMemoryStore.records[key] =
+                            record;
+                    }
+                    else {
+                        ingestStagingStore.recordsMap.set(key, record);
+                    }
                 }, 
                 // we don't need to prime metadata
                 () => { });
@@ -825,10 +835,15 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const getNotifyChangeStoreEntries = function (keys) {
         validateNotDisposed();
-        return durableStore.getEntries(keys, DefaultDurableSegment).then((durableRecords) => {
-            const entries = {};
+        return durableStore
+            .getEntries(keys.map(serializeStructuredKey), DefaultDurableSegment)
+            .then((durableRecords) => {
+            const entries = [];
             publishDurableStoreEntries(durableRecords, (key, record) => {
-                entries[key] = record;
+                entries.push({
+                    key,
+                    record: record,
+                });
             }, () => { });
             return entries;
         });

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

@@ -1,11 +1,9 @@
-import type { Environment, Snapshot, UnAvailableSnapshot, StoreMetadata } from '@luvio/engine';
+import type { Environment, Snapshot, UnAvailableSnapshot, StoreMetadata, NormalizedKeyMetadata } from '@luvio/engine';
 import type { DurableStore, DurableStoreEntries } from '../DurableStore';
 import type { DurableStoreRejectionHandler } from './error';
-declare type ObjectAsSet = {
-    [key: string]: true;
-};
+import { StoreKeySet } from '@luvio/engine';
 declare type ReviveResponse = {
-    revivedKeys: ObjectAsSet;
+    revivedKeys: StoreKeySet<string | NormalizedKeyMetadata>;
     hadUnexpectedShape: boolean;
 };
 /**
@@ -19,7 +17,7 @@ declare type ReviveResponse = {
  * @param pendingWriter the PendingWriter (this is going away soon)
  * @returns
  */
-export declare function publishDurableStoreEntries(durableRecords: DurableStoreEntries<unknown> | undefined, publish: (key: string, record: unknown) => void, publishMetadata: (key: string, metadata: StoreMetadata) => void): ReviveResponse;
+export declare function publishDurableStoreEntries(durableRecords: DurableStoreEntries<unknown> | undefined, publish: (key: string | NormalizedKeyMetadata, record: unknown) => void, publishMetadata: (key: string, metadata: StoreMetadata) => void): ReviveResponse;
 interface ReviveMetrics {
     l2Trips: {
         keysRequestedCount: number;

package/dist/umd/es2018/environments.js

@@ -85,7 +85,7 @@
      * @returns
      */
     function publishDurableStoreEntries(durableRecords, publish, publishMetadata) {
-        const revivedKeys = create(null);
+        const revivedKeys = new engine.StoreKeySet();
         let hadUnexpectedShape = false;
         if (durableRecords === undefined) {
             return { revivedKeys, hadUnexpectedShape };
@@ -123,7 +123,7 @@
                 deepFreeze(data.error);
             }
             publish(key, data);
-            revivedKeys[key] = true;
+            revivedKeys.add(key);
         }
         return { revivedKeys, hadUnexpectedShape };
     }
@@ -147,9 +147,10 @@
         }
         // in case L1 store changes/deallocs a record while we are doing the async read
         // we attempt to read all keys from L2 - so combine recordId with any seenRecords
-        const keysToReviveSet = assign({ [recordId]: true }, seenRecords);
-        const keysToRevive = keys(keysToReviveSet);
-        const canonicalKeys = keysToRevive.map((x) => baseEnvironment.storeGetCanonicalKey(x));
+        const keysToReviveSet = new engine.StoreKeySet().add(recordId);
+        keysToReviveSet.merge(seenRecords);
+        const keysToRevive = keysToReviveSet.keysAsArray();
+        const canonicalKeys = keysToRevive.map((x) => engine.serializeStructuredKey(baseEnvironment.storeGetCanonicalKey(x)));
         const start = Date.now();
         const { l2Trips } = reviveMetrics;
         return durableStore.getEntries(canonicalKeys, DefaultDurableSegment).then((durableRecords) => {
@@ -167,7 +168,7 @@
             if (hadUnexpectedShape === true) {
                 return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
             }
-            if (keys(revivedKeys).length === 0) {
+            if (revivedKeys.size() === 0) {
                 // durable store doesn't have what we asked for so return L1 snapshot
                 return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
             }
@@ -182,16 +183,19 @@
                 // have to check if the new snapshot has any additional seenRecords
                 // and revive again if so
                 const { seenRecords: newSnapshotSeenRecords, recordId: newSnapshotRecordId } = snapshot;
-                const newKeysToReviveSet = assign({ [newSnapshotRecordId]: true }, newSnapshotSeenRecords);
-                const newKeys = keys(newKeysToReviveSet);
+                const newKeysToReviveSet = new engine.StoreKeySet();
+                newKeysToReviveSet.add(newSnapshotRecordId);
+                newKeysToReviveSet.merge(newSnapshotSeenRecords);
+                const newKeys = newKeysToReviveSet.keysAsArray();
                 // in case DS returned additional entries we combine the requested
                 // and returned keys
-                const alreadyRequestedOrRevivedSet = assign(keysToReviveSet, revivedKeys);
+                const alreadyRequestedOrRevivedSet = keysToReviveSet;
+                alreadyRequestedOrRevivedSet.merge(revivedKeys);
                 // if there's any seen keys in the newly rebuilt snapshot that
                 // haven't already been requested or returned then revive again
                 for (let i = 0, len = newKeys.length; i < len; i++) {
                     const newSnapshotSeenKey = newKeys[i];
-                    if (alreadyRequestedOrRevivedSet[newSnapshotSeenKey] !== true) {
+                    if (!alreadyRequestedOrRevivedSet.has(newSnapshotSeenKey)) {
                         return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics);
                     }
                 }
@@ -741,7 +745,7 @@
         const handleSuccessResponse = async function (ingestAndBroadcastFunc, getResponseCacheKeysFunc) {
             validateNotDisposed();
             const cacheKeyMap = getResponseCacheKeysFunc();
-            const cacheKeyMapKeys = Array.from(cacheKeyMap.keys());
+            const cacheKeyMapKeys = cacheKeyMap.keysAsArray();
             const keysToRevive = new engine.StoreKeySet();
             for (const cacheKeyMapKey of cacheKeyMapKeys) {
                 const cacheKey = cacheKeyMap.get(cacheKeyMapKey);
@@ -750,7 +754,7 @@
                 }
             }
             let snapshotFromMemoryIngest = undefined;
-            // Once these are structured keys, we will call the serializeStructuredKey() utility method
+            // To-do: Once these are structured keys, will need to support them throughout durable logic W-12356727
             const keysToReviveAsArray = Array.from(keysToRevive.keysAsStrings());
             if (keysToReviveAsArray.length > 0) {
                 // if we need to do an L2 read then L2 write then we need to synchronize
@@ -774,7 +778,13 @@
                     const entries = await durableStore.getEntries(keysToReviveAsArray, DefaultDurableSegment);
                     ingestStagingStore = buildIngestStagingStore(environment);
                     publishDurableStoreEntries(entries, (key, record) => {
-                        ingestStagingStore.fallbackStringKeyInMemoryStore.records[key] = record;
+                        if (typeof key === 'string') {
+                            ingestStagingStore.fallbackStringKeyInMemoryStore.records[key] =
+                                record;
+                        }
+                        else {
+                            ingestStagingStore.recordsMap.set(key, record);
+                        }
                     }, 
                     // we don't need to prime metadata
                     () => { });
@@ -829,10 +839,15 @@
         };
         const getNotifyChangeStoreEntries = function (keys) {
             validateNotDisposed();
-            return durableStore.getEntries(keys, DefaultDurableSegment).then((durableRecords) => {
-                const entries = {};
+            return durableStore
+                .getEntries(keys.map(engine.serializeStructuredKey), DefaultDurableSegment)
+                .then((durableRecords) => {
+                const entries = [];
                 publishDurableStoreEntries(durableRecords, (key, record) => {
-                    entries[key] = record;
+                    entries.push({
+                        key,
+                        record: record,
+                    });
                 }, () => { });
                 return entries;
             });

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

@@ -1,11 +1,9 @@
-import type { Environment, Snapshot, UnAvailableSnapshot, StoreMetadata } from '@luvio/engine';
+import type { Environment, Snapshot, UnAvailableSnapshot, StoreMetadata, NormalizedKeyMetadata } from '@luvio/engine';
 import type { DurableStore, DurableStoreEntries } from '../DurableStore';
 import type { DurableStoreRejectionHandler } from './error';
-declare type ObjectAsSet = {
-    [key: string]: true;
-};
+import { StoreKeySet } from '@luvio/engine';
 declare type ReviveResponse = {
-    revivedKeys: ObjectAsSet;
+    revivedKeys: StoreKeySet<string | NormalizedKeyMetadata>;
     hadUnexpectedShape: boolean;
 };
 /**
@@ -19,7 +17,7 @@ declare type ReviveResponse = {
  * @param pendingWriter the PendingWriter (this is going away soon)
  * @returns
  */
-export declare function publishDurableStoreEntries(durableRecords: DurableStoreEntries<unknown> | undefined, publish: (key: string, record: unknown) => void, publishMetadata: (key: string, metadata: StoreMetadata) => void): ReviveResponse;
+export declare function publishDurableStoreEntries(durableRecords: DurableStoreEntries<unknown> | undefined, publish: (key: string | NormalizedKeyMetadata, record: unknown) => void, publishMetadata: (key: string, metadata: StoreMetadata) => void): ReviveResponse;
 interface ReviveMetrics {
     l2Trips: {
         keysRequestedCount: number;

package/dist/umd/es5/environments.js

@@ -97,7 +97,7 @@
         return to.concat(ar || Array.prototype.slice.call(from));
     }
 
-    var keys = Object.keys, create = Object.create, assign = Object.assign, freeze = Object.freeze;
+    var keys = Object.keys, create = Object.create, freeze = Object.freeze;
     var isArray = Array.isArray;
 
     //Durable store error instrumentation key
@@ -160,7 +160,7 @@
      * @returns
      */
     function publishDurableStoreEntries(durableRecords, publish, publishMetadata) {
-        var revivedKeys = create(null);
+        var revivedKeys = new engine.StoreKeySet();
         var hadUnexpectedShape = false;
         if (durableRecords === undefined) {
             return { revivedKeys: revivedKeys, hadUnexpectedShape: hadUnexpectedShape };
@@ -198,7 +198,7 @@
                 deepFreeze(data.error);
             }
             publish(key, data);
-            revivedKeys[key] = true;
+            revivedKeys.add(key);
         }
         return { revivedKeys: revivedKeys, hadUnexpectedShape: hadUnexpectedShape };
     }
@@ -211,7 +211,6 @@
     function reviveSnapshot(baseEnvironment, durableStore, 
     // TODO [W-10165787]: We should only allow Unfulfilled snapshot be passed in
     unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics) {
-        var _a;
         if (reviveMetrics === void 0) { reviveMetrics = { l2Trips: [] }; }
         var recordId = unavailableSnapshot.recordId, select = unavailableSnapshot.select, seenRecords = unavailableSnapshot.seenRecords, state = unavailableSnapshot.state;
         // L2 can only revive Unfulfilled snapshots that have a selector since they have the
@@ -224,28 +223,30 @@
         }
         // in case L1 store changes/deallocs a record while we are doing the async read
         // we attempt to read all keys from L2 - so combine recordId with any seenRecords
-        var keysToReviveSet = assign((_a = {}, _a[recordId] = true, _a), seenRecords);
-        var keysToRevive = keys(keysToReviveSet);
-        var canonicalKeys = keysToRevive.map(function (x) { return baseEnvironment.storeGetCanonicalKey(x); });
+        var keysToReviveSet = new engine.StoreKeySet().add(recordId);
+        keysToReviveSet.merge(seenRecords);
+        var keysToRevive = keysToReviveSet.keysAsArray();
+        var canonicalKeys = keysToRevive.map(function (x) {
+            return engine.serializeStructuredKey(baseEnvironment.storeGetCanonicalKey(x));
+        });
         var start = Date.now();
         var l2Trips = reviveMetrics.l2Trips;
         return durableStore.getEntries(canonicalKeys, DefaultDurableSegment).then(function (durableRecords) {
-            var _a;
             l2Trips.push({
                 duration: Date.now() - start,
                 keysRequestedCount: canonicalKeys.length,
             });
-            var _b = publishDurableStoreEntries(durableRecords, 
+            var _a = publishDurableStoreEntries(durableRecords, 
             // TODO [W-10072584]: instead of implicitly using L1 we should take in
             // publish and publishMetadata funcs, so callers can decide where to
             // revive to (like they pass in how to do the buildL1Snapshot)
-            baseEnvironment.storePublish.bind(baseEnvironment), baseEnvironment.publishStoreMetadata.bind(baseEnvironment)), revivedKeys = _b.revivedKeys, hadUnexpectedShape = _b.hadUnexpectedShape;
+            baseEnvironment.storePublish.bind(baseEnvironment), baseEnvironment.publishStoreMetadata.bind(baseEnvironment)), revivedKeys = _a.revivedKeys, hadUnexpectedShape = _a.hadUnexpectedShape;
             // if the data coming back from DS had an unexpected shape then just
             // return the L1 snapshot
             if (hadUnexpectedShape === true) {
                 return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
             }
-            if (keys(revivedKeys).length === 0) {
+            if (revivedKeys.size() === 0) {
                 // durable store doesn't have what we asked for so return L1 snapshot
                 return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
             }
@@ -260,16 +261,19 @@
                 // have to check if the new snapshot has any additional seenRecords
                 // and revive again if so
                 var newSnapshotSeenRecords = snapshot.seenRecords, newSnapshotRecordId = snapshot.recordId;
-                var newKeysToReviveSet = assign((_a = {}, _a[newSnapshotRecordId] = true, _a), newSnapshotSeenRecords);
-                var newKeys = keys(newKeysToReviveSet);
+                var newKeysToReviveSet = new engine.StoreKeySet();
+                newKeysToReviveSet.add(newSnapshotRecordId);
+                newKeysToReviveSet.merge(newSnapshotSeenRecords);
+                var newKeys = newKeysToReviveSet.keysAsArray();
                 // in case DS returned additional entries we combine the requested
                 // and returned keys
-                var alreadyRequestedOrRevivedSet = assign(keysToReviveSet, revivedKeys);
+                var alreadyRequestedOrRevivedSet = keysToReviveSet;
+                alreadyRequestedOrRevivedSet.merge(revivedKeys);
                 // if there's any seen keys in the newly rebuilt snapshot that
                 // haven't already been requested or returned then revive again
                 for (var i = 0, len = newKeys.length; i < len; i++) {
                     var newSnapshotSeenKey = newKeys[i];
-                    if (alreadyRequestedOrRevivedSet[newSnapshotSeenKey] !== true) {
+                    if (!alreadyRequestedOrRevivedSet.has(newSnapshotSeenKey)) {
                         return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics);
                     }
                 }
@@ -871,7 +875,7 @@
                         case 0:
                             validateNotDisposed();
                             cacheKeyMap = getResponseCacheKeysFunc();
-                            cacheKeyMapKeys = Array.from(cacheKeyMap.keys());
+                            cacheKeyMapKeys = cacheKeyMap.keysAsArray();
                             keysToRevive = new engine.StoreKeySet();
                             for (_i = 0, cacheKeyMapKeys_1 = cacheKeyMapKeys; _i < cacheKeyMapKeys_1.length; _i++) {
                                 cacheKeyMapKey = cacheKeyMapKeys_1[_i];
@@ -910,7 +914,13 @@
                                             entries = _a.sent();
                                             ingestStagingStore = buildIngestStagingStore(environment);
                                             publishDurableStoreEntries(entries, function (key, record) {
-                                                ingestStagingStore.fallbackStringKeyInMemoryStore.records[key] = record;
+                                                if (typeof key === 'string') {
+                                                    ingestStagingStore.fallbackStringKeyInMemoryStore.records[key] =
+                                                        record;
+                                                }
+                                                else {
+                                                    ingestStagingStore.recordsMap.set(key, record);
+                                                }
                                             }, 
                                             // we don't need to prime metadata
                                             function () { });
@@ -987,10 +997,15 @@
         };
         var getNotifyChangeStoreEntries = function (keys) {
             validateNotDisposed();
-            return durableStore.getEntries(keys, DefaultDurableSegment).then(function (durableRecords) {
-                var entries = {};
+            return durableStore
+                .getEntries(keys.map(engine.serializeStructuredKey), DefaultDurableSegment)
+                .then(function (durableRecords) {
+                var entries = [];
                 publishDurableStoreEntries(durableRecords, function (key, record) {
-                    entries[key] = record;
+                    entries.push({
+                        key: key,
+                        record: record,
+                    });
                 }, function () { });
                 return entries;
             });

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

@@ -1,11 +1,9 @@
-import type { Environment, Snapshot, UnAvailableSnapshot, StoreMetadata } from '@luvio/engine';
+import type { Environment, Snapshot, UnAvailableSnapshot, StoreMetadata, NormalizedKeyMetadata } from '@luvio/engine';
 import type { DurableStore, DurableStoreEntries } from '../DurableStore';
 import type { DurableStoreRejectionHandler } from './error';
-declare type ObjectAsSet = {
-    [key: string]: true;
-};
+import { StoreKeySet } from '@luvio/engine';
 declare type ReviveResponse = {
-    revivedKeys: ObjectAsSet;
+    revivedKeys: StoreKeySet<string | NormalizedKeyMetadata>;
     hadUnexpectedShape: boolean;
 };
 /**
@@ -19,7 +17,7 @@ declare type ReviveResponse = {
  * @param pendingWriter the PendingWriter (this is going away soon)
  * @returns
  */
-export declare function publishDurableStoreEntries(durableRecords: DurableStoreEntries<unknown> | undefined, publish: (key: string, record: unknown) => void, publishMetadata: (key: string, metadata: StoreMetadata) => void): ReviveResponse;
+export declare function publishDurableStoreEntries(durableRecords: DurableStoreEntries<unknown> | undefined, publish: (key: string | NormalizedKeyMetadata, record: unknown) => void, publishMetadata: (key: string, metadata: StoreMetadata) => void): ReviveResponse;
 interface ReviveMetrics {
     l2Trips: {
         keysRequestedCount: number;

package/package.json

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