@luvio/environments 0.142.2 → 0.142.3

package/dist/umd/es5/environments.js

@@ -1,1013 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@luvio/engine')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@luvio/engine'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.luvioEnvironments = {}, global.luvioEngine));
-})(this, (function (exports, engine) { 'use strict';
-
-    // the last version the metadata shape was altered
-    var DURABLE_METADATA_VERSION = '0.111.0';
-    function isDeprecatedDurableStoreEntry(durableRecord) {
-        if (durableRecord.expiration !== undefined) {
-            return true;
-        }
-        var metadata = durableRecord.metadata;
-        if (metadata !== undefined) {
-            var metadataVersion = metadata.metadataVersion;
-            // eventually we will want to assert that metadataVersion is defined
-            if (metadataVersion !== undefined && metadataVersion !== DURABLE_METADATA_VERSION) {
-                return true;
-            }
-        }
-        // Add more deprecated shape checks here
-        return false;
-    }
-    var DefaultDurableSegment = 'DEFAULT';
-
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-
-    var __assign = function() {
-        __assign = Object.assign || function __assign(t) {
-            for (var s, i = 1, n = arguments.length; i < n; i++) {
-                s = arguments[i];
-                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-            }
-            return t;
-        };
-        return __assign.apply(this, arguments);
-    };
-
-    function __awaiter(thisArg, _arguments, P, generator) {
-        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-        return new (P || (P = Promise))(function (resolve, reject) {
-            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-            step((generator = generator.apply(thisArg, _arguments || [])).next());
-        });
-    }
-
-    function __generator(thisArg, body) {
-        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-        function verb(n) { return function (v) { return step([n, v]); }; }
-        function step(op) {
-            if (f) throw new TypeError("Generator is already executing.");
-            while (g && (g = 0, op[0] && (_ = 0)), _) try {
-                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-                if (y = 0, t) op = [op[0] & 2, t.value];
-                switch (op[0]) {
-                    case 0: case 1: t = op; break;
-                    case 4: _.label++; return { value: op[1], done: false };
-                    case 5: _.label++; y = op[1]; op = [0]; continue;
-                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                    default:
-                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                        if (t[2]) _.ops.pop();
-                        _.trys.pop(); continue;
-                }
-                op = body.call(thisArg, _);
-            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-        }
-    }
-
-    var keys = Object.keys, create = Object.create;
-
-    //Durable store error instrumentation key
-    var DURABLE_STORE_ERROR = 'durable-store-error';
-    /**
-     * Returns a function that processes errors from durable store promise rejections.
-     * If running in a non-production environment, the error is rethrown.
-     * When running in production the error is sent to instrumentation.
-     * @param instrument Instrumentation function implementation
-     */
-    function handleDurableStoreRejection(instrument) {
-        return function (error) {
-            if (process.env.NODE_ENV !== 'production') {
-                throw error;
-            }
-            if (instrument !== undefined) {
-                instrument(function () {
-                    var _a;
-                    return _a = {},
-                        _a[DURABLE_STORE_ERROR] = true,
-                        _a.error = error,
-                        _a;
-                });
-            }
-        };
-    }
-
-    function 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, put, publishMetadata) {
-        var revivedKeys = new engine.StoreKeySet();
-        var hadUnexpectedShape = false;
-        if (durableRecords === undefined) {
-            return { revivedKeys: revivedKeys, hadUnexpectedShape: hadUnexpectedShape };
-        }
-        var durableKeys = keys(durableRecords);
-        if (durableKeys.length === 0) {
-            // no records to revive
-            return { revivedKeys: revivedKeys, hadUnexpectedShape: hadUnexpectedShape };
-        }
-        for (var i = 0, len = durableKeys.length; i < len; i += 1) {
-            var key = durableKeys[i];
-            var durableRecord = durableRecords[key];
-            if (isDeprecatedDurableStoreEntry(durableRecord)) {
-                // had the old shape, skip reviving this entry.
-                hadUnexpectedShape = true;
-                continue;
-            }
-            var metadata = durableRecord.metadata, data = durableRecord.data;
-            if (data === undefined) {
-                // if unexpected data skip reviving
-                hadUnexpectedShape = true;
-                continue;
-            }
-            if (metadata !== undefined) {
-                var expirationTimestamp = metadata.expirationTimestamp;
-                if (expirationTimestamp === undefined) {
-                    // if unexpected expiration data skip reviving
-                    hadUnexpectedShape = true;
-                    continue;
-                }
-                publishMetadata(key, metadata);
-            }
-            if (isStoreEntryError(data)) {
-                // freeze errors on way into L1
-                engine.deepFreeze(data.error);
-            }
-            put(key, data);
-            revivedKeys.add(key);
-        }
-        return { revivedKeys: revivedKeys, hadUnexpectedShape: hadUnexpectedShape };
-    }
-    /**
-     * This method returns a Promise to a snapshot that is revived from L2 cache.  If
-     * L2 does not have the entries necessary to fulfill the snapshot then this method
-     * will refresh the snapshot from network, and then run the results from network
-     * through L2 ingestion, returning the subsequent revived snapshot.
-     */
-    function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics) {
-        if (reviveMetrics === void 0) { reviveMetrics = { l2Trips: [] }; }
-        var recordId = unavailableSnapshot.recordId, select = unavailableSnapshot.select, missingLinks = unavailableSnapshot.missingLinks, seenRecords = unavailableSnapshot.seenRecords, state = unavailableSnapshot.state;
-        // L2 can only revive Unfulfilled snapshots that have a selector since they have the
-        // info needed to revive (like missingLinks) and rebuild.  Otherwise return L1 snapshot.
-        if (state !== 'Unfulfilled' || select === undefined) {
-            return Promise.resolve({
-                snapshot: unavailableSnapshot,
-                metrics: reviveMetrics,
-            });
-        }
-        // in case L1 store changes/deallocs a record while we are doing the async read
-        // we attempt to read all keys from L2 - so combine recordId with any seenRecords
-        var keysToReviveSet = new engine.StoreKeySet().add(recordId);
-        keysToReviveSet.merge(seenRecords);
-        keysToReviveSet.merge(missingLinks);
-        var keysToRevive = keysToReviveSet.keysAsArray();
-        var canonicalKeys = keysToRevive.map(function (x) {
-            return engine.serializeStructuredKey(baseEnvironment.storeGetCanonicalKey(x));
-        });
-        var start = Date.now();
-        var l2Trips = reviveMetrics.l2Trips;
-        return durableStore.getEntries(canonicalKeys, DefaultDurableSegment).then(function (durableRecords) {
-            l2Trips.push({
-                duration: Date.now() - start,
-                keysRequestedCount: canonicalKeys.length,
-            });
-            var _a = publishDurableStoreEntries(durableRecords, 
-            // TODO [W-10072584]: instead of implicitly using L1 we should take in
-            // publish and publishMetadata funcs, so callers can decide where to
-            // revive to (like they pass in how to do the buildL1Snapshot)
-            baseEnvironment.storePut.bind(baseEnvironment), baseEnvironment.publishStoreMetadata.bind(baseEnvironment)), revivedKeys = _a.revivedKeys, hadUnexpectedShape = _a.hadUnexpectedShape;
-            // if the data coming back from DS had an unexpected shape then just
-            // return the L1 snapshot
-            if (hadUnexpectedShape === true) {
-                return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
-            }
-            if (revivedKeys.size() === 0) {
-                // durable store doesn't have what we asked for so return L1 snapshot
-                return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
-            }
-            // try building the snapshot from L1 now that we have revived the missingLinks
-            var snapshot = buildL1Snapshot();
-            // if snapshot is pending then some other in-flight refresh will broadcast
-            // later
-            if (snapshot.state === 'Pending') {
-                return { snapshot: snapshot, metrics: reviveMetrics };
-            }
-            if (snapshot.state === 'Unfulfilled') {
-                // have to check if the new snapshot has any additional seenRecords
-                // and revive again if so
-                var newSnapshotSeenRecords = snapshot.seenRecords, newSnapshotMissingLinks = snapshot.missingLinks, newSnapshotRecordId = snapshot.recordId;
-                var newKeysToReviveSet = new engine.StoreKeySet();
-                newKeysToReviveSet.add(newSnapshotRecordId);
-                newKeysToReviveSet.merge(newSnapshotSeenRecords);
-                newKeysToReviveSet.merge(newSnapshotMissingLinks);
-                var newKeys = newKeysToReviveSet.keysAsArray();
-                // in case DS returned additional entries we combine the requested
-                // and returned keys
-                var alreadyRequestedOrRevivedSet = keysToReviveSet;
-                alreadyRequestedOrRevivedSet.merge(revivedKeys);
-                // if there's any seen keys in the newly rebuilt snapshot that
-                // haven't already been requested or returned then revive again
-                for (var i = 0, len = newKeys.length; i < len; i++) {
-                    var newSnapshotSeenKey = newKeys[i];
-                    if (!alreadyRequestedOrRevivedSet.has(newSnapshotSeenKey)) {
-                        return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics);
-                    }
-                }
-            }
-            return { snapshot: snapshot, metrics: reviveMetrics };
-        }, function (error) {
-            durableStoreErrorHandler(error);
-            // getEntries failed, return the L1 snapshot
-            return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
-        });
-    }
-
-    var TTL_DURABLE_SEGMENT = 'TTL_DURABLE_SEGMENT';
-    var TTL_DEFAULT_KEY = 'TTL_DEFAULT_KEY';
-    function buildDurableTTLOverrideStoreKey(namespace, representationName) {
-        return "".concat(namespace, "::").concat(representationName);
-    }
-    function isEntryDurableTTLOverride(entry) {
-        if (typeof entry === 'object' && entry !== undefined && entry !== null) {
-            var data = entry.data;
-            if (data !== undefined) {
-                return (data.namespace !== undefined &&
-                    data.representationName !== undefined &&
-                    data.ttl !== undefined);
-            }
-        }
-        return false;
-    }
-    function isDefaultDurableTTLOverride(override) {
-        return (override.namespace === TTL_DEFAULT_KEY && override.representationName === TTL_DEFAULT_KEY);
-    }
-    /**
-     * Class to set and get the TTL override values in the Durable Store
-     */
-    var DurableTTLStore = /** @class */ (function () {
-        function DurableTTLStore(durableStore) {
-            this.durableStore = durableStore;
-        }
-        DurableTTLStore.prototype.setDefaultDurableTTLOverrides = function (ttl) {
-            var _a;
-            return this.durableStore.setEntries((_a = {},
-                _a[buildDurableTTLOverrideStoreKey(TTL_DEFAULT_KEY, TTL_DEFAULT_KEY)] = {
-                    data: {
-                        namespace: TTL_DEFAULT_KEY,
-                        representationName: TTL_DEFAULT_KEY,
-                        ttl: ttl,
-                    },
-                },
-                _a), TTL_DURABLE_SEGMENT);
-        };
-        DurableTTLStore.prototype.setDurableTTLOverride = function (namespace, representationName, ttl) {
-            var _a;
-            return this.durableStore.setEntries((_a = {},
-                _a[buildDurableTTLOverrideStoreKey(namespace, representationName)] = {
-                    data: { namespace: namespace, representationName: representationName, ttl: ttl },
-                },
-                _a), TTL_DURABLE_SEGMENT);
-        };
-        DurableTTLStore.prototype.getDurableTTLOverrides = function () {
-            return this.durableStore
-                .getAllEntries(TTL_DURABLE_SEGMENT)
-                .then(function (entries) {
-                var overrides = [];
-                var defaultTTL = undefined;
-                if (entries === undefined) {
-                    return {
-                        defaultTTL: defaultTTL,
-                        overrides: overrides,
-                    };
-                }
-                var keys$1 = keys(entries);
-                for (var i = 0, len = keys$1.length; i < len; i++) {
-                    var key = keys$1[i];
-                    var entry = entries[key];
-                    if (entry !== undefined && isEntryDurableTTLOverride(entry)) {
-                        if (isDefaultDurableTTLOverride(entry.data)) {
-                            defaultTTL = entry.data;
-                        }
-                        else {
-                            overrides.push(entry.data);
-                        }
-                    }
-                }
-                return {
-                    defaultTTL: defaultTTL,
-                    overrides: overrides,
-                };
-            });
-        };
-        return DurableTTLStore;
-    }());
-
-    function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler, additionalDurableStoreOperations) {
-        if (additionalDurableStoreOperations === void 0) { additionalDurableStoreOperations = []; }
-        var durableRecords = create(null);
-        var evictedRecords = create(null);
-        var _a = store.fallbackStringKeyInMemoryStore, records = _a.records, storeMetadata = _a.metadata, visitedIds = _a.visitedIds, refreshedIds = _a.refreshedIds;
-        // TODO: W-8909393 Once metadata is stored in its own segment we need to
-        // call setEntries for the visitedIds on default segment and call setEntries
-        // on the metadata segment for the refreshedIds
-        var keys$1 = keys(__assign(__assign({}, visitedIds), refreshedIds));
-        for (var i = 0, len = keys$1.length; i < len; i += 1) {
-            var key = keys$1[i];
-            var record = records[key];
-            // this record has been evicted, evict from DS
-            if (record === undefined) {
-                evictedRecords[key] = true;
-                continue;
-            }
-            var metadata = storeMetadata[key];
-            durableRecords[key] = {
-                data: record,
-            };
-            if (metadata !== undefined) {
-                durableRecords[key].metadata = __assign(__assign({}, metadata), { metadataVersion: DURABLE_METADATA_VERSION });
-            }
-        }
-        var durableStoreOperations = additionalDurableStoreOperations;
-        // publishes
-        var recordKeys = keys(durableRecords);
-        if (recordKeys.length > 0) {
-            durableStoreOperations.push({
-                type: 'setEntries',
-                entries: durableRecords,
-                segment: DefaultDurableSegment,
-            });
-        }
-        // evicts
-        var evictedKeys = keys(evictedRecords);
-        if (evictedKeys.length > 0) {
-            durableStoreOperations.push({
-                type: 'evictEntries',
-                ids: evictedKeys,
-                segment: DefaultDurableSegment,
-            });
-        }
-        if (durableStoreOperations.length > 0) {
-            return durableStore.batchOperations(durableStoreOperations).catch(durableStoreErrorHandler);
-        }
-        return Promise.resolve();
-    }
-
-    var DurableEnvironmentEventDiscriminator = 'durable';
-    function isDurableEnvironmentEvent(event) {
-        return (event.type === 'environment' && event.environment === DurableEnvironmentEventDiscriminator);
-    }
-    function emitDurableEnvironmentAdapterEvent(eventData, observers) {
-        engine.emitAdapterEvent({
-            type: 'environment',
-            timestamp: Date.now(),
-            environment: DurableEnvironmentEventDiscriminator,
-            data: eventData,
-        }, observers);
-    }
-
-    function reviveTTLOverrides(ttlStore, environment) {
-        return __awaiter(this, void 0, void 0, function () {
-            var map, defaultTTL, overrides, i, len, _a, namespace, representationName, ttl;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, ttlStore.getDurableTTLOverrides()];
-                    case 1:
-                        map = _b.sent();
-                        defaultTTL = map.defaultTTL, overrides = map.overrides;
-                        if (defaultTTL !== undefined) {
-                            environment.storeSetDefaultTTLOverride(defaultTTL.ttl);
-                        }
-                        for (i = 0, len = overrides.length; i < len; i++) {
-                            _a = overrides[i], namespace = _a.namespace, representationName = _a.representationName, ttl = _a.ttl;
-                            environment.storeSetTTLOverride(namespace, representationName, ttl);
-                        }
-                        return [2 /*return*/];
-                }
-            });
-        });
-    }
-
-    /**
-     * Returns an empty InMemoryStore that can be used for ingestion.  Copies over
-     * the TTLOverrides from the given Environment's Store.
-     */
-    function buildIngestStagingStore(environment) {
-        return environment.storeBuildIngestionStagingStore();
-    }
-
-    var AdapterContextSegment = 'ADAPTER-CONTEXT';
-    var ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
-    function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded) {
-        return __awaiter(this, void 0, void 0, function () {
-            var context, contextReturn, entries, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        // initialize empty context store
-                        contextStores[adapterId] = create(null);
-                        context = {
-                            set: function (key, value) {
-                                var _a;
-                                contextStores[adapterId][key] = value;
-                                durableStore.setEntries((_a = {},
-                                    _a[adapterId] = { data: contextStores[adapterId] },
-                                    _a), AdapterContextSegment);
-                                pendingContextStoreKeys.add(adapterId);
-                            },
-                            get: function (key) {
-                                return contextStores[adapterId][key];
-                            },
-                        };
-                        contextReturn = function () {
-                            if (onContextLoaded !== undefined) {
-                                return onContextLoaded(context).then(function () {
-                                    return context;
-                                });
-                            }
-                            return context;
-                        };
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, durableStore.getEntries([adapterId], AdapterContextSegment)];
-                    case 2:
-                        entries = _a.sent();
-                        if (entries !== undefined && entries[adapterId] !== undefined) {
-                            // if durable store has a saved context then load it in the store
-                            contextStores[adapterId] = entries[adapterId].data;
-                        }
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_1 = _a.sent();
-                        durableStoreErrorHandler(error_1);
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/, contextReturn()];
-                }
-            });
-        });
-    }
-    function isUnfulfilledSnapshot(cachedSnapshotResult) {
-        if (cachedSnapshotResult === undefined) {
-            return false;
-        }
-        if ('then' in cachedSnapshotResult) {
-            return false;
-        }
-        return cachedSnapshotResult.state === 'Unfulfilled';
-    }
-    /**
-     * Configures the environment to persist data into a durable store and attempt to resolve
-     * data from the persistent store before hitting the network.
-     *
-     * @param environment The base environment
-     * @param durableStore A DurableStore implementation
-     * @param instrumentation An instrumentation function implementation
-     */
-    function makeDurable(environment, _a) {
-        var _this = this;
-        var durableStore = _a.durableStore, instrumentation = _a.instrumentation;
-        var ingestStagingStore = null;
-        var durableTTLStore = new DurableTTLStore(durableStore);
-        var mergeKeysPromiseMap = new Map();
-        // When a context store is mutated we write it to L2, which causes DS on change
-        // event. If this instance of makeDurable caused that L2 write we can ignore that
-        // on change event. This Set helps us do that.
-        var pendingContextStoreKeys = new Set();
-        var contextStores = create(null);
-        var initializationPromise = new Promise(function (resolve) {
-            var finish = function () {
-                resolve();
-                initializationPromise = undefined;
-            };
-            reviveTTLOverrides(durableTTLStore, environment).then(finish);
-        });
-        //instrumentation for durable store errors
-        var durableStoreErrorHandler = handleDurableStoreRejection(instrumentation);
-        var disposed = false;
-        var validateNotDisposed = function () {
-            if (disposed === true) {
-                throw new Error('This makeDurable instance has been disposed');
-            }
-        };
-        var unsubscribe = durableStore.registerOnChangedListener(function (changes) { return __awaiter(_this, void 0, void 0, function () {
-            var defaultSegmentKeys, adapterContextSegmentKeys, i, len, change, adapterContextKeysFromDifferentInstance, _i, adapterContextSegmentKeys_1, key, entries, entryKeys, i, len, entryKey, entry, error_2, defaultSegmentKeysLength, i, key, canonical;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        defaultSegmentKeys = [];
-                        adapterContextSegmentKeys = [];
-                        for (i = 0, len = changes.length; i < len; i++) {
-                            change = changes[i];
-                            // we only care about changes to the data which is stored in the default
-                            // segment or the adapter context
-                            if (change.segment === DefaultDurableSegment) {
-                                defaultSegmentKeys.push.apply(defaultSegmentKeys, change.ids);
-                            }
-                            else if (change.segment === AdapterContextSegment) {
-                                adapterContextSegmentKeys.push.apply(adapterContextSegmentKeys, change.ids);
-                            }
-                        }
-                        adapterContextKeysFromDifferentInstance = [];
-                        for (_i = 0, adapterContextSegmentKeys_1 = adapterContextSegmentKeys; _i < adapterContextSegmentKeys_1.length; _i++) {
-                            key = adapterContextSegmentKeys_1[_i];
-                            if (pendingContextStoreKeys.has(key)) {
-                                // if this instance caused the L2 write then remove from the
-                                // "pending" Set and move on
-                                pendingContextStoreKeys.delete(key);
-                            }
-                            else {
-                                // else it came from another luvio instance and we need to
-                                // read from L2
-                                adapterContextKeysFromDifferentInstance.push(key);
-                            }
-                        }
-                        if (!(adapterContextKeysFromDifferentInstance.length > 0)) return [3 /*break*/, 4];
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, durableStore.getEntries(adapterContextKeysFromDifferentInstance, AdapterContextSegment)];
-                    case 2:
-                        entries = _a.sent();
-                        if (entries !== undefined) {
-                            entryKeys = keys(entries);
-                            for (i = 0, len = entryKeys.length; i < len; i++) {
-                                entryKey = entryKeys[i];
-                                entry = entries[entryKey];
-                                contextStores[entryKey] = entry.data;
-                            }
-                        }
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_2 = _a.sent();
-                        durableStoreErrorHandler(error_2);
-                        return [3 /*break*/, 4];
-                    case 4:
-                        defaultSegmentKeysLength = defaultSegmentKeys.length;
-                        if (!(defaultSegmentKeysLength > 0)) return [3 /*break*/, 6];
-                        for (i = 0; i < defaultSegmentKeysLength; i++) {
-                            key = defaultSegmentKeys[i];
-                            canonical = environment.storeGetCanonicalKey(key);
-                            if (canonical !== key) {
-                                continue;
-                            }
-                            // TODO: W-8909393 If expiration is the only thing that changed we should not evict the data... so
-                            // if we stored expiration and data at different keys (or same keys in different segments)
-                            // then we could know if only the expiration has changed and we wouldn't need to evict
-                            // and go through an entire broadcast/revive cycle for unchanged data
-                            // call base environment storeEvict so this evict is not tracked for durable deletion
-                            environment.storeEvict(key);
-                        }
-                        return [4 /*yield*/, environment.storeBroadcast(rebuildSnapshot, environment.snapshotAvailable)];
-                    case 5:
-                        _a.sent();
-                        _a.label = 6;
-                    case 6: return [2 /*return*/];
-                }
-            });
-        }); });
-        var dispose = function () {
-            validateNotDisposed();
-            disposed = true;
-            return unsubscribe();
-        };
-        var storePublish = function (key, data) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            ingestStagingStore.publish(key, data);
-            // remove record from main luvio L1 cache while we are on the synchronous path
-            // because we do not want some other code attempting to use the
-            // in-memory values before the durable store onChanged handler
-            // calls back and revives the values to in-memory
-            environment.storeEvict(key);
-        };
-        var publishStoreMetadata = function (recordId, storeMetadata) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            ingestStagingStore.publishMetadata(recordId, storeMetadata);
-        };
-        var storeIngest = function (key, ingest, response, luvio) {
-            validateNotDisposed();
-            // we don't ingest to the luvio L1 store from network directly, we ingest to
-            // L2 and let DurableStore on change event revive keys into luvio L1 store
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
-        };
-        var storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            environment.storeIngestError(key, errorSnapshot, storeMetadataParams, ingestStagingStore);
-        };
-        var storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
-            validateNotDisposed();
-            // publishing to L2 is essentially "broadcasting" because the onChanged
-            // handler will fire which will revive records to the main L1 store and
-            // call the base storeBroadcast
-            return publishChangesToDurableStore();
-        };
-        var publishChangesToDurableStore = function (additionalDurableStoreOperations) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                return Promise.resolve();
-            }
-            var promise = flushInMemoryStoreValuesToDurableStore(ingestStagingStore, durableStore, durableStoreErrorHandler, additionalDurableStoreOperations);
-            ingestStagingStore = null;
-            return promise;
-        };
-        var storeLookup = function (sel, createSnapshot, refresh, ttlStrategy) {
-            validateNotDisposed();
-            // if this lookup is right after an ingest there will be a staging store
-            if (ingestStagingStore !== null) {
-                var reader = new engine.Reader(ingestStagingStore, sel.variables, refresh, undefined, ttlStrategy);
-                return reader.read(sel);
-            }
-            // otherwise this is from buildCachedSnapshot and we should use the luvio
-            // L1 store
-            return environment.storeLookup(sel, createSnapshot, refresh, ttlStrategy);
-        };
-        var storeEvict = function (key) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            ingestStagingStore.evict(key);
-        };
-        var getNode = function (key) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            return environment.getNode(key, ingestStagingStore);
-        };
-        var wrapNormalizedGraphNode = function (normalized) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
-        };
-        var rebuildSnapshot = function (snapshot, onRebuild) {
-            validateNotDisposed();
-            // try rebuilding from memory
-            environment.rebuildSnapshot(snapshot, function (rebuilt) {
-                // only try reviving from durable store if snapshot is unfulfilled
-                if (rebuilt.state !== 'Unfulfilled') {
-                    onRebuild(rebuilt);
-                    return;
-                }
-                // Do an L2 revive and emit to subscriber using the callback.
-                reviveSnapshot(environment, durableStore, rebuilt, durableStoreErrorHandler, function () {
-                    // reviveSnapshot will revive into L1, and since "records" is a reference
-                    // (and not a copy) to the L1 records we can use it for rebuild
-                    var rebuiltSnap;
-                    environment.rebuildSnapshot(snapshot, function (rebuilt) {
-                        rebuiltSnap = rebuilt;
-                    });
-                    return rebuiltSnap;
-                }).then(function (result) {
-                    onRebuild(result.snapshot);
-                });
-            });
-        };
-        var withContext = function (adapter, options) {
-            validateNotDisposed();
-            var contextId = options.contextId, contextVersion = options.contextVersion, onContextLoaded = options.onContextLoaded;
-            var context = undefined;
-            var contextKey = "".concat(contextId);
-            // if a context version is supplied, key with the version encoded
-            if (contextVersion !== undefined) {
-                contextKey += "::".concat(contextVersion);
-            }
-            contextKey += ADAPTER_CONTEXT_ID_SUFFIX;
-            var contextAsPromise = reviveOrCreateContext(contextKey, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded);
-            return function (config, requestContext) {
-                if (context === undefined) {
-                    return contextAsPromise.then(function (revivedContext) {
-                        context = revivedContext;
-                        return adapter(config, context, requestContext); // TODO - remove as any cast after https://github.com/salesforce-experience-platform-emu/luvio/pull/230
-                    });
-                }
-                return adapter(config, context, requestContext);
-            };
-        };
-        var storeRedirect = function (existingKey, canonicalKey) {
-            validateNotDisposed();
-            // call redirect on staging store so "old" keys are removed from L2 on
-            // the next publishChangesToDurableStore.  NOTE: we don't need to call
-            // redirect on the base environment store because staging store and base
-            // L1 store share the same redirect and reverseRedirectKeys
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            ingestStagingStore.redirect(existingKey, canonicalKey);
-        };
-        var storeSetTTLOverride = function (namespace, representationName, ttl) {
-            validateNotDisposed();
-            return Promise.all([
-                environment.storeSetTTLOverride(namespace, representationName, ttl),
-                durableTTLStore.setDurableTTLOverride(namespace, representationName, ttl),
-            ]).then();
-        };
-        var storeSetDefaultTTLOverride = function (ttl) {
-            validateNotDisposed();
-            return Promise.all([
-                environment.storeSetDefaultTTLOverride(ttl),
-                durableTTLStore.setDefaultDurableTTLOverrides(ttl),
-            ]).then();
-        };
-        var getDurableTTLOverrides = function () {
-            validateNotDisposed();
-            return durableTTLStore.getDurableTTLOverrides();
-        };
-        var dispatchResourceRequest = function (request, context, eventObservers) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            validateNotDisposed();
-                            if (!(initializationPromise !== undefined)) return [3 /*break*/, 2];
-                            return [4 /*yield*/, initializationPromise];
-                        case 1:
-                            _a.sent();
-                            _a.label = 2;
-                        case 2: return [2 /*return*/, environment.dispatchResourceRequest(request, context, eventObservers)];
-                    }
-                });
-            });
-        };
-        // NOTE: we can't use "async" keyword on this function because that would
-        // force it to always be an async response.  The signature is a union
-        // of sync/async so no "awaiting" in this function, just promise-chaining
-        var applyCachePolicy = function (luvio, adapterRequestContext, buildSnapshotContext, buildCachedSnapshot, buildNetworkSnapshot) {
-            validateNotDisposed();
-            var wrappedCacheLookup = function (injectedBuildSnapshotContext, injectedStoreLookup) {
-                var snapshot = buildCachedSnapshot(injectedBuildSnapshotContext, injectedStoreLookup, luvio);
-                // if the adapter attempted to do an L1 lookup and it was unfulfilled
-                // then we can attempt an L2 lookup
-                if (isUnfulfilledSnapshot(snapshot)) {
-                    var start_1 = Date.now();
-                    emitDurableEnvironmentAdapterEvent({ type: 'l2-revive-start' }, adapterRequestContext.eventObservers);
-                    var revivedSnapshot = reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, function () { return injectedStoreLookup(snapshot.select, snapshot.refresh); }).then(function (result) {
-                        emitDurableEnvironmentAdapterEvent({
-                            type: 'l2-revive-end',
-                            snapshot: result.snapshot,
-                            duration: Date.now() - start_1,
-                            l2Trips: result.metrics.l2Trips,
-                        }, adapterRequestContext.eventObservers);
-                        return result.snapshot;
-                    });
-                    return revivedSnapshot;
-                }
-                // otherwise just return what buildCachedSnapshot gave us
-                return snapshot;
-            };
-            var wrappedApplyCachePolicy = function () {
-                return environment.applyCachePolicy(luvio, adapterRequestContext, buildSnapshotContext, wrappedCacheLookup, buildNetworkSnapshot);
-            };
-            // GET adapters call applyCachePolicy before any other luvio
-            // function so this is our chance to ensure we're initialized
-            return initializationPromise !== undefined
-                ? initializationPromise.then(wrappedApplyCachePolicy)
-                : wrappedApplyCachePolicy();
-        };
-        var getIngestStagingStoreRecords = function () {
-            validateNotDisposed();
-            if (ingestStagingStore !== null) {
-                return ingestStagingStore.fallbackStringKeyInMemoryStore.records;
-            }
-            return {};
-        };
-        var getIngestStagingStoreMetadata = function () {
-            validateNotDisposed();
-            if (ingestStagingStore !== null) {
-                return ingestStagingStore.fallbackStringKeyInMemoryStore.metadata;
-            }
-            return {};
-        };
-        var handleSuccessResponse = function (ingestAndBroadcastFunc, getResponseCacheKeysFunc) {
-            return __awaiter(this, void 0, void 0, function () {
-                var cacheKeyMap, cacheKeyMapKeys, keysToRevive, _i, cacheKeyMapKeys_1, cacheKeyMapKey, cacheKey, canonical, snapshotFromMemoryIngest, keysToReviveAsArray, readWritePromise, _a, keysToReviveAsArray_1, key, _b, keysToReviveAsArray_2, key, pendingPromise, _c, select, refresh, result;
-                var _this = this;
-                return __generator(this, function (_d) {
-                    switch (_d.label) {
-                        case 0:
-                            validateNotDisposed();
-                            cacheKeyMap = getResponseCacheKeysFunc();
-                            cacheKeyMapKeys = cacheKeyMap.keysAsArray();
-                            keysToRevive = new engine.StoreKeySet();
-                            for (_i = 0, cacheKeyMapKeys_1 = cacheKeyMapKeys; _i < cacheKeyMapKeys_1.length; _i++) {
-                                cacheKeyMapKey = cacheKeyMapKeys_1[_i];
-                                cacheKey = cacheKeyMap.get(cacheKeyMapKey);
-                                if (cacheKey.mergeable === true) {
-                                    canonical = environment.storeGetCanonicalKey(cacheKeyMapKey);
-                                    keysToRevive.add(canonical);
-                                }
-                            }
-                            snapshotFromMemoryIngest = undefined;
-                            keysToReviveAsArray = Array.from(keysToRevive.keysAsStrings());
-                            if (!(keysToReviveAsArray.length > 0)) return [3 /*break*/, 5];
-                            readWritePromise = (function () { return __awaiter(_this, void 0, void 0, function () {
-                                var pendingPromises, _i, keysToReviveAsArray_3, key, pendingPromise, entries;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            pendingPromises = [];
-                                            for (_i = 0, keysToReviveAsArray_3 = keysToReviveAsArray; _i < keysToReviveAsArray_3.length; _i++) {
-                                                key = keysToReviveAsArray_3[_i];
-                                                pendingPromise = mergeKeysPromiseMap.get(key);
-                                                if (pendingPromise !== undefined) {
-                                                    // IMPORTANT: while on the synchronous code path we get a
-                                                    // handle to pendingPromise and push it onto the array.
-                                                    // This is important because later in this synchronous code
-                                                    // path we will upsert readWritePromise into the
-                                                    // mergeKeysPromiseMap (essentially overwriting pendingPromise
-                                                    // in the map).
-                                                    pendingPromises.push(pendingPromise);
-                                                }
-                                            }
-                                            return [4 /*yield*/, Promise.all(pendingPromises)];
-                                        case 1:
-                                            _a.sent();
-                                            return [4 /*yield*/, durableStore.getEntries(keysToReviveAsArray, DefaultDurableSegment)];
-                                        case 2:
-                                            entries = _a.sent();
-                                            ingestStagingStore = buildIngestStagingStore(environment);
-                                            publishDurableStoreEntries(entries, function (key, record) {
-                                                if (typeof key === 'string') {
-                                                    ingestStagingStore.fallbackStringKeyInMemoryStore.records[key] =
-                                                        record;
-                                                }
-                                                else {
-                                                    ingestStagingStore.recordsMap.set(key, record);
-                                                }
-                                            }, function (key, metadata) {
-                                                if (typeof key === 'string') {
-                                                    ingestStagingStore.fallbackStringKeyInMemoryStore.metadata[key] =
-                                                        metadata;
-                                                }
-                                                else {
-                                                    ingestStagingStore.metadataMap.set(key, metadata);
-                                                }
-                                            });
-                                            return [4 /*yield*/, ingestAndBroadcastFunc()];
-                                        case 3:
-                                            snapshotFromMemoryIngest = _a.sent();
-                                            return [2 /*return*/];
-                                    }
-                                });
-                            }); })();
-                            for (_a = 0, keysToReviveAsArray_1 = keysToReviveAsArray; _a < keysToReviveAsArray_1.length; _a++) {
-                                key = keysToReviveAsArray_1[_a];
-                                // we are overwriting the previous promise at this key, but that
-                                // is ok because we got a handle to it earlier (see the IMPORTANT
-                                // comment about 35 lines up)
-                                mergeKeysPromiseMap.set(key, readWritePromise);
-                            }
-                            _d.label = 1;
-                        case 1:
-                            _d.trys.push([1, , 3, 4]);
-                            return [4 /*yield*/, readWritePromise];
-                        case 2:
-                            _d.sent();
-                            return [3 /*break*/, 4];
-                        case 3:
-                            for (_b = 0, keysToReviveAsArray_2 = keysToReviveAsArray; _b < keysToReviveAsArray_2.length; _b++) {
-                                key = keysToReviveAsArray_2[_b];
-                                pendingPromise = mergeKeysPromiseMap.get(key);
-                                // cleanup the entry from the map if this is the last promise
-                                // for that key
-                                if (pendingPromise === readWritePromise) {
-                                    mergeKeysPromiseMap.delete(key);
-                                }
-                            }
-                            return [7 /*endfinally*/];
-                        case 4: return [3 /*break*/, 7];
-                        case 5:
-                            // we aren't doing any merging so we don't have to synchronize, the
-                            // underlying DurableStore implementation takes care of R/W sync
-                            // so all we have to do is ingest then write to L2
-                            ingestStagingStore = buildIngestStagingStore(environment);
-                            return [4 /*yield*/, ingestAndBroadcastFunc()];
-                        case 6:
-                            snapshotFromMemoryIngest = _d.sent();
-                            _d.label = 7;
-                        case 7:
-                            if (snapshotFromMemoryIngest === undefined) {
-                                return [2 /*return*/, undefined];
-                            }
-                            if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
-                                return [2 /*return*/, snapshotFromMemoryIngest];
-                            }
-                            _c = snapshotFromMemoryIngest, select = _c.select, refresh = _c.refresh;
-                            return [4 /*yield*/, reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, function () { return environment.storeLookup(select, environment.createSnapshot, refresh); })];
-                        case 8:
-                            result = _d.sent();
-                            return [2 /*return*/, result.snapshot];
-                    }
-                });
-            });
-        };
-        var handleErrorResponse = function (ingestAndBroadcastFunc) {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    validateNotDisposed();
-                    ingestStagingStore = buildIngestStagingStore(environment);
-                    return [2 /*return*/, ingestAndBroadcastFunc()];
-                });
-            });
-        };
-        var getNotifyChangeStoreEntries = function (keys) {
-            validateNotDisposed();
-            return durableStore
-                .getEntries(keys.map(engine.serializeStructuredKey), DefaultDurableSegment)
-                .then(function (durableRecords) {
-                var entries = [];
-                publishDurableStoreEntries(durableRecords, function (key, record) {
-                    entries.push({
-                        key: key,
-                        record: record,
-                    });
-                }, function () { });
-                return entries;
-            });
-        };
-        environment.defaultCachePolicy = {
-            type: 'stale-while-revalidate',
-            implementation: engine.buildStaleWhileRevalidateImplementation(Number.MAX_SAFE_INTEGER),
-        };
-        return create(environment, {
-            publishStoreMetadata: { value: publishStoreMetadata },
-            storeIngest: { value: storeIngest },
-            storeIngestError: { value: storeIngestError },
-            storeBroadcast: { value: storeBroadcast },
-            storeLookup: { value: storeLookup },
-            storeEvict: { value: storeEvict },
-            wrapNormalizedGraphNode: { value: wrapNormalizedGraphNode },
-            getNode: { value: getNode },
-            rebuildSnapshot: { value: rebuildSnapshot },
-            withContext: { value: withContext },
-            storeSetTTLOverride: { value: storeSetTTLOverride },
-            storeSetDefaultTTLOverride: { value: storeSetDefaultTTLOverride },
-            storePublish: { value: storePublish },
-            storeRedirect: { value: storeRedirect },
-            dispose: { value: dispose },
-            publishChangesToDurableStore: { value: publishChangesToDurableStore },
-            getDurableTTLOverrides: { value: getDurableTTLOverrides },
-            dispatchResourceRequest: { value: dispatchResourceRequest },
-            applyCachePolicy: { value: applyCachePolicy },
-            getIngestStagingStoreRecords: { value: getIngestStagingStoreRecords },
-            getIngestStagingStoreMetadata: { value: getIngestStagingStoreMetadata },
-            handleSuccessResponse: { value: handleSuccessResponse },
-            handleErrorResponse: { value: handleErrorResponse },
-            getNotifyChangeStoreEntries: { value: getNotifyChangeStoreEntries },
-        });
-    }
-
-    exports.DURABLE_METADATA_VERSION = DURABLE_METADATA_VERSION;
-    exports.DefaultDurableSegment = DefaultDurableSegment;
-    exports.isDurableEnvironmentEvent = isDurableEnvironmentEvent;
-    exports.makeDurable = makeDurable;
-    exports.publishDurableStoreEntries = publishDurableStoreEntries;
-
-}));