@luvio/environments 0.138.0 → 0.138.2

package/dist/umd/es5/environments.js

@@ -4,23 +4,23 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.luvioEnvironments = {}, global.luvioEngine));
 })(this, (function (exports, engine) { 'use strict';
 
-    // the last version the metadata shape was altered
-    var DURABLE_METADATA_VERSION = '0.111.0';
-    function isDeprecatedDurableStoreEntry(durableRecord) {
-        if (durableRecord.expiration !== undefined) {
-            return true;
-        }
-        var metadata = durableRecord.metadata;
-        if (metadata !== undefined) {
-            var metadataVersion = metadata.metadataVersion;
-            // eventually we will want to assert that metadataVersion is defined
-            if (metadataVersion !== undefined && metadataVersion !== DURABLE_METADATA_VERSION) {
-                return true;
-            }
-        }
-        // Add more deprecated shape checks here
-        return false;
-    }
+    // the last version the metadata shape was altered
+    var DURABLE_METADATA_VERSION = '0.111.0';
+    function isDeprecatedDurableStoreEntry(durableRecord) {
+        if (durableRecord.expiration !== undefined) {
+            return true;
+        }
+        var metadata = durableRecord.metadata;
+        if (metadata !== undefined) {
+            var metadataVersion = metadata.metadataVersion;
+            // eventually we will want to assert that metadataVersion is defined
+            if (metadataVersion !== undefined && metadataVersion !== DURABLE_METADATA_VERSION) {
+                return true;
+            }
+        }
+        // Add more deprecated shape checks here
+        return false;
+    }
     var DefaultDurableSegment = 'DEFAULT';
 
     /******************************************************************************
@@ -97,945 +97,951 @@
         return to.concat(ar || Array.prototype.slice.call(from));
     }
 
-    var keys = Object.keys, create = Object.create, freeze = Object.freeze;
+    var keys = Object.keys, create = Object.create, freeze = Object.freeze;
     var isArray = Array.isArray;
 
-    //Durable store error instrumentation key
-    var DURABLE_STORE_ERROR = 'durable-store-error';
-    /**
-     * Returns a function that processes errors from durable store promise rejections.
-     * If running in a non-production environment, the error is rethrown.
-     * When running in production the error is sent to instrumentation.
-     * @param instrument Instrumentation function implementation
-     */
-    function handleDurableStoreRejection(instrument) {
-        return function (error) {
-            if (process.env.NODE_ENV !== 'production') {
-                throw error;
-            }
-            if (instrument !== undefined) {
-                instrument(function () {
-                    var _a;
-                    return _a = {},
-                        _a[DURABLE_STORE_ERROR] = true,
-                        _a.error = error,
-                        _a;
-                });
-            }
-        };
+    //Durable store error instrumentation key
+    var DURABLE_STORE_ERROR = 'durable-store-error';
+    /**
+     * Returns a function that processes errors from durable store promise rejections.
+     * If running in a non-production environment, the error is rethrown.
+     * When running in production the error is sent to instrumentation.
+     * @param instrument Instrumentation function implementation
+     */
+    function handleDurableStoreRejection(instrument) {
+        return function (error) {
+            if (process.env.NODE_ENV !== 'production') {
+                throw error;
+            }
+            if (instrument !== undefined) {
+                instrument(function () {
+                    var _a;
+                    return _a = {},
+                        _a[DURABLE_STORE_ERROR] = true,
+                        _a.error = error,
+                        _a;
+                });
+            }
+        };
     }
 
-    function deepFreeze(value) {
-        // No need to freeze primitives
-        if (typeof value !== 'object' || value === null) {
-            return;
-        }
-        if (isArray(value)) {
-            for (var i = 0, len = value.length; i < len; i += 1) {
-                deepFreeze(value[i]);
-            }
-        }
-        else {
-            var keys$1 = keys(value);
-            for (var i = 0, len = keys$1.length; i < len; i += 1) {
-                deepFreeze(value[keys$1[i]]);
-            }
-        }
-        freeze(value);
+    function deepFreeze(value) {
+        // No need to freeze primitives
+        if (typeof value !== 'object' || value === null) {
+            return;
+        }
+        if (isArray(value)) {
+            for (var i = 0, len = value.length; i < len; i += 1) {
+                deepFreeze(value[i]);
+            }
+        }
+        else {
+            var keys$1 = keys(value);
+            for (var i = 0, len = keys$1.length; i < len; i += 1) {
+                deepFreeze(value[keys$1[i]]);
+            }
+        }
+        freeze(value);
     }
 
-    function isStoreEntryError(storeRecord) {
-        return storeRecord.__type === 'error';
+    function isStoreEntryError(storeRecord) {
+        return storeRecord.__type === 'error';
     }
 
-    /**
-     * Takes a set of entries from DurableStore and publishes them via the passed in funcs.
-     * This respects expiration and checks for valid DurableStore data shapes.  This should
-     * be used over manually parsing DurableStoreEntries
-     *
-     * @param durableRecords The DurableStoreEntries to parse
-     * @param publish A function to call with the data of each DurableStoreEntry
-     * @param publishMetadata A function to call with the metadata of each DurableStoreEntry
-     * @param pendingWriter the PendingWriter (this is going away soon)
-     * @returns
-     */
-    function publishDurableStoreEntries(durableRecords, publish, publishMetadata) {
-        var revivedKeys = new engine.StoreKeySet();
-        var hadUnexpectedShape = false;
-        if (durableRecords === undefined) {
-            return { revivedKeys: revivedKeys, hadUnexpectedShape: hadUnexpectedShape };
-        }
-        var durableKeys = keys(durableRecords);
-        if (durableKeys.length === 0) {
-            // no records to revive
-            return { revivedKeys: revivedKeys, hadUnexpectedShape: hadUnexpectedShape };
-        }
-        for (var i = 0, len = durableKeys.length; i < len; i += 1) {
-            var key = durableKeys[i];
-            var durableRecord = durableRecords[key];
-            if (isDeprecatedDurableStoreEntry(durableRecord)) {
-                // had the old shape, skip reviving this entry.
-                hadUnexpectedShape = true;
-                continue;
-            }
-            var metadata = durableRecord.metadata, data = durableRecord.data;
-            if (data === undefined) {
-                // if unexpected data skip reviving
-                hadUnexpectedShape = true;
-                continue;
-            }
-            if (metadata !== undefined) {
-                var expirationTimestamp = metadata.expirationTimestamp;
-                if (expirationTimestamp === undefined) {
-                    // if unexpected expiration data skip reviving
-                    hadUnexpectedShape = true;
-                    continue;
-                }
-                publishMetadata(key, metadata);
-            }
-            if (isStoreEntryError(data)) {
-                // freeze errors on way into L1
-                deepFreeze(data.error);
-            }
-            publish(key, data);
-            revivedKeys.add(key);
-        }
-        return { revivedKeys: revivedKeys, hadUnexpectedShape: hadUnexpectedShape };
-    }
-    /**
-     * This method returns a Promise to a snapshot that is revived from L2 cache.  If
-     * L2 does not have the entries necessary to fulfill the snapshot then this method
-     * will refresh the snapshot from network, and then run the results from network
-     * through L2 ingestion, returning the subsequent revived snapshot.
-     */
-    function reviveSnapshot(baseEnvironment, durableStore, 
-    // TODO [W-10165787]: We should only allow Unfulfilled snapshot be passed in
-    unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics) {
-        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
-        // info needed to revive (like missingLinks) and rebuild.  Otherwise return L1 snapshot.
-        if (state !== 'Unfulfilled' || select === undefined) {
-            return Promise.resolve({
-                snapshot: unavailableSnapshot,
-                metrics: 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
-        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) {
-            l2Trips.push({
-                duration: Date.now() - start,
-                keysRequestedCount: canonicalKeys.length,
-            });
-            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 = _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 (revivedKeys.size() === 0) {
-                // durable store doesn't have what we asked for so return L1 snapshot
-                return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
-            }
-            // try building the snapshot from L1 now that we have revived the missingLinks
-            var snapshot = buildL1Snapshot();
-            // if snapshot is pending then some other in-flight refresh will broadcast
-            // later
-            if (snapshot.state === 'Pending') {
-                return { snapshot: snapshot, metrics: reviveMetrics };
-            }
-            if (snapshot.state === 'Unfulfilled') {
-                // 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 = 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 = 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.has(newSnapshotSeenKey)) {
-                        return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics);
-                    }
-                }
-            }
-            return { snapshot: snapshot, metrics: reviveMetrics };
-        }, function (error) {
-            durableStoreErrorHandler(error);
-            // getEntries failed, return the L1 snapshot
-            return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
-        });
+    /**
+     * Takes a set of entries from DurableStore and publishes them via the passed in funcs.
+     * This respects expiration and checks for valid DurableStore data shapes.  This should
+     * be used over manually parsing DurableStoreEntries
+     *
+     * @param durableRecords The DurableStoreEntries to parse
+     * @param publish A function to call with the data of each DurableStoreEntry
+     * @param publishMetadata A function to call with the metadata of each DurableStoreEntry
+     * @param pendingWriter the PendingWriter (this is going away soon)
+     * @returns
+     */
+    function publishDurableStoreEntries(durableRecords, publish, publishMetadata) {
+        var revivedKeys = new engine.StoreKeySet();
+        var hadUnexpectedShape = false;
+        if (durableRecords === undefined) {
+            return { revivedKeys: revivedKeys, hadUnexpectedShape: hadUnexpectedShape };
+        }
+        var durableKeys = keys(durableRecords);
+        if (durableKeys.length === 0) {
+            // no records to revive
+            return { revivedKeys: revivedKeys, hadUnexpectedShape: hadUnexpectedShape };
+        }
+        for (var i = 0, len = durableKeys.length; i < len; i += 1) {
+            var key = durableKeys[i];
+            var durableRecord = durableRecords[key];
+            if (isDeprecatedDurableStoreEntry(durableRecord)) {
+                // had the old shape, skip reviving this entry.
+                hadUnexpectedShape = true;
+                continue;
+            }
+            var metadata = durableRecord.metadata, data = durableRecord.data;
+            if (data === undefined) {
+                // if unexpected data skip reviving
+                hadUnexpectedShape = true;
+                continue;
+            }
+            if (metadata !== undefined) {
+                var expirationTimestamp = metadata.expirationTimestamp;
+                if (expirationTimestamp === undefined) {
+                    // if unexpected expiration data skip reviving
+                    hadUnexpectedShape = true;
+                    continue;
+                }
+                publishMetadata(key, metadata);
+            }
+            if (isStoreEntryError(data)) {
+                // freeze errors on way into L1
+                deepFreeze(data.error);
+            }
+            publish(key, data);
+            revivedKeys.add(key);
+        }
+        return { revivedKeys: revivedKeys, hadUnexpectedShape: hadUnexpectedShape };
+    }
+    /**
+     * This method returns a Promise to a snapshot that is revived from L2 cache.  If
+     * L2 does not have the entries necessary to fulfill the snapshot then this method
+     * will refresh the snapshot from network, and then run the results from network
+     * through L2 ingestion, returning the subsequent revived snapshot.
+     */
+    function reviveSnapshot(baseEnvironment, durableStore, 
+    // TODO [W-10165787]: We should only allow Unfulfilled snapshot be passed in
+    unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics) {
+        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
+        // info needed to revive (like missingLinks) and rebuild.  Otherwise return L1 snapshot.
+        if (state !== 'Unfulfilled' || select === undefined) {
+            return Promise.resolve({
+                snapshot: unavailableSnapshot,
+                metrics: 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
+        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) {
+            l2Trips.push({
+                duration: Date.now() - start,
+                keysRequestedCount: canonicalKeys.length,
+            });
+            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 = _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 (revivedKeys.size() === 0) {
+                // durable store doesn't have what we asked for so return L1 snapshot
+                return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
+            }
+            // try building the snapshot from L1 now that we have revived the missingLinks
+            var snapshot = buildL1Snapshot();
+            // if snapshot is pending then some other in-flight refresh will broadcast
+            // later
+            if (snapshot.state === 'Pending') {
+                return { snapshot: snapshot, metrics: reviveMetrics };
+            }
+            if (snapshot.state === 'Unfulfilled') {
+                // 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 = 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 = 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.has(newSnapshotSeenKey)) {
+                        return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics);
+                    }
+                }
+            }
+            return { snapshot: snapshot, metrics: reviveMetrics };
+        }, function (error) {
+            durableStoreErrorHandler(error);
+            // getEntries failed, return the L1 snapshot
+            return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
+        });
     }
 
-    var TTL_DURABLE_SEGMENT = 'TTL_DURABLE_SEGMENT';
-    var TTL_DEFAULT_KEY = 'TTL_DEFAULT_KEY';
-    function buildDurableTTLOverrideStoreKey(namespace, representationName) {
-        return "".concat(namespace, "::").concat(representationName);
-    }
-    function isEntryDurableTTLOverride(entry) {
-        if (typeof entry === 'object' && entry !== undefined && entry !== null) {
-            var data = entry.data;
-            if (data !== undefined) {
-                return (data.namespace !== undefined &&
-                    data.representationName !== undefined &&
-                    data.ttl !== undefined);
-            }
-        }
-        return false;
-    }
-    function isDefaultDurableTTLOverride(override) {
-        return (override.namespace === TTL_DEFAULT_KEY && override.representationName === TTL_DEFAULT_KEY);
-    }
-    /**
-     * Class to set and get the TTL override values in the Durable Store
-     */
-    var DurableTTLStore = /** @class */ (function () {
-        function DurableTTLStore(durableStore) {
-            this.durableStore = durableStore;
-        }
-        DurableTTLStore.prototype.setDefaultDurableTTLOverrides = function (ttl) {
-            var _a;
-            return this.durableStore.setEntries((_a = {},
-                _a[buildDurableTTLOverrideStoreKey(TTL_DEFAULT_KEY, TTL_DEFAULT_KEY)] = {
-                    data: {
-                        namespace: TTL_DEFAULT_KEY,
-                        representationName: TTL_DEFAULT_KEY,
-                        ttl: ttl,
-                    },
-                },
-                _a), TTL_DURABLE_SEGMENT);
-        };
-        DurableTTLStore.prototype.setDurableTTLOverride = function (namespace, representationName, ttl) {
-            var _a;
-            return this.durableStore.setEntries((_a = {},
-                _a[buildDurableTTLOverrideStoreKey(namespace, representationName)] = {
-                    data: { namespace: namespace, representationName: representationName, ttl: ttl },
-                },
-                _a), TTL_DURABLE_SEGMENT);
-        };
-        DurableTTLStore.prototype.getDurableTTLOverrides = function () {
-            return this.durableStore
-                .getAllEntries(TTL_DURABLE_SEGMENT)
-                .then(function (entries) {
-                var overrides = [];
-                var defaultTTL = undefined;
-                if (entries === undefined) {
-                    return {
-                        defaultTTL: defaultTTL,
-                        overrides: overrides,
-                    };
-                }
-                var keys$1 = keys(entries);
-                for (var i = 0, len = keys$1.length; i < len; i++) {
-                    var key = keys$1[i];
-                    var entry = entries[key];
-                    if (entry !== undefined && isEntryDurableTTLOverride(entry)) {
-                        if (isDefaultDurableTTLOverride(entry.data)) {
-                            defaultTTL = entry.data;
-                        }
-                        else {
-                            overrides.push(entry.data);
-                        }
-                    }
-                }
-                return {
-                    defaultTTL: defaultTTL,
-                    overrides: overrides,
-                };
-            });
-        };
-        return DurableTTLStore;
+    var TTL_DURABLE_SEGMENT = 'TTL_DURABLE_SEGMENT';
+    var TTL_DEFAULT_KEY = 'TTL_DEFAULT_KEY';
+    function buildDurableTTLOverrideStoreKey(namespace, representationName) {
+        return "".concat(namespace, "::").concat(representationName);
+    }
+    function isEntryDurableTTLOverride(entry) {
+        if (typeof entry === 'object' && entry !== undefined && entry !== null) {
+            var data = entry.data;
+            if (data !== undefined) {
+                return (data.namespace !== undefined &&
+                    data.representationName !== undefined &&
+                    data.ttl !== undefined);
+            }
+        }
+        return false;
+    }
+    function isDefaultDurableTTLOverride(override) {
+        return (override.namespace === TTL_DEFAULT_KEY && override.representationName === TTL_DEFAULT_KEY);
+    }
+    /**
+     * Class to set and get the TTL override values in the Durable Store
+     */
+    var DurableTTLStore = /** @class */ (function () {
+        function DurableTTLStore(durableStore) {
+            this.durableStore = durableStore;
+        }
+        DurableTTLStore.prototype.setDefaultDurableTTLOverrides = function (ttl) {
+            var _a;
+            return this.durableStore.setEntries((_a = {},
+                _a[buildDurableTTLOverrideStoreKey(TTL_DEFAULT_KEY, TTL_DEFAULT_KEY)] = {
+                    data: {
+                        namespace: TTL_DEFAULT_KEY,
+                        representationName: TTL_DEFAULT_KEY,
+                        ttl: ttl,
+                    },
+                },
+                _a), TTL_DURABLE_SEGMENT);
+        };
+        DurableTTLStore.prototype.setDurableTTLOverride = function (namespace, representationName, ttl) {
+            var _a;
+            return this.durableStore.setEntries((_a = {},
+                _a[buildDurableTTLOverrideStoreKey(namespace, representationName)] = {
+                    data: { namespace: namespace, representationName: representationName, ttl: ttl },
+                },
+                _a), TTL_DURABLE_SEGMENT);
+        };
+        DurableTTLStore.prototype.getDurableTTLOverrides = function () {
+            return this.durableStore
+                .getAllEntries(TTL_DURABLE_SEGMENT)
+                .then(function (entries) {
+                var overrides = [];
+                var defaultTTL = undefined;
+                if (entries === undefined) {
+                    return {
+                        defaultTTL: defaultTTL,
+                        overrides: overrides,
+                    };
+                }
+                var keys$1 = keys(entries);
+                for (var i = 0, len = keys$1.length; i < len; i++) {
+                    var key = keys$1[i];
+                    var entry = entries[key];
+                    if (entry !== undefined && isEntryDurableTTLOverride(entry)) {
+                        if (isDefaultDurableTTLOverride(entry.data)) {
+                            defaultTTL = entry.data;
+                        }
+                        else {
+                            overrides.push(entry.data);
+                        }
+                    }
+                }
+                return {
+                    defaultTTL: defaultTTL,
+                    overrides: overrides,
+                };
+            });
+        };
+        return DurableTTLStore;
     }());
 
-    function copy(source) {
-        if (typeof source !== 'object' || source === null) {
-            return source;
-        }
-        if (isArray(source)) {
-            // TS doesn't trust that this new array is an array unless we cast it
-            return __spreadArray([], source, true);
-        }
-        return __assign({}, source);
-    }
-    function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler) {
-        var durableRecords = create(null);
-        var evictedRecords = create(null);
-        var _a = store.fallbackStringKeyInMemoryStore, records = _a.records, storeMetadata = _a.metadata, visitedIds = _a.visitedIds, refreshedIds = _a.refreshedIds;
-        // TODO: W-8909393 Once metadata is stored in its own segment we need to
-        // call setEntries for the visitedIds on default segment and call setEntries
-        // on the metadata segment for the refreshedIds
-        var keys$1 = keys(__assign(__assign({}, visitedIds), refreshedIds));
-        for (var i = 0, len = keys$1.length; i < len; i += 1) {
-            var key = keys$1[i];
-            var record = records[key];
-            // this record has been evicted, evict from DS
-            if (record === undefined) {
-                evictedRecords[key] = true;
-                continue;
-            }
-            var metadata = storeMetadata[key];
-            durableRecords[key] = {
-                // copy the data in case the store is mutated during the
-                // async setEntries call
-                data: copy(record),
-            };
-            if (metadata !== undefined) {
-                durableRecords[key].metadata = __assign(__assign({}, metadata), { metadataVersion: DURABLE_METADATA_VERSION });
-            }
-        }
-        var durableStoreOperations = [];
-        // publishes
-        var recordKeys = keys(durableRecords);
-        if (recordKeys.length > 0) {
-            durableStoreOperations.push({
-                type: 'setEntries',
-                entries: durableRecords,
-                segment: DefaultDurableSegment,
-            });
-        }
-        // evicts
-        var evictedKeys = keys(evictedRecords);
-        if (evictedKeys.length > 0) {
-            durableStoreOperations.push({
-                type: 'evictEntries',
-                ids: evictedKeys,
-                segment: DefaultDurableSegment,
-            });
-        }
-        if (durableStoreOperations.length > 0) {
-            return durableStore.batchOperations(durableStoreOperations).catch(durableStoreErrorHandler);
-        }
-        return Promise.resolve();
+    function copy(source) {
+        if (typeof source !== 'object' || source === null) {
+            return source;
+        }
+        if (isArray(source)) {
+            // TS doesn't trust that this new array is an array unless we cast it
+            return __spreadArray([], source, true);
+        }
+        return __assign({}, source);
+    }
+    function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler) {
+        var durableRecords = create(null);
+        var evictedRecords = create(null);
+        var _a = store.fallbackStringKeyInMemoryStore, records = _a.records, storeMetadata = _a.metadata, visitedIds = _a.visitedIds, refreshedIds = _a.refreshedIds;
+        // TODO: W-8909393 Once metadata is stored in its own segment we need to
+        // call setEntries for the visitedIds on default segment and call setEntries
+        // on the metadata segment for the refreshedIds
+        var keys$1 = keys(__assign(__assign({}, visitedIds), refreshedIds));
+        for (var i = 0, len = keys$1.length; i < len; i += 1) {
+            var key = keys$1[i];
+            var record = records[key];
+            // this record has been evicted, evict from DS
+            if (record === undefined) {
+                evictedRecords[key] = true;
+                continue;
+            }
+            var metadata = storeMetadata[key];
+            durableRecords[key] = {
+                // copy the data in case the store is mutated during the
+                // async setEntries call
+                data: copy(record),
+            };
+            if (metadata !== undefined) {
+                durableRecords[key].metadata = __assign(__assign({}, metadata), { metadataVersion: DURABLE_METADATA_VERSION });
+            }
+        }
+        var durableStoreOperations = [];
+        // publishes
+        var recordKeys = keys(durableRecords);
+        if (recordKeys.length > 0) {
+            durableStoreOperations.push({
+                type: 'setEntries',
+                entries: durableRecords,
+                segment: DefaultDurableSegment,
+            });
+        }
+        // evicts
+        var evictedKeys = keys(evictedRecords);
+        if (evictedKeys.length > 0) {
+            durableStoreOperations.push({
+                type: 'evictEntries',
+                ids: evictedKeys,
+                segment: DefaultDurableSegment,
+            });
+        }
+        if (durableStoreOperations.length > 0) {
+            return durableStore.batchOperations(durableStoreOperations).catch(durableStoreErrorHandler);
+        }
+        return Promise.resolve();
     }
 
-    var DurableEnvironmentEventDiscriminator = 'durable';
-    function isDurableEnvironmentEvent(event) {
-        return (event.type === 'environment' && event.environment === DurableEnvironmentEventDiscriminator);
-    }
-    function emitDurableEnvironmentAdapterEvent(eventData, observers) {
-        engine.emitAdapterEvent({
-            type: 'environment',
-            timestamp: Date.now(),
-            environment: DurableEnvironmentEventDiscriminator,
-            data: eventData,
-        }, observers);
+    var DurableEnvironmentEventDiscriminator = 'durable';
+    function isDurableEnvironmentEvent(event) {
+        return (event.type === 'environment' && event.environment === DurableEnvironmentEventDiscriminator);
+    }
+    function emitDurableEnvironmentAdapterEvent(eventData, observers) {
+        engine.emitAdapterEvent({
+            type: 'environment',
+            timestamp: Date.now(),
+            environment: DurableEnvironmentEventDiscriminator,
+            data: eventData,
+        }, observers);
     }
 
-    function reviveTTLOverrides(ttlStore, environment) {
-        return __awaiter(this, void 0, void 0, function () {
-            var map, defaultTTL, overrides, i, len, _a, namespace, representationName, ttl;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, ttlStore.getDurableTTLOverrides()];
-                    case 1:
-                        map = _b.sent();
-                        defaultTTL = map.defaultTTL, overrides = map.overrides;
-                        if (defaultTTL !== undefined) {
-                            environment.storeSetDefaultTTLOverride(defaultTTL.ttl);
-                        }
-                        for (i = 0, len = overrides.length; i < len; i++) {
-                            _a = overrides[i], namespace = _a.namespace, representationName = _a.representationName, ttl = _a.ttl;
-                            environment.storeSetTTLOverride(namespace, representationName, ttl);
-                        }
-                        return [2 /*return*/];
-                }
-            });
-        });
+    function reviveTTLOverrides(ttlStore, environment) {
+        return __awaiter(this, void 0, void 0, function () {
+            var map, defaultTTL, overrides, i, len, _a, namespace, representationName, ttl;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, ttlStore.getDurableTTLOverrides()];
+                    case 1:
+                        map = _b.sent();
+                        defaultTTL = map.defaultTTL, overrides = map.overrides;
+                        if (defaultTTL !== undefined) {
+                            environment.storeSetDefaultTTLOverride(defaultTTL.ttl);
+                        }
+                        for (i = 0, len = overrides.length; i < len; i++) {
+                            _a = overrides[i], namespace = _a.namespace, representationName = _a.representationName, ttl = _a.ttl;
+                            environment.storeSetTTLOverride(namespace, representationName, ttl);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
     }
 
-    /**
-     * Returns an empty InMemoryStore that can be used for ingestion.  Copies over
-     * the TTLOverrides from the given Environment's Store.
-     */
-    function buildIngestStagingStore(environment) {
-        return environment.storeBuildIngestionStagingStore();
+    /**
+     * Returns an empty InMemoryStore that can be used for ingestion.  Copies over
+     * the TTLOverrides from the given Environment's Store.
+     */
+    function buildIngestStagingStore(environment) {
+        return environment.storeBuildIngestionStagingStore();
     }
 
-    var AdapterContextSegment = 'ADAPTER-CONTEXT';
-    var ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
-    function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded) {
-        return __awaiter(this, void 0, void 0, function () {
-            var context, contextReturn, entries, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        // initialize empty context store
-                        contextStores[adapterId] = create(null);
-                        context = {
-                            set: function (key, value) {
-                                var _a;
-                                contextStores[adapterId][key] = value;
-                                durableStore.setEntries((_a = {},
-                                    _a[adapterId] = { data: contextStores[adapterId] },
-                                    _a), AdapterContextSegment);
-                                pendingContextStoreKeys.add(adapterId);
-                            },
-                            get: function (key) {
-                                return contextStores[adapterId][key];
-                            },
-                        };
-                        contextReturn = function () {
-                            if (onContextLoaded !== undefined) {
-                                return onContextLoaded(context).then(function () {
-                                    return context;
-                                });
-                            }
-                            return context;
-                        };
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, durableStore.getEntries([adapterId], AdapterContextSegment)];
-                    case 2:
-                        entries = _a.sent();
-                        if (entries !== undefined && entries[adapterId] !== undefined) {
-                            // if durable store has a saved context then load it in the store
-                            contextStores[adapterId] = entries[adapterId].data;
-                        }
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_1 = _a.sent();
-                        durableStoreErrorHandler(error_1);
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/, contextReturn()];
-                }
-            });
-        });
-    }
-    function isUnfulfilledSnapshot(cachedSnapshotResult) {
-        if (cachedSnapshotResult === undefined) {
-            return false;
-        }
-        if ('then' in cachedSnapshotResult) {
-            return false;
-        }
-        return cachedSnapshotResult.state === 'Unfulfilled';
-    }
-    /**
-     * Configures the environment to persist data into a durable store and attempt to resolve
-     * data from the persistent store before hitting the network.
-     *
-     * @param environment The base environment
-     * @param durableStore A DurableStore implementation
-     * @param instrumentation An instrumentation function implementation
-     */
-    function makeDurable(environment, _a) {
-        var _this = this;
-        var durableStore = _a.durableStore, instrumentation = _a.instrumentation;
-        var ingestStagingStore = null;
-        var durableTTLStore = new DurableTTLStore(durableStore);
-        var mergeKeysPromiseMap = new engine.StoreKeyMap();
-        // When a context store is mutated we write it to L2, which causes DS on change
-        // event. If this instance of makeDurable caused that L2 write we can ignore that
-        // on change event. This Set helps us do that.
-        var pendingContextStoreKeys = new Set();
-        var contextStores = create(null);
-        var initializationPromise = new Promise(function (resolve) {
-            var finish = function () {
-                resolve();
-                initializationPromise = undefined;
-            };
-            reviveTTLOverrides(durableTTLStore, environment).then(finish);
-        });
-        //instrumentation for durable store errors
-        var durableStoreErrorHandler = handleDurableStoreRejection(instrumentation);
-        var disposed = false;
-        var validateNotDisposed = function () {
-            if (disposed === true) {
-                throw new Error('This makeDurable instance has been disposed');
-            }
-        };
-        var unsubscribe = durableStore.registerOnChangedListener(function (changes) { return __awaiter(_this, void 0, void 0, function () {
-            var defaultSegmentKeys, adapterContextSegmentKeys, i, len, change, adapterContextKeysFromDifferentInstance, _i, adapterContextSegmentKeys_1, key, entries, entryKeys, i, len, entryKey, entry, error_2, defaultSegmentKeysLength, i, key, canonical;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        defaultSegmentKeys = [];
-                        adapterContextSegmentKeys = [];
-                        for (i = 0, len = changes.length; i < len; i++) {
-                            change = changes[i];
-                            // we only care about changes to the data which is stored in the default
-                            // segment or the adapter context
-                            if (change.segment === DefaultDurableSegment) {
-                                defaultSegmentKeys.push.apply(defaultSegmentKeys, change.ids);
-                            }
-                            else if (change.segment === AdapterContextSegment) {
-                                adapterContextSegmentKeys.push.apply(adapterContextSegmentKeys, change.ids);
-                            }
-                        }
-                        adapterContextKeysFromDifferentInstance = [];
-                        for (_i = 0, adapterContextSegmentKeys_1 = adapterContextSegmentKeys; _i < adapterContextSegmentKeys_1.length; _i++) {
-                            key = adapterContextSegmentKeys_1[_i];
-                            if (pendingContextStoreKeys.has(key)) {
-                                // if this instance caused the L2 write then remove from the
-                                // "pending" Set and move on
-                                pendingContextStoreKeys.delete(key);
-                            }
-                            else {
-                                // else it came from another luvio instance and we need to
-                                // read from L2
-                                adapterContextKeysFromDifferentInstance.push(key);
-                            }
-                        }
-                        if (!(adapterContextKeysFromDifferentInstance.length > 0)) return [3 /*break*/, 4];
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, durableStore.getEntries(adapterContextKeysFromDifferentInstance, AdapterContextSegment)];
-                    case 2:
-                        entries = _a.sent();
-                        if (entries !== undefined) {
-                            entryKeys = keys(entries);
-                            for (i = 0, len = entryKeys.length; i < len; i++) {
-                                entryKey = entryKeys[i];
-                                entry = entries[entryKey];
-                                contextStores[entryKey] = entry.data;
-                            }
-                        }
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_2 = _a.sent();
-                        durableStoreErrorHandler(error_2);
-                        return [3 /*break*/, 4];
-                    case 4:
-                        defaultSegmentKeysLength = defaultSegmentKeys.length;
-                        if (!(defaultSegmentKeysLength > 0)) return [3 /*break*/, 6];
-                        for (i = 0; i < defaultSegmentKeysLength; i++) {
-                            key = defaultSegmentKeys[i];
-                            canonical = environment.storeGetCanonicalKey(key);
-                            if (canonical !== key) {
-                                continue;
-                            }
-                            // TODO: W-8909393 If expiration is the only thing that changed we should not evict the data... so
-                            // if we stored expiration and data at different keys (or same keys in different segments)
-                            // then we could know if only the expiration has changed and we wouldn't need to evict
-                            // and go through an entire broadcast/revive cycle for unchanged data
-                            // call base environment storeEvict so this evict is not tracked for durable deletion
-                            environment.storeEvict(key);
-                        }
-                        return [4 /*yield*/, environment.storeBroadcast(rebuildSnapshot, environment.snapshotAvailable)];
-                    case 5:
-                        _a.sent();
-                        _a.label = 6;
-                    case 6: return [2 /*return*/];
-                }
-            });
-        }); });
-        var dispose = function () {
-            validateNotDisposed();
-            disposed = true;
-            return unsubscribe();
-        };
-        var storePublish = function (key, data) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            ingestStagingStore.publish(key, data);
-            // remove record from main luvio L1 cache while we are on the synchronous path
-            // because we do not want some other code attempting to use the
-            // in-memory values before the durable store onChanged handler
-            // calls back and revives the values to in-memory
-            environment.storeEvict(key);
-        };
-        var publishStoreMetadata = function (recordId, storeMetadata) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            ingestStagingStore.publishMetadata(recordId, storeMetadata);
-        };
-        var storeIngest = function (key, ingest, response, luvio) {
-            validateNotDisposed();
-            // we don't ingest to the luvio L1 store from network directly, we ingest to
-            // L2 and let DurableStore on change event revive keys into luvio L1 store
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
-        };
-        var storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            environment.storeIngestError(key, errorSnapshot, storeMetadataParams, ingestStagingStore);
-        };
-        var storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
-            validateNotDisposed();
-            // publishing to L2 is essentially "broadcasting" because the onChanged
-            // handler will fire which will revive records to the main L1 store and
-            // call the base storeBroadcast
-            return publishChangesToDurableStore();
-        };
-        var publishChangesToDurableStore = function () {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                return Promise.resolve();
-            }
-            var promise = flushInMemoryStoreValuesToDurableStore(ingestStagingStore, durableStore, durableStoreErrorHandler);
-            ingestStagingStore = null;
-            return promise;
-        };
-        var storeLookup = function (sel, createSnapshot, refresh, ttlStrategy) {
-            validateNotDisposed();
-            // if this lookup is right after an ingest there will be a staging store
-            if (ingestStagingStore !== null) {
-                var reader = new engine.Reader(ingestStagingStore, sel.variables, refresh, undefined, ttlStrategy);
-                return reader.read(sel);
-            }
-            // otherwise this is from buildCachedSnapshot and we should use the luvio
-            // L1 store
-            return environment.storeLookup(sel, createSnapshot, refresh, ttlStrategy);
-        };
-        var storeEvict = function (key) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            ingestStagingStore.evict(key);
-        };
-        var getNode = function (key) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            return environment.getNode(key, ingestStagingStore);
-        };
-        var wrapNormalizedGraphNode = function (normalized) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
-        };
-        var rebuildSnapshot = function (snapshot, onRebuild) {
-            validateNotDisposed();
-            // try rebuilding from memory
-            environment.rebuildSnapshot(snapshot, function (rebuilt) {
-                // only try reviving from durable store if snapshot is unfulfilled
-                if (rebuilt.state !== 'Unfulfilled') {
-                    onRebuild(rebuilt);
-                    return;
-                }
-                // Do an L2 revive and emit to subscriber using the callback.
-                reviveSnapshot(environment, durableStore, rebuilt, durableStoreErrorHandler, function () {
-                    // reviveSnapshot will revive into L1, and since "records" is a reference
-                    // (and not a copy) to the L1 records we can use it for rebuild
-                    var rebuiltSnap;
-                    environment.rebuildSnapshot(snapshot, function (rebuilt) {
-                        rebuiltSnap = rebuilt;
-                    });
-                    return rebuiltSnap;
-                }).then(function (result) {
-                    onRebuild(result.snapshot);
-                });
-            });
-        };
-        var withContext = function (adapter, options) {
-            validateNotDisposed();
-            var contextId = options.contextId, contextVersion = options.contextVersion, onContextLoaded = options.onContextLoaded;
-            var context = undefined;
-            var contextKey = "".concat(contextId);
-            // if a context version is supplied, key with the version encoded
-            if (contextVersion !== undefined) {
-                contextKey += "::".concat(contextVersion);
-            }
-            contextKey += ADAPTER_CONTEXT_ID_SUFFIX;
-            var contextAsPromise = reviveOrCreateContext(contextKey, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded);
-            return function (config, requestContext) {
-                if (context === undefined) {
-                    return contextAsPromise.then(function (revivedContext) {
-                        context = revivedContext;
-                        return adapter(config, context, requestContext); // TODO - remove as any cast after https://github.com/salesforce-experience-platform-emu/luvio/pull/230
-                    });
-                }
-                return adapter(config, context, requestContext);
-            };
-        };
-        var storeRedirect = function (existingKey, canonicalKey) {
-            validateNotDisposed();
-            // call redirect on staging store so "old" keys are removed from L2 on
-            // the next publishChangesToDurableStore.  NOTE: we don't need to call
-            // redirect on the base environment store because staging store and base
-            // L1 store share the same redirect and reverseRedirectKeys
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            ingestStagingStore.redirect(existingKey, canonicalKey);
-        };
-        var storeSetTTLOverride = function (namespace, representationName, ttl) {
-            validateNotDisposed();
-            return Promise.all([
-                environment.storeSetTTLOverride(namespace, representationName, ttl),
-                durableTTLStore.setDurableTTLOverride(namespace, representationName, ttl),
-            ]).then();
-        };
-        var storeSetDefaultTTLOverride = function (ttl) {
-            validateNotDisposed();
-            return Promise.all([
-                environment.storeSetDefaultTTLOverride(ttl),
-                durableTTLStore.setDefaultDurableTTLOverrides(ttl),
-            ]).then();
-        };
-        var getDurableTTLOverrides = function () {
-            validateNotDisposed();
-            return durableTTLStore.getDurableTTLOverrides();
-        };
-        var dispatchResourceRequest = function (request, context, eventObservers) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            validateNotDisposed();
-                            if (!(initializationPromise !== undefined)) return [3 /*break*/, 2];
-                            return [4 /*yield*/, initializationPromise];
-                        case 1:
-                            _a.sent();
-                            _a.label = 2;
-                        case 2: return [2 /*return*/, environment.dispatchResourceRequest(request, context, eventObservers)];
-                    }
-                });
-            });
-        };
-        // NOTE: we can't use "async" keyword on this function because that would
-        // force it to always be an async response.  The signature is a union
-        // of sync/async so no "awaiting" in this function, just promise-chaining
-        var applyCachePolicy = function (luvio, adapterRequestContext, buildSnapshotContext, buildCachedSnapshot, buildNetworkSnapshot) {
-            validateNotDisposed();
-            var wrappedCacheLookup = function (injectedBuildSnapshotContext, injectedStoreLookup) {
-                var snapshot = buildCachedSnapshot(injectedBuildSnapshotContext, injectedStoreLookup, luvio);
-                // if the adapter attempted to do an L1 lookup and it was unfulfilled
-                // then we can attempt an L2 lookup
-                if (isUnfulfilledSnapshot(snapshot)) {
-                    var start_1 = Date.now();
-                    emitDurableEnvironmentAdapterEvent({ type: 'l2-revive-start' }, adapterRequestContext.eventObservers);
-                    var revivedSnapshot = reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, function () { return injectedStoreLookup(snapshot.select, snapshot.refresh); }).then(function (result) {
-                        emitDurableEnvironmentAdapterEvent({
-                            type: 'l2-revive-end',
-                            snapshot: result.snapshot,
-                            duration: Date.now() - start_1,
-                            l2Trips: result.metrics.l2Trips,
-                        }, adapterRequestContext.eventObservers);
-                        return result.snapshot;
-                    });
-                    return revivedSnapshot;
-                }
-                // otherwise just return what buildCachedSnapshot gave us
-                return snapshot;
-            };
-            var wrappedApplyCachePolicy = function () {
-                return environment.applyCachePolicy(luvio, adapterRequestContext, buildSnapshotContext, wrappedCacheLookup, buildNetworkSnapshot);
-            };
-            // GET adapters call applyCachePolicy before any other luvio
-            // function so this is our chance to ensure we're initialized
-            return initializationPromise !== undefined
-                ? initializationPromise.then(wrappedApplyCachePolicy)
-                : wrappedApplyCachePolicy();
-        };
-        var getIngestStagingStoreRecords = function () {
-            validateNotDisposed();
-            if (ingestStagingStore !== null) {
-                return ingestStagingStore.fallbackStringKeyInMemoryStore.records;
-            }
-            return {};
-        };
-        var getIngestStagingStoreMetadata = function () {
-            validateNotDisposed();
-            if (ingestStagingStore !== null) {
-                return ingestStagingStore.fallbackStringKeyInMemoryStore.metadata;
-            }
-            return {};
-        };
-        var handleSuccessResponse = function (ingestAndBroadcastFunc, getResponseCacheKeysFunc) {
-            return __awaiter(this, void 0, void 0, function () {
-                var cacheKeyMap, cacheKeyMapKeys, keysToRevive, _i, cacheKeyMapKeys_1, cacheKeyMapKey, cacheKey, snapshotFromMemoryIngest, keysToReviveAsArray, readWritePromise, _a, keysToReviveAsArray_1, key, _b, keysToReviveAsArray_2, key, pendingPromise, _c, select, refresh, result;
-                var _this = this;
-                return __generator(this, function (_d) {
-                    switch (_d.label) {
-                        case 0:
-                            validateNotDisposed();
-                            cacheKeyMap = getResponseCacheKeysFunc();
-                            cacheKeyMapKeys = cacheKeyMap.keysAsArray();
-                            keysToRevive = new engine.StoreKeySet();
-                            for (_i = 0, cacheKeyMapKeys_1 = cacheKeyMapKeys; _i < cacheKeyMapKeys_1.length; _i++) {
-                                cacheKeyMapKey = cacheKeyMapKeys_1[_i];
-                                cacheKey = cacheKeyMap.get(cacheKeyMapKey);
-                                if (cacheKey.mergeable === true) {
-                                    keysToRevive.add(cacheKeyMapKey);
-                                }
-                            }
-                            snapshotFromMemoryIngest = undefined;
-                            keysToReviveAsArray = Array.from(keysToRevive.keysAsStrings());
-                            if (!(keysToReviveAsArray.length > 0)) return [3 /*break*/, 5];
-                            readWritePromise = (function () { return __awaiter(_this, void 0, void 0, function () {
-                                var pendingPromises, _i, keysToReviveAsArray_3, key, pendingPromise, entries;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            pendingPromises = [];
-                                            for (_i = 0, keysToReviveAsArray_3 = keysToReviveAsArray; _i < keysToReviveAsArray_3.length; _i++) {
-                                                key = keysToReviveAsArray_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(keysToReviveAsArray, DefaultDurableSegment)];
-                                        case 2:
-                                            entries = _a.sent();
-                                            ingestStagingStore = buildIngestStagingStore(environment);
-                                            publishDurableStoreEntries(entries, function (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 () { });
-                                            return [4 /*yield*/, ingestAndBroadcastFunc()];
-                                        case 3:
-                                            snapshotFromMemoryIngest = _a.sent();
-                                            return [2 /*return*/];
-                                    }
-                                });
-                            }); })();
-                            for (_a = 0, keysToReviveAsArray_1 = keysToReviveAsArray; _a < keysToReviveAsArray_1.length; _a++) {
-                                key = keysToReviveAsArray_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, keysToReviveAsArray_2 = keysToReviveAsArray; _b < keysToReviveAsArray_2.length; _b++) {
-                                key = keysToReviveAsArray_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);
-                            return [4 /*yield*/, ingestAndBroadcastFunc()];
-                        case 6:
-                            snapshotFromMemoryIngest = _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];
-                    }
-                });
-            });
-        };
-        var handleErrorResponse = function (ingestAndBroadcastFunc) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    validateNotDisposed();
-                    ingestStagingStore = buildIngestStagingStore(environment);
-                    return [2 /*return*/, ingestAndBroadcastFunc()];
-                });
-            });
-        };
-        var getNotifyChangeStoreEntries = function (keys) {
-            validateNotDisposed();
-            return durableStore
-                .getEntries(keys.map(engine.serializeStructuredKey), DefaultDurableSegment)
-                .then(function (durableRecords) {
-                var entries = [];
-                publishDurableStoreEntries(durableRecords, function (key, record) {
-                    entries.push({
-                        key: key,
-                        record: record,
-                    });
-                }, function () { });
-                return entries;
-            });
-        };
-        environment.defaultCachePolicy = {
-            type: 'stale-while-revalidate',
-            implementation: engine.buildStaleWhileRevalidateImplementation(Number.MAX_SAFE_INTEGER),
-        };
-        return create(environment, {
-            publishStoreMetadata: { value: publishStoreMetadata },
-            storeIngest: { value: storeIngest },
-            storeIngestError: { value: storeIngestError },
-            storeBroadcast: { value: storeBroadcast },
-            storeLookup: { value: storeLookup },
-            storeEvict: { value: storeEvict },
-            wrapNormalizedGraphNode: { value: wrapNormalizedGraphNode },
-            getNode: { value: getNode },
-            rebuildSnapshot: { value: rebuildSnapshot },
-            withContext: { value: withContext },
-            storeSetTTLOverride: { value: storeSetTTLOverride },
-            storeSetDefaultTTLOverride: { value: storeSetDefaultTTLOverride },
-            storePublish: { value: storePublish },
-            storeRedirect: { value: storeRedirect },
-            dispose: { value: dispose },
-            publishChangesToDurableStore: { value: publishChangesToDurableStore },
-            getDurableTTLOverrides: { value: getDurableTTLOverrides },
-            dispatchResourceRequest: { value: dispatchResourceRequest },
-            applyCachePolicy: { value: applyCachePolicy },
-            getIngestStagingStoreRecords: { value: getIngestStagingStoreRecords },
-            getIngestStagingStoreMetadata: { value: getIngestStagingStoreMetadata },
-            handleSuccessResponse: { value: handleSuccessResponse },
-            handleErrorResponse: { value: handleErrorResponse },
-            getNotifyChangeStoreEntries: { value: getNotifyChangeStoreEntries },
-        });
+    var AdapterContextSegment = 'ADAPTER-CONTEXT';
+    var ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
+    function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded) {
+        return __awaiter(this, void 0, void 0, function () {
+            var context, contextReturn, entries, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // initialize empty context store
+                        contextStores[adapterId] = create(null);
+                        context = {
+                            set: function (key, value) {
+                                var _a;
+                                contextStores[adapterId][key] = value;
+                                durableStore.setEntries((_a = {},
+                                    _a[adapterId] = { data: contextStores[adapterId] },
+                                    _a), AdapterContextSegment);
+                                pendingContextStoreKeys.add(adapterId);
+                            },
+                            get: function (key) {
+                                return contextStores[adapterId][key];
+                            },
+                        };
+                        contextReturn = function () {
+                            if (onContextLoaded !== undefined) {
+                                return onContextLoaded(context).then(function () {
+                                    return context;
+                                });
+                            }
+                            return context;
+                        };
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, durableStore.getEntries([adapterId], AdapterContextSegment)];
+                    case 2:
+                        entries = _a.sent();
+                        if (entries !== undefined && entries[adapterId] !== undefined) {
+                            // if durable store has a saved context then load it in the store
+                            contextStores[adapterId] = entries[adapterId].data;
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_1 = _a.sent();
+                        durableStoreErrorHandler(error_1);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/, contextReturn()];
+                }
+            });
+        });
+    }
+    function isUnfulfilledSnapshot(cachedSnapshotResult) {
+        if (cachedSnapshotResult === undefined) {
+            return false;
+        }
+        if ('then' in cachedSnapshotResult) {
+            return false;
+        }
+        return cachedSnapshotResult.state === 'Unfulfilled';
+    }
+    /**
+     * Configures the environment to persist data into a durable store and attempt to resolve
+     * data from the persistent store before hitting the network.
+     *
+     * @param environment The base environment
+     * @param durableStore A DurableStore implementation
+     * @param instrumentation An instrumentation function implementation
+     */
+    function makeDurable(environment, _a) {
+        var _this = this;
+        var durableStore = _a.durableStore, instrumentation = _a.instrumentation;
+        var ingestStagingStore = null;
+        var durableTTLStore = new DurableTTLStore(durableStore);
+        var mergeKeysPromiseMap = new engine.StoreKeyMap();
+        // When a context store is mutated we write it to L2, which causes DS on change
+        // event. If this instance of makeDurable caused that L2 write we can ignore that
+        // on change event. This Set helps us do that.
+        var pendingContextStoreKeys = new Set();
+        var contextStores = create(null);
+        var initializationPromise = new Promise(function (resolve) {
+            var finish = function () {
+                resolve();
+                initializationPromise = undefined;
+            };
+            reviveTTLOverrides(durableTTLStore, environment).then(finish);
+        });
+        //instrumentation for durable store errors
+        var durableStoreErrorHandler = handleDurableStoreRejection(instrumentation);
+        var disposed = false;
+        var validateNotDisposed = function () {
+            if (disposed === true) {
+                throw new Error('This makeDurable instance has been disposed');
+            }
+        };
+        var unsubscribe = durableStore.registerOnChangedListener(function (changes) { return __awaiter(_this, void 0, void 0, function () {
+            var defaultSegmentKeys, adapterContextSegmentKeys, i, len, change, adapterContextKeysFromDifferentInstance, _i, adapterContextSegmentKeys_1, key, entries, entryKeys, i, len, entryKey, entry, error_2, defaultSegmentKeysLength, i, key, canonical;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        defaultSegmentKeys = [];
+                        adapterContextSegmentKeys = [];
+                        for (i = 0, len = changes.length; i < len; i++) {
+                            change = changes[i];
+                            // we only care about changes to the data which is stored in the default
+                            // segment or the adapter context
+                            if (change.segment === DefaultDurableSegment) {
+                                defaultSegmentKeys.push.apply(defaultSegmentKeys, change.ids);
+                            }
+                            else if (change.segment === AdapterContextSegment) {
+                                adapterContextSegmentKeys.push.apply(adapterContextSegmentKeys, change.ids);
+                            }
+                        }
+                        adapterContextKeysFromDifferentInstance = [];
+                        for (_i = 0, adapterContextSegmentKeys_1 = adapterContextSegmentKeys; _i < adapterContextSegmentKeys_1.length; _i++) {
+                            key = adapterContextSegmentKeys_1[_i];
+                            if (pendingContextStoreKeys.has(key)) {
+                                // if this instance caused the L2 write then remove from the
+                                // "pending" Set and move on
+                                pendingContextStoreKeys.delete(key);
+                            }
+                            else {
+                                // else it came from another luvio instance and we need to
+                                // read from L2
+                                adapterContextKeysFromDifferentInstance.push(key);
+                            }
+                        }
+                        if (!(adapterContextKeysFromDifferentInstance.length > 0)) return [3 /*break*/, 4];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, durableStore.getEntries(adapterContextKeysFromDifferentInstance, AdapterContextSegment)];
+                    case 2:
+                        entries = _a.sent();
+                        if (entries !== undefined) {
+                            entryKeys = keys(entries);
+                            for (i = 0, len = entryKeys.length; i < len; i++) {
+                                entryKey = entryKeys[i];
+                                entry = entries[entryKey];
+                                contextStores[entryKey] = entry.data;
+                            }
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_2 = _a.sent();
+                        durableStoreErrorHandler(error_2);
+                        return [3 /*break*/, 4];
+                    case 4:
+                        defaultSegmentKeysLength = defaultSegmentKeys.length;
+                        if (!(defaultSegmentKeysLength > 0)) return [3 /*break*/, 6];
+                        for (i = 0; i < defaultSegmentKeysLength; i++) {
+                            key = defaultSegmentKeys[i];
+                            canonical = environment.storeGetCanonicalKey(key);
+                            if (canonical !== key) {
+                                continue;
+                            }
+                            // TODO: W-8909393 If expiration is the only thing that changed we should not evict the data... so
+                            // if we stored expiration and data at different keys (or same keys in different segments)
+                            // then we could know if only the expiration has changed and we wouldn't need to evict
+                            // and go through an entire broadcast/revive cycle for unchanged data
+                            // call base environment storeEvict so this evict is not tracked for durable deletion
+                            environment.storeEvict(key);
+                        }
+                        return [4 /*yield*/, environment.storeBroadcast(rebuildSnapshot, environment.snapshotAvailable)];
+                    case 5:
+                        _a.sent();
+                        _a.label = 6;
+                    case 6: return [2 /*return*/];
+                }
+            });
+        }); });
+        var dispose = function () {
+            validateNotDisposed();
+            disposed = true;
+            return unsubscribe();
+        };
+        var storePublish = function (key, data) {
+            validateNotDisposed();
+            if (ingestStagingStore === null) {
+                ingestStagingStore = buildIngestStagingStore(environment);
+            }
+            ingestStagingStore.publish(key, data);
+            // remove record from main luvio L1 cache while we are on the synchronous path
+            // because we do not want some other code attempting to use the
+            // in-memory values before the durable store onChanged handler
+            // calls back and revives the values to in-memory
+            environment.storeEvict(key);
+        };
+        var publishStoreMetadata = function (recordId, storeMetadata) {
+            validateNotDisposed();
+            if (ingestStagingStore === null) {
+                ingestStagingStore = buildIngestStagingStore(environment);
+            }
+            ingestStagingStore.publishMetadata(recordId, storeMetadata);
+        };
+        var storeIngest = function (key, ingest, response, luvio) {
+            validateNotDisposed();
+            // we don't ingest to the luvio L1 store from network directly, we ingest to
+            // L2 and let DurableStore on change event revive keys into luvio L1 store
+            if (ingestStagingStore === null) {
+                ingestStagingStore = buildIngestStagingStore(environment);
+            }
+            environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
+        };
+        var storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
+            validateNotDisposed();
+            if (ingestStagingStore === null) {
+                ingestStagingStore = buildIngestStagingStore(environment);
+            }
+            environment.storeIngestError(key, errorSnapshot, storeMetadataParams, ingestStagingStore);
+        };
+        var storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
+            validateNotDisposed();
+            // publishing to L2 is essentially "broadcasting" because the onChanged
+            // handler will fire which will revive records to the main L1 store and
+            // call the base storeBroadcast
+            return publishChangesToDurableStore();
+        };
+        var publishChangesToDurableStore = function () {
+            validateNotDisposed();
+            if (ingestStagingStore === null) {
+                return Promise.resolve();
+            }
+            var promise = flushInMemoryStoreValuesToDurableStore(ingestStagingStore, durableStore, durableStoreErrorHandler);
+            ingestStagingStore = null;
+            return promise;
+        };
+        var storeLookup = function (sel, createSnapshot, refresh, ttlStrategy) {
+            validateNotDisposed();
+            // if this lookup is right after an ingest there will be a staging store
+            if (ingestStagingStore !== null) {
+                var reader = new engine.Reader(ingestStagingStore, sel.variables, refresh, undefined, ttlStrategy);
+                return reader.read(sel);
+            }
+            // otherwise this is from buildCachedSnapshot and we should use the luvio
+            // L1 store
+            return environment.storeLookup(sel, createSnapshot, refresh, ttlStrategy);
+        };
+        var storeEvict = function (key) {
+            validateNotDisposed();
+            if (ingestStagingStore === null) {
+                ingestStagingStore = buildIngestStagingStore(environment);
+            }
+            ingestStagingStore.evict(key);
+        };
+        var getNode = function (key) {
+            validateNotDisposed();
+            if (ingestStagingStore === null) {
+                ingestStagingStore = buildIngestStagingStore(environment);
+            }
+            return environment.getNode(key, ingestStagingStore);
+        };
+        var wrapNormalizedGraphNode = function (normalized) {
+            validateNotDisposed();
+            if (ingestStagingStore === null) {
+                ingestStagingStore = buildIngestStagingStore(environment);
+            }
+            return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
+        };
+        var rebuildSnapshot = function (snapshot, onRebuild) {
+            validateNotDisposed();
+            // try rebuilding from memory
+            environment.rebuildSnapshot(snapshot, function (rebuilt) {
+                // only try reviving from durable store if snapshot is unfulfilled
+                if (rebuilt.state !== 'Unfulfilled') {
+                    onRebuild(rebuilt);
+                    return;
+                }
+                // Do an L2 revive and emit to subscriber using the callback.
+                reviveSnapshot(environment, durableStore, rebuilt, durableStoreErrorHandler, function () {
+                    // reviveSnapshot will revive into L1, and since "records" is a reference
+                    // (and not a copy) to the L1 records we can use it for rebuild
+                    var rebuiltSnap;
+                    environment.rebuildSnapshot(snapshot, function (rebuilt) {
+                        rebuiltSnap = rebuilt;
+                    });
+                    return rebuiltSnap;
+                }).then(function (result) {
+                    onRebuild(result.snapshot);
+                });
+            });
+        };
+        var withContext = function (adapter, options) {
+            validateNotDisposed();
+            var contextId = options.contextId, contextVersion = options.contextVersion, onContextLoaded = options.onContextLoaded;
+            var context = undefined;
+            var contextKey = "".concat(contextId);
+            // if a context version is supplied, key with the version encoded
+            if (contextVersion !== undefined) {
+                contextKey += "::".concat(contextVersion);
+            }
+            contextKey += ADAPTER_CONTEXT_ID_SUFFIX;
+            var contextAsPromise = reviveOrCreateContext(contextKey, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded);
+            return function (config, requestContext) {
+                if (context === undefined) {
+                    return contextAsPromise.then(function (revivedContext) {
+                        context = revivedContext;
+                        return adapter(config, context, requestContext); // TODO - remove as any cast after https://github.com/salesforce-experience-platform-emu/luvio/pull/230
+                    });
+                }
+                return adapter(config, context, requestContext);
+            };
+        };
+        var storeRedirect = function (existingKey, canonicalKey) {
+            validateNotDisposed();
+            // call redirect on staging store so "old" keys are removed from L2 on
+            // the next publishChangesToDurableStore.  NOTE: we don't need to call
+            // redirect on the base environment store because staging store and base
+            // L1 store share the same redirect and reverseRedirectKeys
+            if (ingestStagingStore === null) {
+                ingestStagingStore = buildIngestStagingStore(environment);
+            }
+            ingestStagingStore.redirect(existingKey, canonicalKey);
+        };
+        var storeSetTTLOverride = function (namespace, representationName, ttl) {
+            validateNotDisposed();
+            return Promise.all([
+                environment.storeSetTTLOverride(namespace, representationName, ttl),
+                durableTTLStore.setDurableTTLOverride(namespace, representationName, ttl),
+            ]).then();
+        };
+        var storeSetDefaultTTLOverride = function (ttl) {
+            validateNotDisposed();
+            return Promise.all([
+                environment.storeSetDefaultTTLOverride(ttl),
+                durableTTLStore.setDefaultDurableTTLOverrides(ttl),
+            ]).then();
+        };
+        var getDurableTTLOverrides = function () {
+            validateNotDisposed();
+            return durableTTLStore.getDurableTTLOverrides();
+        };
+        var dispatchResourceRequest = function (request, context, eventObservers) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            validateNotDisposed();
+                            if (!(initializationPromise !== undefined)) return [3 /*break*/, 2];
+                            return [4 /*yield*/, initializationPromise];
+                        case 1:
+                            _a.sent();
+                            _a.label = 2;
+                        case 2: return [2 /*return*/, environment.dispatchResourceRequest(request, context, eventObservers)];
+                    }
+                });
+            });
+        };
+        // NOTE: we can't use "async" keyword on this function because that would
+        // force it to always be an async response.  The signature is a union
+        // of sync/async so no "awaiting" in this function, just promise-chaining
+        var applyCachePolicy = function (luvio, adapterRequestContext, buildSnapshotContext, buildCachedSnapshot, buildNetworkSnapshot) {
+            validateNotDisposed();
+            var wrappedCacheLookup = function (injectedBuildSnapshotContext, injectedStoreLookup) {
+                var snapshot = buildCachedSnapshot(injectedBuildSnapshotContext, injectedStoreLookup, luvio);
+                // if the adapter attempted to do an L1 lookup and it was unfulfilled
+                // then we can attempt an L2 lookup
+                if (isUnfulfilledSnapshot(snapshot)) {
+                    var start_1 = Date.now();
+                    emitDurableEnvironmentAdapterEvent({ type: 'l2-revive-start' }, adapterRequestContext.eventObservers);
+                    var revivedSnapshot = reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, function () { return injectedStoreLookup(snapshot.select, snapshot.refresh); }).then(function (result) {
+                        emitDurableEnvironmentAdapterEvent({
+                            type: 'l2-revive-end',
+                            snapshot: result.snapshot,
+                            duration: Date.now() - start_1,
+                            l2Trips: result.metrics.l2Trips,
+                        }, adapterRequestContext.eventObservers);
+                        return result.snapshot;
+                    });
+                    return revivedSnapshot;
+                }
+                // otherwise just return what buildCachedSnapshot gave us
+                return snapshot;
+            };
+            var wrappedApplyCachePolicy = function () {
+                return environment.applyCachePolicy(luvio, adapterRequestContext, buildSnapshotContext, wrappedCacheLookup, buildNetworkSnapshot);
+            };
+            // GET adapters call applyCachePolicy before any other luvio
+            // function so this is our chance to ensure we're initialized
+            return initializationPromise !== undefined
+                ? initializationPromise.then(wrappedApplyCachePolicy)
+                : wrappedApplyCachePolicy();
+        };
+        var getIngestStagingStoreRecords = function () {
+            validateNotDisposed();
+            if (ingestStagingStore !== null) {
+                return ingestStagingStore.fallbackStringKeyInMemoryStore.records;
+            }
+            return {};
+        };
+        var getIngestStagingStoreMetadata = function () {
+            validateNotDisposed();
+            if (ingestStagingStore !== null) {
+                return ingestStagingStore.fallbackStringKeyInMemoryStore.metadata;
+            }
+            return {};
+        };
+        var handleSuccessResponse = function (ingestAndBroadcastFunc, getResponseCacheKeysFunc) {
+            return __awaiter(this, void 0, void 0, function () {
+                var cacheKeyMap, cacheKeyMapKeys, keysToRevive, _i, cacheKeyMapKeys_1, cacheKeyMapKey, cacheKey, snapshotFromMemoryIngest, keysToReviveAsArray, readWritePromise, _a, keysToReviveAsArray_1, key, _b, keysToReviveAsArray_2, key, pendingPromise, _c, select, refresh, result;
+                var _this = this;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            validateNotDisposed();
+                            cacheKeyMap = getResponseCacheKeysFunc();
+                            cacheKeyMapKeys = cacheKeyMap.keysAsArray();
+                            keysToRevive = new engine.StoreKeySet();
+                            for (_i = 0, cacheKeyMapKeys_1 = cacheKeyMapKeys; _i < cacheKeyMapKeys_1.length; _i++) {
+                                cacheKeyMapKey = cacheKeyMapKeys_1[_i];
+                                cacheKey = cacheKeyMap.get(cacheKeyMapKey);
+                                if (cacheKey.mergeable === true) {
+                                    keysToRevive.add(cacheKeyMapKey);
+                                }
+                            }
+                            snapshotFromMemoryIngest = undefined;
+                            keysToReviveAsArray = Array.from(keysToRevive.keysAsStrings());
+                            if (!(keysToReviveAsArray.length > 0)) return [3 /*break*/, 5];
+                            readWritePromise = (function () { return __awaiter(_this, void 0, void 0, function () {
+                                var pendingPromises, _i, keysToReviveAsArray_3, key, pendingPromise, entries;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            pendingPromises = [];
+                                            for (_i = 0, keysToReviveAsArray_3 = keysToReviveAsArray; _i < keysToReviveAsArray_3.length; _i++) {
+                                                key = keysToReviveAsArray_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(keysToReviveAsArray, DefaultDurableSegment)];
+                                        case 2:
+                                            entries = _a.sent();
+                                            ingestStagingStore = buildIngestStagingStore(environment);
+                                            publishDurableStoreEntries(entries, function (key, record) {
+                                                if (typeof key === 'string') {
+                                                    ingestStagingStore.fallbackStringKeyInMemoryStore.records[key] =
+                                                        record;
+                                                }
+                                                else {
+                                                    ingestStagingStore.recordsMap.set(key, record);
+                                                }
+                                            }, function (key, metadata) {
+                                                if (typeof key === 'string') {
+                                                    ingestStagingStore.fallbackStringKeyInMemoryStore.metadata[key] =
+                                                        metadata;
+                                                }
+                                                else {
+                                                    ingestStagingStore.metadataMap.set(key, metadata);
+                                                }
+                                            });
+                                            return [4 /*yield*/, ingestAndBroadcastFunc()];
+                                        case 3:
+                                            snapshotFromMemoryIngest = _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); })();
+                            for (_a = 0, keysToReviveAsArray_1 = keysToReviveAsArray; _a < keysToReviveAsArray_1.length; _a++) {
+                                key = keysToReviveAsArray_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, keysToReviveAsArray_2 = keysToReviveAsArray; _b < keysToReviveAsArray_2.length; _b++) {
+                                key = keysToReviveAsArray_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);
+                            return [4 /*yield*/, ingestAndBroadcastFunc()];
+                        case 6:
+                            snapshotFromMemoryIngest = _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];
+                    }
+                });
+            });
+        };
+        var handleErrorResponse = function (ingestAndBroadcastFunc) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    validateNotDisposed();
+                    ingestStagingStore = buildIngestStagingStore(environment);
+                    return [2 /*return*/, ingestAndBroadcastFunc()];
+                });
+            });
+        };
+        var getNotifyChangeStoreEntries = function (keys) {
+            validateNotDisposed();
+            return durableStore
+                .getEntries(keys.map(engine.serializeStructuredKey), DefaultDurableSegment)
+                .then(function (durableRecords) {
+                var entries = [];
+                publishDurableStoreEntries(durableRecords, function (key, record) {
+                    entries.push({
+                        key: key,
+                        record: record,
+                    });
+                }, function () { });
+                return entries;
+            });
+        };
+        environment.defaultCachePolicy = {
+            type: 'stale-while-revalidate',
+            implementation: engine.buildStaleWhileRevalidateImplementation(Number.MAX_SAFE_INTEGER),
+        };
+        return create(environment, {
+            publishStoreMetadata: { value: publishStoreMetadata },
+            storeIngest: { value: storeIngest },
+            storeIngestError: { value: storeIngestError },
+            storeBroadcast: { value: storeBroadcast },
+            storeLookup: { value: storeLookup },
+            storeEvict: { value: storeEvict },
+            wrapNormalizedGraphNode: { value: wrapNormalizedGraphNode },
+            getNode: { value: getNode },
+            rebuildSnapshot: { value: rebuildSnapshot },
+            withContext: { value: withContext },
+            storeSetTTLOverride: { value: storeSetTTLOverride },
+            storeSetDefaultTTLOverride: { value: storeSetDefaultTTLOverride },
+            storePublish: { value: storePublish },
+            storeRedirect: { value: storeRedirect },
+            dispose: { value: dispose },
+            publishChangesToDurableStore: { value: publishChangesToDurableStore },
+            getDurableTTLOverrides: { value: getDurableTTLOverrides },
+            dispatchResourceRequest: { value: dispatchResourceRequest },
+            applyCachePolicy: { value: applyCachePolicy },
+            getIngestStagingStoreRecords: { value: getIngestStagingStoreRecords },
+            getIngestStagingStoreMetadata: { value: getIngestStagingStoreMetadata },
+            handleSuccessResponse: { value: handleSuccessResponse },
+            handleErrorResponse: { value: handleErrorResponse },
+            getNotifyChangeStoreEntries: { value: getNotifyChangeStoreEntries },
+        });
     }
 
     exports.DURABLE_METADATA_VERSION = DURABLE_METADATA_VERSION;