@luvio/environments 0.138.1 → 0.138.3

package/dist/es/es2018/environments.js

@@ -1,885 +1,885 @@
 import { StoreKeySet, serializeStructuredKey, emitAdapterEvent, StoreKeyMap, buildStaleWhileRevalidateImplementation, Reader } from '@luvio/engine';
 
-// the last version the metadata shape was altered
-const DURABLE_METADATA_VERSION = '0.111.0';
-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 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 StoreKeySet().add(recordId);
-    keysToReviveSet.merge(seenRecords);
-    const keysToRevive = keysToReviveSet.keysAsArray();
-    const canonicalKeys = keysToRevive.map((x) => serializeStructuredKey(baseEnvironment.storeGetCanonicalKey(x)));
-    const start = Date.now();
-    const { l2Trips } = reviveMetrics;
-    return durableStore.getEntries(canonicalKeys, DefaultDurableSegment).then((durableRecords) => {
-        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 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 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 StoreKeySet().add(recordId);
+    keysToReviveSet.merge(seenRecords);
+    const keysToRevive = keysToReviveSet.keysAsArray();
+    const canonicalKeys = keysToRevive.map((x) => serializeStructuredKey(baseEnvironment.storeGetCanonicalKey(x)));
+    const start = Date.now();
+    const { l2Trips } = reviveMetrics;
+    return durableStore.getEntries(canonicalKeys, DefaultDurableSegment).then((durableRecords) => {
+        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 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) {
-    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) {
+    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 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 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 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(serializeStructuredKey), DefaultDurableSegment)
-            .then((durableRecords) => {
-            const entries = [];
-            publishDurableStoreEntries(durableRecords, (key, record) => {
-                entries.push({
-                    key,
-                    record: record,
-                });
-            }, () => { });
-            return entries;
-        });
-    };
-    environment.defaultCachePolicy = {
-        type: 'stale-while-revalidate',
-        implementation: 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 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 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 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(serializeStructuredKey), DefaultDurableSegment)
+            .then((durableRecords) => {
+            const entries = [];
+            publishDurableStoreEntries(durableRecords, (key, record) => {
+                entries.push({
+                    key,
+                    record: record,
+                });
+            }, () => { });
+            return entries;
+        });
+    };
+    environment.defaultCachePolicy = {
+        type: 'stale-while-revalidate',
+        implementation: 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 },
+    });
 }
 
 export { DURABLE_METADATA_VERSION, DefaultDurableSegment, isDurableEnvironmentEvent, makeDurable, publishDurableStoreEntries };