@luvio/environments 0.138.0 → 0.138.2

package/dist/umd/es2018/environments.js

@@ -4,880 +4,886 @@
     (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
-    const DURABLE_METADATA_VERSION = '0.111.0';
-    function isDeprecatedDurableStoreEntry(durableRecord) {
-        if (durableRecord.expiration !== undefined) {
-            return true;
-        }
-        const metadata = durableRecord.metadata;
-        if (metadata !== undefined) {
-            const { metadataVersion } = metadata;
-            // 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
+    const DURABLE_METADATA_VERSION = '0.111.0';
+    function isDeprecatedDurableStoreEntry(durableRecord) {
+        if (durableRecord.expiration !== undefined) {
+            return true;
+        }
+        const metadata = durableRecord.metadata;
+        if (metadata !== undefined) {
+            const { metadataVersion } = metadata;
+            // 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;
+    }
     const DefaultDurableSegment = 'DEFAULT';
 
-    const { keys, create, assign, freeze } = Object;
+    const { keys, create, assign, freeze } = Object;
     const { isArray } = Array;
 
-    //Durable store error instrumentation key
-    const 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 (error) => {
-            if (process.env.NODE_ENV !== 'production') {
-                throw error;
-            }
-            if (instrument !== undefined) {
-                instrument(() => {
-                    return {
-                        [DURABLE_STORE_ERROR]: true,
-                        error: error,
-                    };
-                });
-            }
-        };
+    //Durable store error instrumentation key
+    const 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 (error) => {
+            if (process.env.NODE_ENV !== 'production') {
+                throw error;
+            }
+            if (instrument !== undefined) {
+                instrument(() => {
+                    return {
+                        [DURABLE_STORE_ERROR]: true,
+                        error: error,
+                    };
+                });
+            }
+        };
     }
 
-    function deepFreeze(value) {
-        // No need to freeze primitives
-        if (typeof value !== 'object' || value === null) {
-            return;
-        }
-        if (isArray(value)) {
-            for (let i = 0, len = value.length; i < len; i += 1) {
-                deepFreeze(value[i]);
-            }
-        }
-        else {
-            const keys$1 = keys(value);
-            for (let 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 (let i = 0, len = value.length; i < len; i += 1) {
+                deepFreeze(value[i]);
+            }
+        }
+        else {
+            const keys$1 = keys(value);
+            for (let 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) {
-        const revivedKeys = new engine.StoreKeySet();
-        let hadUnexpectedShape = false;
-        if (durableRecords === undefined) {
-            return { revivedKeys, hadUnexpectedShape };
-        }
-        const durableKeys = keys(durableRecords);
-        if (durableKeys.length === 0) {
-            // no records to revive
-            return { revivedKeys, hadUnexpectedShape };
-        }
-        for (let i = 0, len = durableKeys.length; i < len; i += 1) {
-            const key = durableKeys[i];
-            const durableRecord = durableRecords[key];
-            if (isDeprecatedDurableStoreEntry(durableRecord)) {
-                // had the old shape, skip reviving this entry.
-                hadUnexpectedShape = true;
-                continue;
-            }
-            const { metadata, data } = durableRecord;
-            if (data === undefined) {
-                // if unexpected data skip reviving
-                hadUnexpectedShape = true;
-                continue;
-            }
-            if (metadata !== undefined) {
-                const { expirationTimestamp } = metadata;
-                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, 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 = { l2Trips: [] }) {
-        const { recordId, select, seenRecords, state } = unavailableSnapshot;
-        // 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
-        const keysToReviveSet = new engine.StoreKeySet().add(recordId);
-        keysToReviveSet.merge(seenRecords);
-        const keysToRevive = keysToReviveSet.keysAsArray();
-        const canonicalKeys = keysToRevive.map((x) => engine.serializeStructuredKey(baseEnvironment.storeGetCanonicalKey(x)));
-        const start = Date.now();
-        const { l2Trips } = reviveMetrics;
-        return durableStore.getEntries(canonicalKeys, DefaultDurableSegment).then((durableRecords) => {
-            l2Trips.push({
-                duration: Date.now() - start,
-                keysRequestedCount: canonicalKeys.length,
-            });
-            const { revivedKeys, hadUnexpectedShape } = 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));
-            // 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
-            const snapshot = buildL1Snapshot();
-            // if snapshot is pending then some other in-flight refresh will broadcast
-            // later
-            if (snapshot.state === 'Pending') {
-                return { snapshot, metrics: reviveMetrics };
-            }
-            if (snapshot.state === 'Unfulfilled') {
-                // have to check if the new snapshot has any additional seenRecords
-                // and revive again if so
-                const { seenRecords: newSnapshotSeenRecords, recordId: newSnapshotRecordId } = snapshot;
-                const newKeysToReviveSet = new engine.StoreKeySet();
-                newKeysToReviveSet.add(newSnapshotRecordId);
-                newKeysToReviveSet.merge(newSnapshotSeenRecords);
-                const newKeys = newKeysToReviveSet.keysAsArray();
-                // in case DS returned additional entries we combine the requested
-                // and returned keys
-                const alreadyRequestedOrRevivedSet = keysToReviveSet;
-                alreadyRequestedOrRevivedSet.merge(revivedKeys);
-                // if there's any seen keys in the newly rebuilt snapshot that
-                // haven't already been requested or returned then revive again
-                for (let i = 0, len = newKeys.length; i < len; i++) {
-                    const newSnapshotSeenKey = newKeys[i];
-                    if (!alreadyRequestedOrRevivedSet.has(newSnapshotSeenKey)) {
-                        return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics);
-                    }
-                }
-            }
-            return { snapshot, metrics: reviveMetrics };
-        }, (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) {
+        const revivedKeys = new engine.StoreKeySet();
+        let hadUnexpectedShape = false;
+        if (durableRecords === undefined) {
+            return { revivedKeys, hadUnexpectedShape };
+        }
+        const durableKeys = keys(durableRecords);
+        if (durableKeys.length === 0) {
+            // no records to revive
+            return { revivedKeys, hadUnexpectedShape };
+        }
+        for (let i = 0, len = durableKeys.length; i < len; i += 1) {
+            const key = durableKeys[i];
+            const durableRecord = durableRecords[key];
+            if (isDeprecatedDurableStoreEntry(durableRecord)) {
+                // had the old shape, skip reviving this entry.
+                hadUnexpectedShape = true;
+                continue;
+            }
+            const { metadata, data } = durableRecord;
+            if (data === undefined) {
+                // if unexpected data skip reviving
+                hadUnexpectedShape = true;
+                continue;
+            }
+            if (metadata !== undefined) {
+                const { expirationTimestamp } = metadata;
+                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, 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 = { l2Trips: [] }) {
+        const { recordId, select, seenRecords, state } = unavailableSnapshot;
+        // 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
+        const keysToReviveSet = new engine.StoreKeySet().add(recordId);
+        keysToReviveSet.merge(seenRecords);
+        const keysToRevive = keysToReviveSet.keysAsArray();
+        const canonicalKeys = keysToRevive.map((x) => engine.serializeStructuredKey(baseEnvironment.storeGetCanonicalKey(x)));
+        const start = Date.now();
+        const { l2Trips } = reviveMetrics;
+        return durableStore.getEntries(canonicalKeys, DefaultDurableSegment).then((durableRecords) => {
+            l2Trips.push({
+                duration: Date.now() - start,
+                keysRequestedCount: canonicalKeys.length,
+            });
+            const { revivedKeys, hadUnexpectedShape } = 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));
+            // 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
+            const snapshot = buildL1Snapshot();
+            // if snapshot is pending then some other in-flight refresh will broadcast
+            // later
+            if (snapshot.state === 'Pending') {
+                return { snapshot, metrics: reviveMetrics };
+            }
+            if (snapshot.state === 'Unfulfilled') {
+                // have to check if the new snapshot has any additional seenRecords
+                // and revive again if so
+                const { seenRecords: newSnapshotSeenRecords, recordId: newSnapshotRecordId } = snapshot;
+                const newKeysToReviveSet = new engine.StoreKeySet();
+                newKeysToReviveSet.add(newSnapshotRecordId);
+                newKeysToReviveSet.merge(newSnapshotSeenRecords);
+                const newKeys = newKeysToReviveSet.keysAsArray();
+                // in case DS returned additional entries we combine the requested
+                // and returned keys
+                const alreadyRequestedOrRevivedSet = keysToReviveSet;
+                alreadyRequestedOrRevivedSet.merge(revivedKeys);
+                // if there's any seen keys in the newly rebuilt snapshot that
+                // haven't already been requested or returned then revive again
+                for (let i = 0, len = newKeys.length; i < len; i++) {
+                    const newSnapshotSeenKey = newKeys[i];
+                    if (!alreadyRequestedOrRevivedSet.has(newSnapshotSeenKey)) {
+                        return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics);
+                    }
+                }
+            }
+            return { snapshot, metrics: reviveMetrics };
+        }, (error) => {
+            durableStoreErrorHandler(error);
+            // getEntries failed, return the L1 snapshot
+            return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
+        });
     }
 
-    const TTL_DURABLE_SEGMENT = 'TTL_DURABLE_SEGMENT';
-    const TTL_DEFAULT_KEY = 'TTL_DEFAULT_KEY';
-    function buildDurableTTLOverrideStoreKey(namespace, representationName) {
-        return `${namespace}::${representationName}`;
-    }
-    function isEntryDurableTTLOverride(entry) {
-        if (typeof entry === 'object' && entry !== undefined && entry !== null) {
-            const 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
-     */
-    class DurableTTLStore {
-        constructor(durableStore) {
-            this.durableStore = durableStore;
-        }
-        setDefaultDurableTTLOverrides(ttl) {
-            return this.durableStore.setEntries({
-                [buildDurableTTLOverrideStoreKey(TTL_DEFAULT_KEY, TTL_DEFAULT_KEY)]: {
-                    data: {
-                        namespace: TTL_DEFAULT_KEY,
-                        representationName: TTL_DEFAULT_KEY,
-                        ttl,
-                    },
-                },
-            }, TTL_DURABLE_SEGMENT);
-        }
-        setDurableTTLOverride(namespace, representationName, ttl) {
-            return this.durableStore.setEntries({
-                [buildDurableTTLOverrideStoreKey(namespace, representationName)]: {
-                    data: { namespace, representationName, ttl },
-                },
-            }, TTL_DURABLE_SEGMENT);
-        }
-        getDurableTTLOverrides() {
-            return this.durableStore
-                .getAllEntries(TTL_DURABLE_SEGMENT)
-                .then((entries) => {
-                const overrides = [];
-                let defaultTTL = undefined;
-                if (entries === undefined) {
-                    return {
-                        defaultTTL,
-                        overrides,
-                    };
-                }
-                const keys$1 = keys(entries);
-                for (let i = 0, len = keys$1.length; i < len; i++) {
-                    const key = keys$1[i];
-                    const entry = entries[key];
-                    if (entry !== undefined && isEntryDurableTTLOverride(entry)) {
-                        if (isDefaultDurableTTLOverride(entry.data)) {
-                            defaultTTL = entry.data;
-                        }
-                        else {
-                            overrides.push(entry.data);
-                        }
-                    }
-                }
-                return {
-                    defaultTTL,
-                    overrides,
-                };
-            });
-        }
+    const TTL_DURABLE_SEGMENT = 'TTL_DURABLE_SEGMENT';
+    const TTL_DEFAULT_KEY = 'TTL_DEFAULT_KEY';
+    function buildDurableTTLOverrideStoreKey(namespace, representationName) {
+        return `${namespace}::${representationName}`;
+    }
+    function isEntryDurableTTLOverride(entry) {
+        if (typeof entry === 'object' && entry !== undefined && entry !== null) {
+            const 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
+     */
+    class DurableTTLStore {
+        constructor(durableStore) {
+            this.durableStore = durableStore;
+        }
+        setDefaultDurableTTLOverrides(ttl) {
+            return this.durableStore.setEntries({
+                [buildDurableTTLOverrideStoreKey(TTL_DEFAULT_KEY, TTL_DEFAULT_KEY)]: {
+                    data: {
+                        namespace: TTL_DEFAULT_KEY,
+                        representationName: TTL_DEFAULT_KEY,
+                        ttl,
+                    },
+                },
+            }, TTL_DURABLE_SEGMENT);
+        }
+        setDurableTTLOverride(namespace, representationName, ttl) {
+            return this.durableStore.setEntries({
+                [buildDurableTTLOverrideStoreKey(namespace, representationName)]: {
+                    data: { namespace, representationName, ttl },
+                },
+            }, TTL_DURABLE_SEGMENT);
+        }
+        getDurableTTLOverrides() {
+            return this.durableStore
+                .getAllEntries(TTL_DURABLE_SEGMENT)
+                .then((entries) => {
+                const overrides = [];
+                let defaultTTL = undefined;
+                if (entries === undefined) {
+                    return {
+                        defaultTTL,
+                        overrides,
+                    };
+                }
+                const keys$1 = keys(entries);
+                for (let i = 0, len = keys$1.length; i < len; i++) {
+                    const key = keys$1[i];
+                    const entry = entries[key];
+                    if (entry !== undefined && isEntryDurableTTLOverride(entry)) {
+                        if (isDefaultDurableTTLOverride(entry.data)) {
+                            defaultTTL = entry.data;
+                        }
+                        else {
+                            overrides.push(entry.data);
+                        }
+                    }
+                }
+                return {
+                    defaultTTL,
+                    overrides,
+                };
+            });
+        }
     }
 
-    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 [...source];
-        }
-        return { ...source };
-    }
-    function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler) {
-        const durableRecords = create(null);
-        const evictedRecords = create(null);
-        const { records, metadata: storeMetadata, visitedIds, refreshedIds, } = store.fallbackStringKeyInMemoryStore;
-        // 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
-        const keys$1 = keys({ ...visitedIds, ...refreshedIds });
-        for (let i = 0, len = keys$1.length; i < len; i += 1) {
-            const key = keys$1[i];
-            const record = records[key];
-            // this record has been evicted, evict from DS
-            if (record === undefined) {
-                evictedRecords[key] = true;
-                continue;
-            }
-            const 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 = {
-                    ...metadata,
-                    metadataVersion: DURABLE_METADATA_VERSION,
-                };
-            }
-        }
-        const durableStoreOperations = [];
-        // publishes
-        const recordKeys = keys(durableRecords);
-        if (recordKeys.length > 0) {
-            durableStoreOperations.push({
-                type: 'setEntries',
-                entries: durableRecords,
-                segment: DefaultDurableSegment,
-            });
-        }
-        // evicts
-        const 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 [...source];
+        }
+        return { ...source };
+    }
+    function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler) {
+        const durableRecords = create(null);
+        const evictedRecords = create(null);
+        const { records, metadata: storeMetadata, visitedIds, refreshedIds, } = store.fallbackStringKeyInMemoryStore;
+        // 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
+        const keys$1 = keys({ ...visitedIds, ...refreshedIds });
+        for (let i = 0, len = keys$1.length; i < len; i += 1) {
+            const key = keys$1[i];
+            const record = records[key];
+            // this record has been evicted, evict from DS
+            if (record === undefined) {
+                evictedRecords[key] = true;
+                continue;
+            }
+            const 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 = {
+                    ...metadata,
+                    metadataVersion: DURABLE_METADATA_VERSION,
+                };
+            }
+        }
+        const durableStoreOperations = [];
+        // publishes
+        const recordKeys = keys(durableRecords);
+        if (recordKeys.length > 0) {
+            durableStoreOperations.push({
+                type: 'setEntries',
+                entries: durableRecords,
+                segment: DefaultDurableSegment,
+            });
+        }
+        // evicts
+        const 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();
     }
 
-    const 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);
+    const 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);
     }
 
-    async function reviveTTLOverrides(ttlStore, environment) {
-        const map = await ttlStore.getDurableTTLOverrides();
-        const { defaultTTL, overrides } = map;
-        if (defaultTTL !== undefined) {
-            environment.storeSetDefaultTTLOverride(defaultTTL.ttl);
-        }
-        for (let i = 0, len = overrides.length; i < len; i++) {
-            const { namespace, representationName, ttl } = overrides[i];
-            environment.storeSetTTLOverride(namespace, representationName, ttl);
-        }
+    async function reviveTTLOverrides(ttlStore, environment) {
+        const map = await ttlStore.getDurableTTLOverrides();
+        const { defaultTTL, overrides } = map;
+        if (defaultTTL !== undefined) {
+            environment.storeSetDefaultTTLOverride(defaultTTL.ttl);
+        }
+        for (let i = 0, len = overrides.length; i < len; i++) {
+            const { namespace, representationName, ttl } = overrides[i];
+            environment.storeSetTTLOverride(namespace, representationName, ttl);
+        }
     }
 
-    /**
-     * 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();
     }
 
-    const AdapterContextSegment = 'ADAPTER-CONTEXT';
-    const ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
-    async function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded) {
-        // initialize empty context store
-        contextStores[adapterId] = create(null);
-        const context = {
-            set(key, value) {
-                contextStores[adapterId][key] = value;
-                durableStore.setEntries({
-                    [adapterId]: { data: contextStores[adapterId] },
-                }, AdapterContextSegment);
-                pendingContextStoreKeys.add(adapterId);
-            },
-            get(key) {
-                return contextStores[adapterId][key];
-            },
-        };
-        const contextReturn = () => {
-            if (onContextLoaded !== undefined) {
-                return onContextLoaded(context).then(() => {
-                    return context;
-                });
-            }
-            return context;
-        };
-        try {
-            const entries = await durableStore.getEntries([adapterId], AdapterContextSegment);
-            if (entries !== undefined && entries[adapterId] !== undefined) {
-                // if durable store has a saved context then load it in the store
-                contextStores[adapterId] = entries[adapterId].data;
-            }
-        }
-        catch (error) {
-            durableStoreErrorHandler(error);
-        }
-        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, { durableStore, instrumentation }) {
-        let ingestStagingStore = null;
-        const durableTTLStore = new DurableTTLStore(durableStore);
-        const 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.
-        const pendingContextStoreKeys = new Set();
-        const contextStores = create(null);
-        let initializationPromise = new Promise((resolve) => {
-            const finish = () => {
-                resolve();
-                initializationPromise = undefined;
-            };
-            reviveTTLOverrides(durableTTLStore, environment).then(finish);
-        });
-        //instrumentation for durable store errors
-        const durableStoreErrorHandler = handleDurableStoreRejection(instrumentation);
-        let disposed = false;
-        const validateNotDisposed = () => {
-            if (disposed === true) {
-                throw new Error('This makeDurable instance has been disposed');
-            }
-        };
-        const unsubscribe = durableStore.registerOnChangedListener(async (changes) => {
-            const defaultSegmentKeys = [];
-            const adapterContextSegmentKeys = [];
-            for (let i = 0, len = changes.length; i < len; i++) {
-                const 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(...change.ids);
-                }
-                else if (change.segment === AdapterContextSegment) {
-                    adapterContextSegmentKeys.push(...change.ids);
-                }
-            }
-            // process adapter context changes
-            const adapterContextKeysFromDifferentInstance = [];
-            for (const key of adapterContextSegmentKeys) {
-                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) {
-                try {
-                    const entries = await durableStore.getEntries(adapterContextKeysFromDifferentInstance, AdapterContextSegment);
-                    if (entries !== undefined) {
-                        const entryKeys = keys(entries);
-                        for (let i = 0, len = entryKeys.length; i < len; i++) {
-                            const entryKey = entryKeys[i];
-                            const entry = entries[entryKey];
-                            contextStores[entryKey] = entry.data;
-                        }
-                    }
-                }
-                catch (error) {
-                    durableStoreErrorHandler(error);
-                }
-            }
-            // process default segment changes
-            const defaultSegmentKeysLength = defaultSegmentKeys.length;
-            if (defaultSegmentKeysLength > 0) {
-                for (let i = 0; i < defaultSegmentKeysLength; i++) {
-                    const key = defaultSegmentKeys[i];
-                    const 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);
-                }
-                await environment.storeBroadcast(rebuildSnapshot, environment.snapshotAvailable);
-            }
-        });
-        const dispose = function () {
-            validateNotDisposed();
-            disposed = true;
-            return unsubscribe();
-        };
-        const 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);
-        };
-        const publishStoreMetadata = function (recordId, storeMetadata) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            ingestStagingStore.publishMetadata(recordId, storeMetadata);
-        };
-        const 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);
-        };
-        const storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            environment.storeIngestError(key, errorSnapshot, storeMetadataParams, ingestStagingStore);
-        };
-        const 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();
-        };
-        const publishChangesToDurableStore = function () {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                return Promise.resolve();
-            }
-            const promise = flushInMemoryStoreValuesToDurableStore(ingestStagingStore, durableStore, durableStoreErrorHandler);
-            ingestStagingStore = null;
-            return promise;
-        };
-        const storeLookup = function (sel, createSnapshot, refresh, ttlStrategy) {
-            validateNotDisposed();
-            // if this lookup is right after an ingest there will be a staging store
-            if (ingestStagingStore !== null) {
-                const 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);
-        };
-        const storeEvict = function (key) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            ingestStagingStore.evict(key);
-        };
-        const getNode = function (key) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            return environment.getNode(key, ingestStagingStore);
-        };
-        const wrapNormalizedGraphNode = function (normalized) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
-        };
-        const rebuildSnapshot = function (snapshot, onRebuild) {
-            validateNotDisposed();
-            // try rebuilding from memory
-            environment.rebuildSnapshot(snapshot, (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, () => {
-                    // 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
-                    let rebuiltSnap;
-                    environment.rebuildSnapshot(snapshot, (rebuilt) => {
-                        rebuiltSnap = rebuilt;
-                    });
-                    return rebuiltSnap;
-                }).then((result) => {
-                    onRebuild(result.snapshot);
-                });
-            });
-        };
-        const withContext = function (adapter, options) {
-            validateNotDisposed();
-            const { contextId, contextVersion, onContextLoaded } = options;
-            let context = undefined;
-            let contextKey = `${contextId}`;
-            // if a context version is supplied, key with the version encoded
-            if (contextVersion !== undefined) {
-                contextKey += `::${contextVersion}`;
-            }
-            contextKey += ADAPTER_CONTEXT_ID_SUFFIX;
-            const contextAsPromise = reviveOrCreateContext(contextKey, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded);
-            return (config, requestContext) => {
-                if (context === undefined) {
-                    return contextAsPromise.then((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);
-            };
-        };
-        const 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);
-        };
-        const storeSetTTLOverride = function (namespace, representationName, ttl) {
-            validateNotDisposed();
-            return Promise.all([
-                environment.storeSetTTLOverride(namespace, representationName, ttl),
-                durableTTLStore.setDurableTTLOverride(namespace, representationName, ttl),
-            ]).then();
-        };
-        const storeSetDefaultTTLOverride = function (ttl) {
-            validateNotDisposed();
-            return Promise.all([
-                environment.storeSetDefaultTTLOverride(ttl),
-                durableTTLStore.setDefaultDurableTTLOverrides(ttl),
-            ]).then();
-        };
-        const getDurableTTLOverrides = function () {
-            validateNotDisposed();
-            return durableTTLStore.getDurableTTLOverrides();
-        };
-        const dispatchResourceRequest = async function (request, context, eventObservers) {
-            validateNotDisposed();
-            // non-GET adapters call dispatchResourceRequest before any other luvio
-            // function so this is our chance to ensure we're initialized
-            if (initializationPromise !== undefined) {
-                await initializationPromise;
-            }
-            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
-        const applyCachePolicy = function (luvio, adapterRequestContext, buildSnapshotContext, buildCachedSnapshot, buildNetworkSnapshot) {
-            validateNotDisposed();
-            const wrappedCacheLookup = (injectedBuildSnapshotContext, injectedStoreLookup) => {
-                const 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)) {
-                    const start = Date.now();
-                    emitDurableEnvironmentAdapterEvent({ type: 'l2-revive-start' }, adapterRequestContext.eventObservers);
-                    const revivedSnapshot = reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, () => injectedStoreLookup(snapshot.select, snapshot.refresh)).then((result) => {
-                        emitDurableEnvironmentAdapterEvent({
-                            type: 'l2-revive-end',
-                            snapshot: result.snapshot,
-                            duration: Date.now() - start,
-                            l2Trips: result.metrics.l2Trips,
-                        }, adapterRequestContext.eventObservers);
-                        return result.snapshot;
-                    });
-                    return revivedSnapshot;
-                }
-                // otherwise just return what buildCachedSnapshot gave us
-                return snapshot;
-            };
-            const wrappedApplyCachePolicy = () => {
-                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();
-        };
-        const getIngestStagingStoreRecords = function () {
-            validateNotDisposed();
-            if (ingestStagingStore !== null) {
-                return ingestStagingStore.fallbackStringKeyInMemoryStore.records;
-            }
-            return {};
-        };
-        const getIngestStagingStoreMetadata = function () {
-            validateNotDisposed();
-            if (ingestStagingStore !== null) {
-                return ingestStagingStore.fallbackStringKeyInMemoryStore.metadata;
-            }
-            return {};
-        };
-        const handleSuccessResponse = async function (ingestAndBroadcastFunc, getResponseCacheKeysFunc) {
-            validateNotDisposed();
-            const cacheKeyMap = getResponseCacheKeysFunc();
-            const cacheKeyMapKeys = cacheKeyMap.keysAsArray();
-            const keysToRevive = new engine.StoreKeySet();
-            for (const cacheKeyMapKey of cacheKeyMapKeys) {
-                const cacheKey = cacheKeyMap.get(cacheKeyMapKey);
-                if (cacheKey.mergeable === true) {
-                    keysToRevive.add(cacheKeyMapKey);
-                }
-            }
-            let snapshotFromMemoryIngest = undefined;
-            // To-do: Once these are structured keys, will need to support them throughout durable logic W-12356727
-            const keysToReviveAsArray = Array.from(keysToRevive.keysAsStrings());
-            if (keysToReviveAsArray.length > 0) {
-                // if we need to do an L2 read then L2 write then we need to synchronize
-                // our read/merge/ingest/write Promise based on the keys so we don't
-                // stomp over any data
-                const readWritePromise = (async () => {
-                    const pendingPromises = [];
-                    for (const key of keysToReviveAsArray) {
-                        const pendingPromise = mergeKeysPromiseMap.get(key);
-                        if (pendingPromise !== undefined) {
-                            // IMPORTANT: while on the synchronous code path we get a
-                            // handle to pendingPromise and push it onto the array.
-                            // This is important because later in this synchronous code
-                            // path we will upsert readWritePromise into the
-                            // mergeKeysPromiseMap (essentially overwriting pendingPromise
-                            // in the map).
-                            pendingPromises.push(pendingPromise);
-                        }
-                    }
-                    await Promise.all(pendingPromises);
-                    const entries = await durableStore.getEntries(keysToReviveAsArray, DefaultDurableSegment);
-                    ingestStagingStore = buildIngestStagingStore(environment);
-                    publishDurableStoreEntries(entries, (key, record) => {
-                        if (typeof key === 'string') {
-                            ingestStagingStore.fallbackStringKeyInMemoryStore.records[key] =
-                                record;
-                        }
-                        else {
-                            ingestStagingStore.recordsMap.set(key, record);
-                        }
-                    }, 
-                    // we don't need to prime metadata
-                    () => { });
-                    snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
-                })();
-                for (const key of keysToReviveAsArray) {
-                    // we are overwriting the previous promise at this key, but that
-                    // is ok because we got a handle to it earlier (see the IMPORTANT
-                    // comment about 35 lines up)
-                    mergeKeysPromiseMap.set(key, readWritePromise);
-                }
-                try {
-                    await readWritePromise;
-                }
-                finally {
-                    for (const key of keysToReviveAsArray) {
-                        const pendingPromise = mergeKeysPromiseMap.get(key);
-                        // cleanup the entry from the map if this is the last promise
-                        // for that key
-                        if (pendingPromise === readWritePromise) {
-                            mergeKeysPromiseMap.delete(key);
-                        }
-                    }
-                }
-            }
-            else {
-                // we aren't doing any merging so we don't have to synchronize, the
-                // underlying DurableStore implementation takes care of R/W sync
-                // so all we have to do is ingest then write to L2
-                ingestStagingStore = buildIngestStagingStore(environment);
-                snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
-            }
-            if (snapshotFromMemoryIngest === undefined) {
-                return undefined;
-            }
-            if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
-                return snapshotFromMemoryIngest;
-            }
-            // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
-            const { select, refresh } = snapshotFromMemoryIngest;
-            const result = await reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(select, environment.createSnapshot, refresh));
-            return result.snapshot;
-        };
-        const handleErrorResponse = async function (ingestAndBroadcastFunc) {
-            validateNotDisposed();
-            ingestStagingStore = buildIngestStagingStore(environment);
-            return ingestAndBroadcastFunc();
-        };
-        const getNotifyChangeStoreEntries = function (keys) {
-            validateNotDisposed();
-            return durableStore
-                .getEntries(keys.map(engine.serializeStructuredKey), DefaultDurableSegment)
-                .then((durableRecords) => {
-                const entries = [];
-                publishDurableStoreEntries(durableRecords, (key, record) => {
-                    entries.push({
-                        key,
-                        record: record,
-                    });
-                }, () => { });
-                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 },
-        });
+    const AdapterContextSegment = 'ADAPTER-CONTEXT';
+    const ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
+    async function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded) {
+        // initialize empty context store
+        contextStores[adapterId] = create(null);
+        const context = {
+            set(key, value) {
+                contextStores[adapterId][key] = value;
+                durableStore.setEntries({
+                    [adapterId]: { data: contextStores[adapterId] },
+                }, AdapterContextSegment);
+                pendingContextStoreKeys.add(adapterId);
+            },
+            get(key) {
+                return contextStores[adapterId][key];
+            },
+        };
+        const contextReturn = () => {
+            if (onContextLoaded !== undefined) {
+                return onContextLoaded(context).then(() => {
+                    return context;
+                });
+            }
+            return context;
+        };
+        try {
+            const entries = await durableStore.getEntries([adapterId], AdapterContextSegment);
+            if (entries !== undefined && entries[adapterId] !== undefined) {
+                // if durable store has a saved context then load it in the store
+                contextStores[adapterId] = entries[adapterId].data;
+            }
+        }
+        catch (error) {
+            durableStoreErrorHandler(error);
+        }
+        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, { durableStore, instrumentation }) {
+        let ingestStagingStore = null;
+        const durableTTLStore = new DurableTTLStore(durableStore);
+        const 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.
+        const pendingContextStoreKeys = new Set();
+        const contextStores = create(null);
+        let initializationPromise = new Promise((resolve) => {
+            const finish = () => {
+                resolve();
+                initializationPromise = undefined;
+            };
+            reviveTTLOverrides(durableTTLStore, environment).then(finish);
+        });
+        //instrumentation for durable store errors
+        const durableStoreErrorHandler = handleDurableStoreRejection(instrumentation);
+        let disposed = false;
+        const validateNotDisposed = () => {
+            if (disposed === true) {
+                throw new Error('This makeDurable instance has been disposed');
+            }
+        };
+        const unsubscribe = durableStore.registerOnChangedListener(async (changes) => {
+            const defaultSegmentKeys = [];
+            const adapterContextSegmentKeys = [];
+            for (let i = 0, len = changes.length; i < len; i++) {
+                const 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(...change.ids);
+                }
+                else if (change.segment === AdapterContextSegment) {
+                    adapterContextSegmentKeys.push(...change.ids);
+                }
+            }
+            // process adapter context changes
+            const adapterContextKeysFromDifferentInstance = [];
+            for (const key of adapterContextSegmentKeys) {
+                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) {
+                try {
+                    const entries = await durableStore.getEntries(adapterContextKeysFromDifferentInstance, AdapterContextSegment);
+                    if (entries !== undefined) {
+                        const entryKeys = keys(entries);
+                        for (let i = 0, len = entryKeys.length; i < len; i++) {
+                            const entryKey = entryKeys[i];
+                            const entry = entries[entryKey];
+                            contextStores[entryKey] = entry.data;
+                        }
+                    }
+                }
+                catch (error) {
+                    durableStoreErrorHandler(error);
+                }
+            }
+            // process default segment changes
+            const defaultSegmentKeysLength = defaultSegmentKeys.length;
+            if (defaultSegmentKeysLength > 0) {
+                for (let i = 0; i < defaultSegmentKeysLength; i++) {
+                    const key = defaultSegmentKeys[i];
+                    const 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);
+                }
+                await environment.storeBroadcast(rebuildSnapshot, environment.snapshotAvailable);
+            }
+        });
+        const dispose = function () {
+            validateNotDisposed();
+            disposed = true;
+            return unsubscribe();
+        };
+        const 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);
+        };
+        const publishStoreMetadata = function (recordId, storeMetadata) {
+            validateNotDisposed();
+            if (ingestStagingStore === null) {
+                ingestStagingStore = buildIngestStagingStore(environment);
+            }
+            ingestStagingStore.publishMetadata(recordId, storeMetadata);
+        };
+        const 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);
+        };
+        const storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
+            validateNotDisposed();
+            if (ingestStagingStore === null) {
+                ingestStagingStore = buildIngestStagingStore(environment);
+            }
+            environment.storeIngestError(key, errorSnapshot, storeMetadataParams, ingestStagingStore);
+        };
+        const 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();
+        };
+        const publishChangesToDurableStore = function () {
+            validateNotDisposed();
+            if (ingestStagingStore === null) {
+                return Promise.resolve();
+            }
+            const promise = flushInMemoryStoreValuesToDurableStore(ingestStagingStore, durableStore, durableStoreErrorHandler);
+            ingestStagingStore = null;
+            return promise;
+        };
+        const storeLookup = function (sel, createSnapshot, refresh, ttlStrategy) {
+            validateNotDisposed();
+            // if this lookup is right after an ingest there will be a staging store
+            if (ingestStagingStore !== null) {
+                const 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);
+        };
+        const storeEvict = function (key) {
+            validateNotDisposed();
+            if (ingestStagingStore === null) {
+                ingestStagingStore = buildIngestStagingStore(environment);
+            }
+            ingestStagingStore.evict(key);
+        };
+        const getNode = function (key) {
+            validateNotDisposed();
+            if (ingestStagingStore === null) {
+                ingestStagingStore = buildIngestStagingStore(environment);
+            }
+            return environment.getNode(key, ingestStagingStore);
+        };
+        const wrapNormalizedGraphNode = function (normalized) {
+            validateNotDisposed();
+            if (ingestStagingStore === null) {
+                ingestStagingStore = buildIngestStagingStore(environment);
+            }
+            return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
+        };
+        const rebuildSnapshot = function (snapshot, onRebuild) {
+            validateNotDisposed();
+            // try rebuilding from memory
+            environment.rebuildSnapshot(snapshot, (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, () => {
+                    // 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
+                    let rebuiltSnap;
+                    environment.rebuildSnapshot(snapshot, (rebuilt) => {
+                        rebuiltSnap = rebuilt;
+                    });
+                    return rebuiltSnap;
+                }).then((result) => {
+                    onRebuild(result.snapshot);
+                });
+            });
+        };
+        const withContext = function (adapter, options) {
+            validateNotDisposed();
+            const { contextId, contextVersion, onContextLoaded } = options;
+            let context = undefined;
+            let contextKey = `${contextId}`;
+            // if a context version is supplied, key with the version encoded
+            if (contextVersion !== undefined) {
+                contextKey += `::${contextVersion}`;
+            }
+            contextKey += ADAPTER_CONTEXT_ID_SUFFIX;
+            const contextAsPromise = reviveOrCreateContext(contextKey, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded);
+            return (config, requestContext) => {
+                if (context === undefined) {
+                    return contextAsPromise.then((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);
+            };
+        };
+        const 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);
+        };
+        const storeSetTTLOverride = function (namespace, representationName, ttl) {
+            validateNotDisposed();
+            return Promise.all([
+                environment.storeSetTTLOverride(namespace, representationName, ttl),
+                durableTTLStore.setDurableTTLOverride(namespace, representationName, ttl),
+            ]).then();
+        };
+        const storeSetDefaultTTLOverride = function (ttl) {
+            validateNotDisposed();
+            return Promise.all([
+                environment.storeSetDefaultTTLOverride(ttl),
+                durableTTLStore.setDefaultDurableTTLOverrides(ttl),
+            ]).then();
+        };
+        const getDurableTTLOverrides = function () {
+            validateNotDisposed();
+            return durableTTLStore.getDurableTTLOverrides();
+        };
+        const dispatchResourceRequest = async function (request, context, eventObservers) {
+            validateNotDisposed();
+            // non-GET adapters call dispatchResourceRequest before any other luvio
+            // function so this is our chance to ensure we're initialized
+            if (initializationPromise !== undefined) {
+                await initializationPromise;
+            }
+            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
+        const applyCachePolicy = function (luvio, adapterRequestContext, buildSnapshotContext, buildCachedSnapshot, buildNetworkSnapshot) {
+            validateNotDisposed();
+            const wrappedCacheLookup = (injectedBuildSnapshotContext, injectedStoreLookup) => {
+                const 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)) {
+                    const start = Date.now();
+                    emitDurableEnvironmentAdapterEvent({ type: 'l2-revive-start' }, adapterRequestContext.eventObservers);
+                    const revivedSnapshot = reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, () => injectedStoreLookup(snapshot.select, snapshot.refresh)).then((result) => {
+                        emitDurableEnvironmentAdapterEvent({
+                            type: 'l2-revive-end',
+                            snapshot: result.snapshot,
+                            duration: Date.now() - start,
+                            l2Trips: result.metrics.l2Trips,
+                        }, adapterRequestContext.eventObservers);
+                        return result.snapshot;
+                    });
+                    return revivedSnapshot;
+                }
+                // otherwise just return what buildCachedSnapshot gave us
+                return snapshot;
+            };
+            const wrappedApplyCachePolicy = () => {
+                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();
+        };
+        const getIngestStagingStoreRecords = function () {
+            validateNotDisposed();
+            if (ingestStagingStore !== null) {
+                return ingestStagingStore.fallbackStringKeyInMemoryStore.records;
+            }
+            return {};
+        };
+        const getIngestStagingStoreMetadata = function () {
+            validateNotDisposed();
+            if (ingestStagingStore !== null) {
+                return ingestStagingStore.fallbackStringKeyInMemoryStore.metadata;
+            }
+            return {};
+        };
+        const handleSuccessResponse = async function (ingestAndBroadcastFunc, getResponseCacheKeysFunc) {
+            validateNotDisposed();
+            const cacheKeyMap = getResponseCacheKeysFunc();
+            const cacheKeyMapKeys = cacheKeyMap.keysAsArray();
+            const keysToRevive = new engine.StoreKeySet();
+            for (const cacheKeyMapKey of cacheKeyMapKeys) {
+                const cacheKey = cacheKeyMap.get(cacheKeyMapKey);
+                if (cacheKey.mergeable === true) {
+                    keysToRevive.add(cacheKeyMapKey);
+                }
+            }
+            let snapshotFromMemoryIngest = undefined;
+            // To-do: Once these are structured keys, will need to support them throughout durable logic W-12356727
+            const keysToReviveAsArray = Array.from(keysToRevive.keysAsStrings());
+            if (keysToReviveAsArray.length > 0) {
+                // if we need to do an L2 read then L2 write then we need to synchronize
+                // our read/merge/ingest/write Promise based on the keys so we don't
+                // stomp over any data
+                const readWritePromise = (async () => {
+                    const pendingPromises = [];
+                    for (const key of keysToReviveAsArray) {
+                        const pendingPromise = mergeKeysPromiseMap.get(key);
+                        if (pendingPromise !== undefined) {
+                            // IMPORTANT: while on the synchronous code path we get a
+                            // handle to pendingPromise and push it onto the array.
+                            // This is important because later in this synchronous code
+                            // path we will upsert readWritePromise into the
+                            // mergeKeysPromiseMap (essentially overwriting pendingPromise
+                            // in the map).
+                            pendingPromises.push(pendingPromise);
+                        }
+                    }
+                    await Promise.all(pendingPromises);
+                    const entries = await durableStore.getEntries(keysToReviveAsArray, DefaultDurableSegment);
+                    ingestStagingStore = buildIngestStagingStore(environment);
+                    publishDurableStoreEntries(entries, (key, record) => {
+                        if (typeof key === 'string') {
+                            ingestStagingStore.fallbackStringKeyInMemoryStore.records[key] =
+                                record;
+                        }
+                        else {
+                            ingestStagingStore.recordsMap.set(key, record);
+                        }
+                    }, (key, metadata) => {
+                        if (typeof key === 'string') {
+                            ingestStagingStore.fallbackStringKeyInMemoryStore.metadata[key] =
+                                metadata;
+                        }
+                        else {
+                            ingestStagingStore.metadataMap.set(key, metadata);
+                        }
+                    });
+                    snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
+                })();
+                for (const key of keysToReviveAsArray) {
+                    // we are overwriting the previous promise at this key, but that
+                    // is ok because we got a handle to it earlier (see the IMPORTANT
+                    // comment about 35 lines up)
+                    mergeKeysPromiseMap.set(key, readWritePromise);
+                }
+                try {
+                    await readWritePromise;
+                }
+                finally {
+                    for (const key of keysToReviveAsArray) {
+                        const pendingPromise = mergeKeysPromiseMap.get(key);
+                        // cleanup the entry from the map if this is the last promise
+                        // for that key
+                        if (pendingPromise === readWritePromise) {
+                            mergeKeysPromiseMap.delete(key);
+                        }
+                    }
+                }
+            }
+            else {
+                // we aren't doing any merging so we don't have to synchronize, the
+                // underlying DurableStore implementation takes care of R/W sync
+                // so all we have to do is ingest then write to L2
+                ingestStagingStore = buildIngestStagingStore(environment);
+                snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
+            }
+            if (snapshotFromMemoryIngest === undefined) {
+                return undefined;
+            }
+            if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
+                return snapshotFromMemoryIngest;
+            }
+            // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
+            const { select, refresh } = snapshotFromMemoryIngest;
+            const result = await reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(select, environment.createSnapshot, refresh));
+            return result.snapshot;
+        };
+        const handleErrorResponse = async function (ingestAndBroadcastFunc) {
+            validateNotDisposed();
+            ingestStagingStore = buildIngestStagingStore(environment);
+            return ingestAndBroadcastFunc();
+        };
+        const getNotifyChangeStoreEntries = function (keys) {
+            validateNotDisposed();
+            return durableStore
+                .getEntries(keys.map(engine.serializeStructuredKey), DefaultDurableSegment)
+                .then((durableRecords) => {
+                const entries = [];
+                publishDurableStoreEntries(durableRecords, (key, record) => {
+                    entries.push({
+                        key,
+                        record: record,
+                    });
+                }, () => { });
+                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;