@salesforce/lds-runtime-bridge 0.1.0-dev1

package/dist/ldsRuntimeBridge.js

@@ -0,0 +1,2014 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/*
+ *  ATTENTION!
+ *  THIS IS A GENERATED FILE FROM https://github.com/salesforce-experience-platform-emu/lds-lightning-platform
+ *  If you would like to contribute to LDS, please follow the steps outlined in the git repo.
+ *  Any changes made to this file in p4 will be automatically overwritten.
+ *  *******************************************************************************************
+ */
+import { setDefaultLuvio } from 'force/ldsEngine';
+import { setBypassDeepFreeze, StoreKeySet, serializeStructuredKey, StringKeyInMemoryStore, Reader, deepFreeze, emitAdapterEvent, InMemoryStore, Environment, Luvio } from 'force/luvioEngine';
+import { setupInstrumentation, instrumentAdapter as instrumentAdapter$1, instrumentLuvio } from 'force/ldsInstrumentation';
+import { idleDetector, getInstrumentation } from 'o11y/client';
+import { instrument } from 'force/ldsBindings';
+import { extractRecordIdFromStoreKey, RECORD_VIEW_ENTITY_ID_PREFIX, isStoreKeyRecordViewEntity, keyBuilderRecord, RECORD_ID_PREFIX, RECORD_FIELDS_KEY_JUNCTION } from 'force/ldsAdaptersUiapi';
+import networkAdapter from 'force/ldsNetwork';
+import { initializeOneStore, getRuntime as getRuntime$1 } from 'native/ldsRuntimeMobile';
+import ldsEngineCreator from 'force/ldsEngineCreator';
+
+// 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 RedirectDurableSegment = 'REDIRECT_KEYS';
+const MessagingDurableSegment = 'MESSAGING';
+const MessageNotifyStoreUpdateAvailable = 'notifyStoreUpdateAvailable';
+
+const { keys: keys$2, create: create$2, assign: assign$2, freeze: freeze$1 } = Object;
+
+//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 isStoreEntryError(storeRecord) {
+    if (!storeRecord || typeof storeRecord !== 'object') {
+        return false;
+    }
+    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) {
+    const revivedKeys = new StoreKeySet();
+    let hadUnexpectedShape = false;
+    if (durableRecords === undefined) {
+        return { revivedKeys, hadUnexpectedShape };
+    }
+    const durableKeys = keys$2(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);
+        }
+        put(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, unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, revivingStore, reviveMetrics = { l2Trips: [] }) {
+    const { recordId, select, missingLinks, 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,
+        });
+    }
+    const keysToReviveSet = new StoreKeySet();
+    if (revivingStore) {
+        // Any stale keys since the last l2 read should be cleared and fetched again
+        for (const staleKey of revivingStore.staleEntries) {
+            keysToReviveSet.add(staleKey);
+        }
+        revivingStore.clearStale();
+    }
+    else {
+        // when not using a reviving store:
+        // 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
+        keysToReviveSet.add(recordId);
+        keysToReviveSet.merge(seenRecords);
+    }
+    keysToReviveSet.merge(missingLinks);
+    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.storePut.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, missingLinks: newSnapshotMissingLinks, recordId: newSnapshotRecordId, } = snapshot;
+            const newKeysToReviveSet = new StoreKeySet();
+            newKeysToReviveSet.add(newSnapshotRecordId);
+            newKeysToReviveSet.merge(newSnapshotSeenRecords);
+            newKeysToReviveSet.merge(newSnapshotMissingLinks);
+            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, revivingStore, 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$2(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 flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler, redirects, shouldFlush, additionalDurableStoreOperations = [], enableDurableMetadataRefresh = false) {
+    const durableRecords = create$2(null);
+    const refreshedDurableRecords = create$2(null);
+    const evictedRecords = create$2(null);
+    const { 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$2({ ...visitedIds, ...refreshedIds });
+    for (let i = 0, len = keys$1.length; i < len; i += 1) {
+        const key = keys$1[i];
+        const canonicalKey = store.getCanonicalRecordId(key);
+        // this record has been redirected, evict the original
+        if (canonicalKey !== key) {
+            evictedRecords[key] = true;
+            continue;
+        }
+        const record = store.readEntry(key);
+        const wasVisited = visitedIds[key] !== undefined;
+        // this record has been evicted, evict from DS
+        if (wasVisited && record === undefined) {
+            evictedRecords[key] = true;
+            continue;
+        }
+        const metadata = store.readMetadata(key);
+        const entries = wasVisited === true || enableDurableMetadataRefresh === false
+            ? durableRecords
+            : refreshedDurableRecords;
+        const { flushValue: flushValue, forceFlushMetadata: flushMetadata } = shouldFlush(key, record);
+        if (flushValue) {
+            setRecordTo(entries, key, record, metadata);
+        }
+        else {
+            // If the record is not to be flushed, we still need to update the metadata
+            if (flushMetadata === true) {
+                setRecordTo(refreshedDurableRecords, key, record, metadata);
+            }
+        }
+    }
+    const durableStoreOperations = additionalDurableStoreOperations;
+    const recordKeys = keys$2(durableRecords);
+    if (recordKeys.length > 0) {
+        // publishes with data
+        durableStoreOperations.push({
+            type: 'setEntries',
+            entries: durableRecords,
+            segment: DefaultDurableSegment,
+        });
+    }
+    const refreshKeys = keys$2(refreshedDurableRecords);
+    if (refreshKeys.length > 0) {
+        // publishes with only metadata updates
+        durableStoreOperations.push({
+            type: 'setMetadata',
+            entries: refreshedDurableRecords,
+            segment: DefaultDurableSegment,
+        });
+    }
+    // redirects
+    redirects.forEach((value, key) => {
+        durableStoreOperations.push({
+            type: 'setEntries',
+            entries: {
+                [key]: {
+                    data: { key, redirect: value },
+                },
+            },
+            segment: RedirectDurableSegment,
+        });
+    });
+    // evicts
+    const evictedKeys = keys$2(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 setRecordTo(entries, key, record, metadata) {
+    entries[key] = {
+        data: record,
+    };
+    if (metadata !== undefined) {
+        entries[key].metadata = {
+            ...metadata,
+            metadataVersion: DURABLE_METADATA_VERSION,
+        };
+    }
+}
+
+const DurableEnvironmentEventDiscriminator = 'durable';
+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);
+    }
+}
+
+/**
+ * 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();
+}
+
+async function reviveRedirects(durableStore, env) {
+    const entries = await durableStore.getAllEntries(RedirectDurableSegment);
+    if (entries) {
+        for (const durableEntry of Object.keys(entries)) {
+            const entry = entries[durableEntry];
+            const { data: { key, redirect }, } = entry;
+            if (entry) {
+                env.storeRedirect(key, redirect);
+            }
+        }
+    }
+}
+
+function buildRevivingStagingStore(upstreamStore) {
+    const localStore = new StringKeyInMemoryStore();
+    const staleEntries = new Set();
+    function readEntry(key) {
+        if (typeof key !== 'string') {
+            return upstreamStore.readEntry(key);
+        }
+        let storeEntry = localStore.readEntry(key);
+        if (!storeEntry) {
+            // read from upstream store...
+            storeEntry = upstreamStore.readEntry(key);
+            // put it in our store to avoid it getting evicted prior to the next durable store read
+            localStore.put(key, storeEntry);
+        }
+        return storeEntry;
+    }
+    // Entries are marked stale by the durable store change listener. They are not
+    // immediately evicted so as to not result in a cache miss during a rebuild.
+    // The revive process will clear stale entries and read them from the durable store
+    // on the next revive loop.
+    function markStale(key) {
+        staleEntries.add(key);
+    }
+    // The revive loop clears stale entries right before reading from the durable store.
+    // Any stale entries will be revived to ensure they are present in L1 and match the
+    // latest data.
+    function clearStale() {
+        for (const key of staleEntries) {
+            localStore.dealloc(key);
+        }
+        staleEntries.clear();
+    }
+    // All functions other than `readEntry` pass through to the upstream store.
+    // A reviving store is only "active" during a call to `environment.storeLookup`, and will
+    // be used by the reader attempting to build an L1 snapshot. Immediately after the L1 rebuild
+    // the reviving store becomes inactive other than receiving change notifications.
+    return create$2(upstreamStore, {
+        readEntry: { value: readEntry },
+        markStale: { value: markStale },
+        clearStale: { value: clearStale },
+        staleEntries: { value: staleEntries },
+    });
+}
+
+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$2(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.  Sets the default
+ * cache policy to stale-while-revalidate with infinite staleDuration.
+ *
+ * @param environment The base environment
+ * @param durableStore A DurableStore implementation
+ * @param instrumentation An instrumentation function implementation
+ */
+function makeDurable(environment, { durableStore, instrumentation, useRevivingStore, shouldFlush, enableDurableMetadataRefresh = false, disableDeepFreeze = false, }) {
+    // runtimes can choose to disable deepFreeze, e.g. headless mobile runtime
+    setBypassDeepFreeze(disableDeepFreeze);
+    let stagingStore = null;
+    const durableTTLStore = new DurableTTLStore(durableStore);
+    const 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.
+    const pendingContextStoreKeys = new Set();
+    // Reviving stores are tracked so that they can be notified of durable store change notifications.
+    const revivingStores = new Set();
+    // redirects that need to be flushed to the durable store
+    const pendingStoreRedirects = new Map();
+    const contextStores = create$2(null);
+    let initializationPromise = new Promise((resolve) => {
+        const finish = () => {
+            resolve();
+            initializationPromise = undefined;
+        };
+        Promise.all([
+            reviveTTLOverrides(durableTTLStore, environment),
+            reviveRedirects(durableStore, 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 = [];
+        const redirectSegmentKeys = [];
+        const metadataRefreshSegmentKeys = [];
+        const messagingSegmentKeys = [];
+        let shouldBroadcast = false;
+        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) {
+                if (change.type === 'setMetadata') {
+                    metadataRefreshSegmentKeys.push(...change.ids);
+                }
+                else {
+                    defaultSegmentKeys.push(...change.ids);
+                }
+            }
+            else if (change.segment === AdapterContextSegment) {
+                adapterContextSegmentKeys.push(...change.ids);
+            }
+            else if (change.segment === RedirectDurableSegment) {
+                redirectSegmentKeys.push(...change.ids);
+            }
+            else if (change.segment === MessagingDurableSegment) {
+                messagingSegmentKeys.push(...change.ids);
+            }
+        }
+        if (redirectSegmentKeys.length > 0) {
+            const redirectEntries = await durableStore.getEntries(redirectSegmentKeys, RedirectDurableSegment);
+            if (redirectEntries !== undefined) {
+                const redirectKeys = Object.keys(redirectEntries);
+                for (const key of redirectKeys) {
+                    const redirectData = redirectEntries[key];
+                    environment.storeRedirect(redirectData.data.key, redirectData.data.redirect);
+                    shouldBroadcast = true;
+                }
+            }
+        }
+        // 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$2(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];
+                // 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);
+                for (const revivingStore of revivingStores) {
+                    revivingStore.markStale(key);
+                }
+            }
+            shouldBroadcast = true;
+        }
+        // process metadata only refreshes
+        if (metadataRefreshSegmentKeys.length > 0) {
+            const filteredKeys = metadataRefreshSegmentKeys.filter((s) => environment.storeKeyExists(s));
+            if (filteredKeys.length > 0) {
+                const entries = await durableStore.getMetadata(filteredKeys, DefaultDurableSegment);
+                if (entries !== undefined) {
+                    const entryKeys = keys$2(entries);
+                    for (let i = 0, len = entryKeys.length; i < len; i++) {
+                        const entryKey = entryKeys[i];
+                        const { metadata } = entries[entryKey];
+                        if (metadata !== undefined) {
+                            environment.putStoreMetadata(entryKey, metadata, false);
+                        }
+                    }
+                }
+            }
+        }
+        if (shouldBroadcast) {
+            await environment.storeBroadcast(rebuildSnapshot, environment.snapshotAvailable);
+        }
+        // if having notifyStoreUpdateAvailable msg, then pull the message body out from store
+        // and call environment.notifyStoreUpdateAvailable
+        if (messagingSegmentKeys.includes(MessageNotifyStoreUpdateAvailable)) {
+            const entries = await durableStore.getEntries([MessageNotifyStoreUpdateAvailable], MessagingDurableSegment);
+            if (entries !== undefined) {
+                const notifyEntry = entries[MessageNotifyStoreUpdateAvailable];
+                if (notifyEntry !== undefined) {
+                    const keys = notifyEntry.data;
+                    if (keys.length > 0) {
+                        environment.notifyStoreUpdateAvailable(keys);
+                    }
+                }
+            }
+        }
+    });
+    const dispose = function () {
+        validateNotDisposed();
+        disposed = true;
+        return unsubscribe();
+    };
+    const storePublish = function (key, data) {
+        validateNotDisposed();
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
+        }
+        stagingStore.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.storeDealloc(key);
+    };
+    const publishStoreMetadata = function (recordId, storeMetadata) {
+        validateNotDisposed();
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
+        }
+        stagingStore.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 (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
+        }
+        environment.storeIngest(key, ingest, response, luvio, stagingStore);
+    };
+    const storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
+        validateNotDisposed();
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
+        }
+        environment.storeIngestError(key, errorSnapshot, storeMetadataParams, stagingStore);
+    };
+    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 (additionalDurableStoreOperations) {
+        validateNotDisposed();
+        if (stagingStore === null) {
+            return Promise.resolve();
+        }
+        const promise = flushInMemoryStoreValuesToDurableStore(stagingStore, durableStore, durableStoreErrorHandler, new Map(pendingStoreRedirects), shouldFlush !== null && shouldFlush !== void 0 ? shouldFlush : (() => ({ flushValue: true })), additionalDurableStoreOperations, enableDurableMetadataRefresh);
+        pendingStoreRedirects.clear();
+        stagingStore = null;
+        return promise;
+    };
+    const storeLookup = function (sel, createSnapshot, refresh, ttlStrategy) {
+        validateNotDisposed();
+        // if this lookup is right after an ingest or during a revive there will be a staging store
+        if (stagingStore !== null) {
+            const reader = new Reader(stagingStore, 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 (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
+        }
+        stagingStore.evict(key);
+    };
+    const getNode = function (key) {
+        validateNotDisposed();
+        if (stagingStore !== null) {
+            return environment.getNode(key, stagingStore);
+        }
+        return environment.getNode(key);
+    };
+    const wrapNormalizedGraphNode = function (normalized, key) {
+        validateNotDisposed();
+        if (stagingStore !== null) {
+            return environment.wrapNormalizedGraphNode(normalized, key, stagingStore);
+        }
+        return environment.wrapNormalizedGraphNode(normalized, key);
+    };
+    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.
+            reviveSnapshotWrapper(rebuilt, () => {
+                // 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();
+        pendingStoreRedirects.set(existingKey, canonicalKey);
+        // 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 (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
+        }
+        stagingStore.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 = reviveSnapshotWrapper(snapshot, () => 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 (stagingStore !== null) {
+            return stagingStore.fallbackStringKeyInMemoryStore.records;
+        }
+        return {};
+    };
+    const getIngestStagingStoreMetadata = function () {
+        validateNotDisposed();
+        if (stagingStore !== null) {
+            return stagingStore.fallbackStringKeyInMemoryStore.metadata;
+        }
+        return {};
+    };
+    const getIngestStagingStore = function () {
+        validateNotDisposed();
+        return stagingStore === null || stagingStore === void 0 ? void 0 : stagingStore.fallbackStringKeyInMemoryStore;
+    };
+    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) {
+                const canonical = environment.storeGetCanonicalKey(cacheKeyMapKey);
+                keysToRevive.add(canonical);
+            }
+        }
+        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);
+                stagingStore = buildIngestStagingStore(environment);
+                publishDurableStoreEntries(entries, (key, record) => {
+                    if (typeof key === 'string') {
+                        stagingStore.fallbackStringKeyInMemoryStore.records[key] = record;
+                    }
+                    else {
+                        stagingStore.recordsMap.set(key, record);
+                    }
+                }, (key, metadata) => {
+                    if (typeof key === 'string') {
+                        stagingStore.fallbackStringKeyInMemoryStore.metadata[key] = metadata;
+                    }
+                    else {
+                        stagingStore.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
+            stagingStore = 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 reviveSnapshotWrapper(snapshotFromMemoryIngest, () => environment.storeLookup(select, environment.createSnapshot, refresh));
+        return result.snapshot;
+    };
+    const handleErrorResponse = async function (ingestAndBroadcastFunc) {
+        validateNotDisposed();
+        stagingStore = 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;
+        });
+    };
+    // flag entries specified by keys in durable store as expired.
+    // send a notifyStoreUpdateAvailable message through durable store set entries to
+    // indirectly triggers all js environments to refresh snapshots if overlapping with keys.
+    const notifyStoreUpdateAvailable = async function (keys$1) {
+        validateNotDisposed();
+        const entryKeys = keys$1.map(serializeStructuredKey);
+        const entries = await durableStore.getEntries(entryKeys, DefaultDurableSegment);
+        if (entries === undefined || keys$2(entries).length === 0) {
+            return environment.notifyStoreUpdateAvailable(keys$1);
+        }
+        const now = Date.now();
+        let needWriteBack = false;
+        for (let i = 0; i < entryKeys.length; i++) {
+            const key = entryKeys[i];
+            const entry = entries[key];
+            if (entry !== undefined) {
+                const storeEntry = entry;
+                if (storeEntry.metadata !== undefined) {
+                    storeEntry.metadata = {
+                        ...storeEntry.metadata,
+                        expirationTimestamp: now,
+                    };
+                }
+                needWriteBack = true;
+            }
+        }
+        if (needWriteBack) {
+            await durableStore.setEntries(entries, DefaultDurableSegment);
+        }
+        // push a notifyStoreUpdateAvailable message with entryKeys as data into messaging segment
+        await durableStore.setEntries({ notifyStoreUpdateAvailable: { data: entryKeys } }, MessagingDurableSegment);
+        return Promise.resolve(undefined);
+    };
+    const reviveSnapshotWrapper = function (unavailableSnapshot, buildL1Snapshot) {
+        let revivingStore = undefined;
+        if (useRevivingStore) {
+            // NOTE: `store` is private, there doesn't seem to be a better,
+            // cleaner way of accessing it from a derived environment.
+            let baseStore = environment.store;
+            // If we're rebuilding during an ingest, the existing staging store should be the base store.
+            if (stagingStore) {
+                baseStore = stagingStore;
+            }
+            let revivingStore = buildRevivingStagingStore(baseStore);
+            revivingStores.add(revivingStore);
+        }
+        return reviveSnapshot(environment, durableStore, unavailableSnapshot, durableStoreErrorHandler, () => {
+            const tempStore = stagingStore;
+            const result = buildL1Snapshot();
+            stagingStore = tempStore;
+            return result;
+        }, revivingStore).finally(() => {
+        });
+    };
+    const expirePossibleStaleRecords = async function (keys$1, config, refresh) {
+        validateNotDisposed();
+        const metadataKeys = keys$1.map(serializeStructuredKey);
+        const now = Date.now();
+        const entries = await durableStore.getMetadata(metadataKeys, DefaultDurableSegment);
+        if (entries === undefined || keys$2(entries).length === 0) {
+            return environment.expirePossibleStaleRecords(keys$1);
+        }
+        let metaDataChanged = false;
+        const metadataEntries = metadataKeys.reduce((accu, key) => {
+            const metadataEntry = entries[key];
+            if (metadataEntry.metadata !== undefined) {
+                const metadata = { ...metadataEntry.metadata, expirationTimestamp: now };
+                accu[key] = { metadata };
+                metaDataChanged = true;
+            }
+            return accu;
+        }, {});
+        if (metaDataChanged) {
+            await durableStore.setMetadata(metadataEntries, DefaultDurableSegment);
+        }
+        if (config !== undefined && refresh !== undefined) {
+            return environment.refreshPossibleStaleRecords(config, refresh);
+        }
+        return Promise.resolve();
+    };
+    // set the default cache policy of the base environment
+    environment.setDefaultCachePolicy({
+        type: 'stale-while-revalidate',
+        staleDurationSeconds: Number.MAX_SAFE_INTEGER,
+    });
+    return create$2(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 },
+        getIngestStagingStore: { value: getIngestStagingStore },
+        handleSuccessResponse: { value: handleSuccessResponse },
+        handleErrorResponse: { value: handleErrorResponse },
+        getNotifyChangeStoreEntries: { value: getNotifyChangeStoreEntries },
+        notifyStoreUpdateAvailable: { value: notifyStoreUpdateAvailable },
+        expirePossibleStaleRecords: { value: expirePossibleStaleRecords },
+    });
+}
+
+const { keys: keys$1, create: create$1, assign: assign$1, entries: entries$1, values: values$1 } = Object;
+const { stringify, parse } = JSON;
+
+function selectColumnsFromTableWhereKeyIn(columnNames, table, keyColumnName, whereIn) {
+    const paramList = whereIn.map(() => '?').join(',');
+    return `SELECT ${columnNames.join(',')} FROM ${table} WHERE ${keyColumnName} IN (${paramList})`;
+}
+function selectColumnsFromTableWhereKeyInNamespaced(columnNames, table, keyColumnName, whereIn, namespaceColumnName) {
+    const paramList = whereIn.map(() => '?').join(',');
+    return `SELECT ${columnNames.join(',')} FROM ${table} WHERE ${namespaceColumnName} = ? AND ${keyColumnName} IN (${paramList})`;
+}
+
+// These const values must be in sync with the latest
+// @salesforce/nimbus-plugin-lds/sql schema file
+const TABLE_NAME$1 = 'lds_data';
+const COLUMN_NAME_KEY$2 = 'key';
+const COLUMN_NAME_DATA$2 = 'data';
+const COLUMN_NAME_METADATA$1 = 'metadata';
+class LdsDataTable {
+    constructor(plugin) {
+        this.tableName = TABLE_NAME$1;
+        this.columnNames = [COLUMN_NAME_KEY$2, COLUMN_NAME_DATA$2, COLUMN_NAME_METADATA$1];
+        this.conflictColumnNames = [COLUMN_NAME_KEY$2];
+        this.getAllQuery = `SELECT ${this.columnNames.join(',')} FROM ${this.tableName}`;
+        this.plugin = plugin;
+    }
+    getByKeys(keys) {
+        const getQuery = selectColumnsFromTableWhereKeyIn(this.columnNames, this.tableName, COLUMN_NAME_KEY$2, keys);
+        return new Promise((resolve, reject) => {
+            this.plugin.query(getQuery, keys, (x) => {
+                resolve(this.mapToDurableEntries(x));
+            }, reject);
+        });
+    }
+    getMetadataByKeys(keys) {
+        const query = selectColumnsFromTableWhereKeyIn([COLUMN_NAME_KEY$2, COLUMN_NAME_METADATA$1], this.tableName, COLUMN_NAME_KEY$2, keys);
+        return new Promise((resolve, reject) => {
+            this.plugin.query(query, keys, (results) => {
+                resolve(results.rows.reduce((entries, row) => {
+                    const [key, stringifiedMetadata] = row;
+                    if (stringifiedMetadata !== undefined) {
+                        entries[key] = {
+                            metadata: parse(stringifiedMetadata),
+                        };
+                    }
+                    return entries;
+                }, {}));
+            }, reject);
+        });
+    }
+    getAll() {
+        return new Promise((resolve, reject) => {
+            this.plugin.query(this.getAllQuery, [], (x) => {
+                resolve(this.mapToDurableEntries(x));
+            }, reject);
+        });
+    }
+    entriesToUpsertOperations(entries, segment) {
+        return {
+            type: 'upsert',
+            table: this.tableName,
+            keyColumn: COLUMN_NAME_KEY$2,
+            context: {
+                segment,
+            },
+            conflictColumns: this.conflictColumnNames,
+            columns: this.columnNames,
+            rows: keys$1(entries).reduce((rows, key) => {
+                const entry = entries[key];
+                const { data, metadata } = entry;
+                const row = [key, stringify(data), metadata ? stringify(metadata) : null];
+                rows.push(row);
+                return rows;
+            }, []),
+        };
+    }
+    metadataToUpdateOperations(entries, segment) {
+        return {
+            type: 'update',
+            table: this.tableName,
+            keyColumn: COLUMN_NAME_KEY$2,
+            context: {
+                segment,
+                type: 'setMetadata',
+            },
+            columns: [COLUMN_NAME_METADATA$1],
+            values: keys$1(entries).reduce((values, key) => {
+                const { metadata } = entries[key];
+                const row = [metadata ? stringify(metadata) : null];
+                values[key] = row;
+                return values;
+            }, {}),
+        };
+    }
+    mapToDurableEntries(sqliteResult) {
+        return sqliteResult.rows.reduce((entries, row) => {
+            const [key, stringifiedData, stringifiedMetadata] = row;
+            const durableStoreEntry = {
+                data: parse(stringifiedData),
+            };
+            if (stringifiedMetadata !== null) {
+                durableStoreEntry.metadata = parse(stringifiedMetadata);
+            }
+            entries[key] = durableStoreEntry;
+            return entries;
+        }, {});
+    }
+}
+
+// These const values must be in sync with the latest
+// @salesforce/nimbus-plugin-lds/sql schema file
+const TABLE_NAME = 'lds_internal';
+const COLUMN_NAME_KEY$1 = 'key';
+const COLUMN_NAME_DATA$1 = 'data';
+const COLUMN_NAME_METADATA = 'metadata';
+const COLUMN_NAME_NAMESPACE = 'namespace';
+class LdsInternalDataTable {
+    constructor(plugin) {
+        this.tableName = TABLE_NAME;
+        this.columnNames = [
+            COLUMN_NAME_KEY$1,
+            COLUMN_NAME_DATA$1,
+            COLUMN_NAME_METADATA,
+            COLUMN_NAME_NAMESPACE,
+        ];
+        this.conflictColumnNames = [COLUMN_NAME_KEY$1, COLUMN_NAME_NAMESPACE];
+        this.getAllQuery = `SELECT ${this.columnNames.join(',')} FROM ${this.tableName} WHERE ${COLUMN_NAME_NAMESPACE} = ?`;
+        this.plugin = plugin;
+    }
+    getByKeys(keys, namespace) {
+        if (namespace === undefined) {
+            throw Error('LdsInternalDataTable requires namespace');
+        }
+        const getQuery = selectColumnsFromTableWhereKeyInNamespaced(this.columnNames, this.tableName, COLUMN_NAME_KEY$1, keys, COLUMN_NAME_NAMESPACE);
+        return new Promise((resolve, reject) => {
+            this.plugin.query(getQuery, [namespace].concat(keys), (x) => {
+                resolve(this.mapToDurableEntries(x));
+            }, reject);
+        });
+    }
+    getMetadataByKeys(keys, namespace) {
+        if (namespace === undefined) {
+            throw Error('LdsInternalDataTable requires namespace');
+        }
+        const query = selectColumnsFromTableWhereKeyInNamespaced([COLUMN_NAME_KEY$1, COLUMN_NAME_METADATA], this.tableName, COLUMN_NAME_KEY$1, keys, COLUMN_NAME_NAMESPACE);
+        return new Promise((resolve, reject) => {
+            this.plugin.query(query, [namespace].concat(keys), (results) => {
+                resolve(results.rows.reduce((entries, row) => {
+                    const [key, stringifiedMetadata] = row;
+                    if (stringifiedMetadata !== undefined) {
+                        entries[key] = {
+                            metadata: parse(stringifiedMetadata),
+                        };
+                    }
+                    return entries;
+                }, {}));
+            }, reject);
+        });
+    }
+    getAll(namespace) {
+        return new Promise((resolve, reject) => {
+            this.plugin.query(this.getAllQuery, [namespace], (x) => {
+                resolve(this.mapToDurableEntries(x));
+            }, reject);
+        });
+    }
+    entriesToUpsertOperations(entries, segment) {
+        return {
+            type: 'upsert',
+            table: this.tableName,
+            keyColumn: COLUMN_NAME_KEY$1,
+            context: {
+                segment,
+            },
+            conflictColumns: this.conflictColumnNames,
+            columns: this.columnNames,
+            rows: keys$1(entries).reduce((rows, key) => {
+                const entry = entries[key];
+                const { data, metadata } = entry;
+                const row = [key, stringify(data)];
+                if (metadata) {
+                    row.push(stringify(metadata));
+                }
+                else {
+                    row.push(null);
+                }
+                row.push(segment);
+                rows.push(row);
+                return rows;
+            }, []),
+        };
+    }
+    metadataToUpdateOperations(entries, segment) {
+        return {
+            type: 'update',
+            table: this.tableName,
+            keyColumn: COLUMN_NAME_KEY$1,
+            context: {
+                segment,
+                type: 'setMetadata',
+            },
+            columns: [COLUMN_NAME_METADATA],
+            values: keys$1(entries).reduce((values, key) => {
+                const { metadata } = entries[key];
+                const row = [metadata ? stringify(metadata) : null];
+                values[key] = row;
+                return values;
+            }, {}),
+        };
+    }
+    metadataToUpdateSQLQueries(entries, segment) {
+        return keys$1(entries).reduce((accu, key) => {
+            const { metadata } = entries[key];
+            if (metadata !== undefined) {
+                accu.push({
+                    sql: `UPDATE ${this.tableName} SET ${COLUMN_NAME_METADATA} = ? WHERE (${COLUMN_NAME_KEY$1} IS ? AND ${COLUMN_NAME_NAMESPACE} IS ?)`,
+                    params: [stringify(metadata), key, segment],
+                    change: {
+                        ids: [key],
+                        segment,
+                        type: 'setMetadata',
+                        isExternalChange: false,
+                    },
+                });
+            }
+            return accu;
+        }, []);
+    }
+    mapToDurableEntries(sqliteResult) {
+        return sqliteResult.rows.reduce((entries, row) => {
+            const [key, stringifiedData, stringifiedMetadata] = row;
+            const durableStoreEntry = {
+                data: parse(stringifiedData),
+            };
+            if (stringifiedMetadata !== null) {
+                durableStoreEntry.metadata = parse(stringifiedMetadata);
+            }
+            entries[key] = durableStoreEntry;
+            return entries;
+        }, {});
+    }
+}
+
+const tasker = idleDetector.declareNotifierTaskMulti('NimbusSqliteStore');
+const instrumentation = getInstrumentation('lds-mobile');
+const GRAPHQL_QUERY_ROOT_KEY = 'UiApi::uiapi::Query[uiapi]__uiapi__query';
+const GRAPHQL_QUERY_ROOT_METRIC_NAME = 'gql-query-root-object-size';
+class NimbusSqliteStore {
+    constructor(plugin, additionalTableMap = {}) {
+        this.plugin = plugin;
+        this.internalDataTable = new LdsInternalDataTable(plugin);
+        this.dataTableMap = {
+            ...additionalTableMap,
+            [DefaultDurableSegment]: new LdsDataTable(plugin),
+        };
+    }
+    isEvalSupported() {
+        return true;
+    }
+    query(sql, params) {
+        tasker.add();
+        return new Promise((resolve, reject) => {
+            this.plugin.query(sql, params, (result) => {
+                resolve(result);
+            }, (error) => {
+                reject(error);
+            });
+        }).finally(() => tasker.done());
+    }
+    batchQuery(queries) {
+        const promises = queries.map((q) => this.query(q.sql, q.params));
+        tasker.add();
+        return Promise.all(promises).finally(() => tasker.done());
+    }
+    async getEntries(entryIds, segment) {
+        tasker.add();
+        return this.getTable(segment)
+            .getByKeys(entryIds, segment)
+            .finally(() => tasker.done());
+    }
+    async getMetadata(entryIds, segment) {
+        tasker.add();
+        return this.getTable(segment)
+            .getMetadataByKeys(entryIds, segment)
+            .finally(() => tasker.done());
+    }
+    getAllEntries(segment) {
+        tasker.add();
+        return this.getTable(segment)
+            .getAll(segment)
+            .finally(() => tasker.done());
+    }
+    setEntries(entries, segment) {
+        if (keys$1(entries).length === 0) {
+            return Promise.resolve();
+        }
+        const table = this.getTable(segment);
+        const upsertOperation = table.entriesToUpsertOperations(entries, segment);
+        if (entries[GRAPHQL_QUERY_ROOT_KEY]) {
+            this.trackGraphQLQueryRootSize(upsertOperation);
+        }
+        return this.batchOperationAsPromise([upsertOperation]);
+    }
+    setMetadata(entries, segment) {
+        if (keys$1(entries).length === 0) {
+            return Promise.resolve();
+        }
+        const table = this.getTable(segment);
+        let operation = table.metadataToUpdateOperations(entries, segment);
+        return this.batchOperationAsPromise([operation]);
+    }
+    batchOperations(operations) {
+        const sqliteOperations = operations.reduce((acc, cur) => {
+            if (cur.type === 'setEntries') {
+                if (keys$1(cur.entries).length > 0) {
+                    const table = this.getTable(cur.segment);
+                    const upsertOperation = table.entriesToUpsertOperations(cur.entries, cur.segment);
+                    if (cur.entries[GRAPHQL_QUERY_ROOT_KEY]) {
+                        this.trackGraphQLQueryRootSize(upsertOperation);
+                    }
+                    acc.push(upsertOperation);
+                }
+            }
+            else if (cur.type === 'setMetadata') {
+                if (keys$1(cur.entries).length > 0) {
+                    const table = this.getTable(cur.segment);
+                    acc.push(table.metadataToUpdateOperations(cur.entries, cur.segment));
+                }
+            }
+            else {
+                if (cur.ids.length > 0) {
+                    acc.push(this.idsToDeleteOperation(cur.ids, cur.segment));
+                }
+            }
+            return acc;
+        }, []);
+        return sqliteOperations.length === 0
+            ? Promise.resolve()
+            : this.batchOperationAsPromise(sqliteOperations);
+    }
+    evictEntries(entryIds, segment) {
+        return entryIds.length === 0
+            ? Promise.resolve()
+            : this.batchOperationAsPromise([this.idsToDeleteOperation(entryIds, segment)]);
+    }
+    registerOnChangedListener(listener) {
+        let unsubscribeId = undefined;
+        this.plugin
+            .registerOnChangedListener(async (changes) => {
+            const durableChanges = changes.map((c) => {
+                let type = c.type === 'upsert' ? 'setEntries' : 'evictEntries';
+                // if our context contains a type then set that as our main level type
+                // allows us in the future of updates to specify the segment change happening
+                // example being update call on metadata only or updating data
+                if ((c.type === 'update' || c.type === 'upsert') &&
+                    c.context.type !== undefined) {
+                    type = c.context.type;
+                }
+                return {
+                    type,
+                    ids: c.keys,
+                    isExternalChange: false,
+                    segment: c.context.segment,
+                };
+            });
+            await listener(durableChanges);
+        })
+            .then((unsub) => {
+            unsubscribeId = unsub;
+        });
+        return () => {
+            if (unsubscribeId) {
+                return this.plugin.unsubscribeOnChangedListener(unsubscribeId);
+            }
+            return Promise.resolve();
+        };
+    }
+    getTable(segment) {
+        return this.dataTableMap[segment] ?? this.internalDataTable;
+    }
+    idsToDeleteOperation(entryIds, segment) {
+        const table = this.getTable(segment);
+        return {
+            type: 'delete',
+            table: table.tableName,
+            keyColumn: 'key',
+            context: {
+                segment,
+            },
+            ids: entryIds,
+        };
+    }
+    batchOperationAsPromise(sqliteOperations) {
+        tasker.add();
+        return new Promise((resolve, reject) => {
+            this.plugin.batchOperations(sqliteOperations, (error) => {
+                if (error && error !== null) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+        }).finally(() => tasker.done());
+    }
+    trackGraphQLQueryRootSize(upsertOperation) {
+        try {
+            if (upsertOperation.type !== 'upsert') {
+                return;
+            }
+            const row = upsertOperation.rows.find((r) => r[0] === GRAPHQL_QUERY_ROOT_KEY);
+            if (!(row && row[1] && typeof row[1] === 'string')) {
+                return;
+            }
+            instrumentation.trackValue(GRAPHQL_QUERY_ROOT_METRIC_NAME, row[1].length);
+        }
+        catch { }
+    }
+}
+
+let reportObservers = [];
+function instrumentAdapter(adapter, metadata) {
+    let instrumentedMobileAdapter = adapter;
+    return instrumentAdapter$1(instrumentedMobileAdapter, metadata, {
+        trackL1Hits: true,
+        trackL2Hits: true,
+        trackCacheMisses: true,
+        reportObserver: (report) => {
+            for (const observer of reportObservers) {
+                observer(report);
+            }
+        },
+    });
+}
+function setupMobileInstrumentation(luvio, store) {
+    setupInstrumentation(luvio, store);
+    instrument({ instrumentAdapter });
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+const { keys, values, create, assign, freeze, entries } = Object;
+
+function buildRecordFieldStoreKey(recordKey, fieldName) {
+    return `${recordKey}${RECORD_FIELDS_KEY_JUNCTION}${fieldName}`;
+}
+function isStoreKeyRecordId(key) {
+    return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1;
+}
+function createLink(key) {
+    return { __ref: key };
+}
+function isStoreRecordError(storeRecord) {
+    return storeRecord.__type === 'error';
+}
+function isEntryDurableRecordRepresentation(entry, key) {
+    // Either a DurableRecordRepresentation or StoreRecordError can live at a record key
+    return ((isStoreKeyRecordId(key) || isStoreKeyRecordViewEntity(key)) &&
+        entry.data.__type === undefined);
+}
+/**
+ * Records are stored in the durable store with scalar fields denormalized. This function takes that denoramlized
+ * durable store record representation and normalizes it back out into the format the the luvio store expects it
+ * @param key Record store key
+ * @param entry Durable entry containing a denormalized record representation
+ * @returns a set of entries containing the normalized record and its normalized fields
+ */
+function normalizeRecordFields(key, entry) {
+    const { data: record } = entry;
+    const { fields, links } = record;
+    const missingFieldLinks = links === undefined ? [] : keys(links);
+    const fieldNames = keys(fields);
+    const normalizedFields = {};
+    const returnEntries = {};
+    // restore fields
+    for (let i = 0, len = fieldNames.length; i < len; i++) {
+        const fieldName = fieldNames[i];
+        const field = fields[fieldName];
+        if (field.__state !== undefined && field.__state.isMissing === true) {
+            normalizedFields[fieldName] = { isMissing: true, __ref: undefined };
+            continue;
+        }
+        const fieldKey = buildRecordFieldStoreKey(key, fieldName);
+        returnEntries[fieldKey] = { data: field };
+        normalizedFields[fieldName] = createLink(fieldKey);
+    }
+    // restore missing fields
+    for (let i = 0, len = missingFieldLinks.length; i < len; i++) {
+        const fieldName = missingFieldLinks[i];
+        const link = links[fieldName];
+        if (link.isMissing === true) {
+            normalizedFields[fieldName] = { ...link, __ref: undefined };
+        }
+    }
+    returnEntries[key] = {
+        data: assign(record, { fields: normalizedFields }),
+        metadata: entry.metadata,
+    };
+    return returnEntries;
+}
+/**
+ * Transforms a record for storage in the durable store. The transformation involves denormalizing
+ * scalar fields and persisting link metadata to transform back into a normalized representation
+ *
+ * If the record contains pending fields this will return undefined as pending records do not get persisted
+ * to the durable store. There should be a refresh operation outbound that will bring in the updated record.
+ *
+ * @param normalizedRecord Record containing normalized field links
+ * @param recordStore a store containing referenced record fields
+ */
+function buildDurableRecordRepresentation(normalizedRecord, records, pendingEntries, store) {
+    const fields = normalizedRecord.fields;
+    const filteredFields = {};
+    const fieldNames = keys(fields);
+    for (let i = 0, len = fieldNames.length; i < len; i++) {
+        const fieldName = fieldNames[i];
+        const field = fields[fieldName];
+        // pending fields get filtered out of the durable store
+        const { pending } = field;
+        if (pending === true) {
+            // do not write records with pending fields to the durable store
+            // there should be a refresh operation outbound that will bring in the updated record
+            return undefined;
+        }
+        const { __ref } = field;
+        if (__ref !== undefined) {
+            let ref = records[__ref];
+            if (pendingEntries !== undefined) {
+                // If the ref was part of the pending write that takes precedence
+                const pendingEntry = pendingEntries[__ref];
+                if (pendingEntry !== undefined) {
+                    ref = pendingEntry.data;
+                }
+            }
+            // if field reference exists then add it to our filteredFields
+            if (ref !== undefined) {
+                filteredFields[fieldName] = ref;
+            }
+            else {
+                // if we have a store to read, try to find the field there too
+                // The durable ingest staging store may pass through to L1, and
+                // not all fields are necessarily published every time, so it is
+                // important to check L1 and not just the fields being published,
+                // otherwise we risk truncating the fields on the record.
+                if (store) {
+                    ref = store.readEntry(__ref);
+                    if (ref !== undefined) {
+                        filteredFields[fieldName] = ref;
+                    }
+                }
+            }
+        }
+        // we want to preserve fields that are missing nodes
+        if (field.isMissing === true) {
+            filteredFields[fieldName] = {
+                value: undefined,
+                displayValue: undefined,
+                __state: { isMissing: true },
+            };
+        }
+    }
+    return {
+        ...normalizedRecord,
+        fields: filteredFields,
+    };
+}
+function getDenormalizedKey(originalKey, recordId, luvio) {
+    // this will likely need to be handled when moving to structured keys
+    // note record view entities dont have an associated keybuilder. They get ingested as records to a different key format
+    // see the override for how they are handled packages/lds-adapters-uiapi/src/raml-artifacts/types/RecordRepresentation/keyBuilderFromType.ts
+    if (originalKey.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX)) {
+        return RECORD_VIEW_ENTITY_ID_PREFIX + recordId;
+    }
+    return keyBuilderRecord(luvio, { recordId });
+}
+function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecords, getStoreMetadata, getStore, sqlStore) {
+    const getEntries = function (entries, segment) {
+        // this HOF only inspects records in the default segment
+        if (segment !== DefaultDurableSegment) {
+            return durableStore.getEntries(entries, segment);
+        }
+        const { length: entriesLength } = entries;
+        if (entriesLength === 0) {
+            return Promise.resolve({});
+        }
+        // filter out record field keys
+        const filteredEntryIds = [];
+        // map of records to avoid requesting duplicate record keys when requesting both records and fields
+        const recordEntries = {};
+        const recordViewEntries = {};
+        for (let i = 0, len = entriesLength; i < len; i++) {
+            const id = entries[i];
+            const recordId = extractRecordIdFromStoreKey(id);
+            if (recordId !== undefined) {
+                if (id.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX)) {
+                    if (recordViewEntries[recordId] === undefined) {
+                        const key = getDenormalizedKey(id, recordId, luvio);
+                        recordViewEntries[recordId] = true;
+                        filteredEntryIds.push(key);
+                    }
+                }
+                else {
+                    if (recordEntries[recordId] === undefined) {
+                        const key = getDenormalizedKey(id, recordId, luvio);
+                        recordEntries[recordId] = true;
+                        filteredEntryIds.push(key);
+                    }
+                }
+            }
+            else {
+                filteredEntryIds.push(id);
+            }
+        }
+        // call base getEntries
+        return durableStore.getEntries(filteredEntryIds, segment).then((durableEntries) => {
+            if (durableEntries === undefined) {
+                return undefined;
+            }
+            const returnEntries = create(null);
+            const keys$1 = keys(durableEntries);
+            for (let i = 0, len = keys$1.length; i < len; i++) {
+                const key = keys$1[i];
+                const value = durableEntries[key];
+                if (value === undefined) {
+                    continue;
+                }
+                if (isEntryDurableRecordRepresentation(value, key)) {
+                    assign(returnEntries, normalizeRecordFields(key, value));
+                }
+                else {
+                    returnEntries[key] = value;
+                }
+            }
+            return returnEntries;
+        });
+    };
+    const denormalizeEntries = function (entries) {
+        let hasEntries = false;
+        let hasMetadata = false;
+        const putEntries = create(null);
+        const putMetadata = create(null);
+        const keys$1 = keys(entries);
+        const putRecords = {};
+        const putRecordViews = {};
+        const storeRecords = getStoreRecords !== undefined ? getStoreRecords() : {};
+        const storeMetadata = getStoreMetadata !== undefined ? getStoreMetadata() : {};
+        const store = getStore();
+        for (let i = 0, len = keys$1.length; i < len; i++) {
+            const key = keys$1[i];
+            let value = entries[key];
+            const recordId = extractRecordIdFromStoreKey(key);
+            // do not put normalized field values
+            if (recordId !== undefined) {
+                const isRecordView = key.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX);
+                if (isRecordView) {
+                    if (putRecordViews[recordId] === true) {
+                        continue;
+                    }
+                }
+                else {
+                    if (putRecords[recordId] === true) {
+                        continue;
+                    }
+                }
+                const recordKey = getDenormalizedKey(key, recordId, luvio);
+                const recordEntries = entries;
+                const entry = recordEntries[recordKey];
+                let record = entry && entry.data;
+                if (record === undefined) {
+                    record = storeRecords[recordKey];
+                    if (record === undefined) {
+                        // fields are being published without a record for them existing,
+                        // fields cannot exist standalone in the durable store
+                        continue;
+                    }
+                }
+                if (isRecordView) {
+                    putRecordViews[recordId] = true;
+                }
+                else {
+                    putRecords[recordId] = true;
+                }
+                if (isStoreRecordError(record)) {
+                    hasEntries = true;
+                    putEntries[recordKey] = value;
+                    continue;
+                }
+                let metadata = entry && entry.metadata;
+                if (metadata === undefined) {
+                    metadata = {
+                        ...storeMetadata[recordKey],
+                        metadataVersion: DURABLE_METADATA_VERSION,
+                    };
+                }
+                const denormalizedRecord = buildDurableRecordRepresentation(record, storeRecords, recordEntries, store);
+                if (denormalizedRecord !== undefined) {
+                    hasEntries = true;
+                    putEntries[recordKey] = {
+                        data: denormalizedRecord,
+                        metadata,
+                    };
+                    // if undefined then it is pending
+                    // we should still update metadata on pending records
+                }
+                else {
+                    hasMetadata = true;
+                    metadata.expirationTimestamp = metadata.ingestionTimestamp;
+                    putMetadata[recordKey] = {
+                        metadata,
+                    };
+                }
+            }
+            else {
+                hasEntries = true;
+                putEntries[key] = value;
+            }
+        }
+        return { putEntries, putMetadata, hasEntries, hasMetadata };
+    };
+    const setEntries = function (entries, segment) {
+        if (segment !== DefaultDurableSegment) {
+            return durableStore.setEntries(entries, segment);
+        }
+        const { putEntries, putMetadata, hasEntries, hasMetadata } = denormalizeEntries(entries);
+        const promises = [
+            hasEntries ? durableStore.setEntries(putEntries, segment) : undefined,
+        ];
+        if (sqlStore !== undefined) {
+            promises.push(hasMetadata && sqlStore !== undefined
+                ? durableStore.setMetadata(putMetadata, segment)
+                : undefined);
+        }
+        return Promise.all(promises).then(() => { });
+    };
+    const batchOperations = function (operations) {
+        const operationsWithDenormedRecords = [];
+        for (let i = 0, len = operations.length; i < len; i++) {
+            const operation = operations[i];
+            if (operation.type === 'setMetadata') {
+                // if setMetadata also contains entry data then it needs to be denormalized.
+                const keys$1 = keys(operation.entries);
+                if (keys$1.length > 0) {
+                    const firstKey = keys$1[0];
+                    // casted to any to check if data exists
+                    const firstEntry = operation.entries[firstKey];
+                    // it is not possible for setMetadata to contain entries with both data and no data in the same operation.
+                    // this is determined by the plugin supporting update batch calls before it gets to this HOF.
+                    // so we only need to check one entry to confirm this for performance
+                    if (firstEntry.data !== undefined) {
+                        const { putEntries, putMetadata, hasMetadata } = denormalizeEntries(operation.entries);
+                        operationsWithDenormedRecords.push({
+                            ...operation,
+                            entries: putEntries,
+                        });
+                        if (hasMetadata && sqlStore !== undefined) {
+                            operationsWithDenormedRecords.push({
+                                ...operation,
+                                entries: putMetadata,
+                                type: 'setMetadata',
+                            });
+                        }
+                    }
+                    else {
+                        operationsWithDenormedRecords.push(operation);
+                    }
+                }
+                continue;
+            }
+            if (operation.segment !== DefaultDurableSegment || operation.type === 'evictEntries') {
+                operationsWithDenormedRecords.push(operation);
+                continue;
+            }
+            const { putEntries, putMetadata, hasMetadata } = denormalizeEntries(operation.entries);
+            operationsWithDenormedRecords.push({
+                ...operation,
+                entries: putEntries,
+            });
+            if (hasMetadata && sqlStore !== undefined) {
+                operationsWithDenormedRecords.push({
+                    ...operation,
+                    entries: putMetadata,
+                    type: 'setMetadata',
+                });
+            }
+        }
+        return durableStore.batchOperations(operationsWithDenormedRecords);
+    };
+    return create(durableStore, {
+        getEntries: { value: getEntries, writable: true },
+        setEntries: { value: setEntries, writable: true },
+        batchOperations: { value: batchOperations, writable: true },
+    });
+}
+
+let luvio;
+let getIngestRecords;
+let getIngestMetadata;
+let getIngestStore;
+// LdsSqliteStore plugin helper
+function getNimbusDurableStore() {
+    const resolvedPlugin = __nimbus.plugins.LdsSqliteStore;
+    return new NimbusSqliteStore(resolvedPlugin);
+}
+/**
+ * Use record denormalizing store to persist field values and references
+ */
+function createRecordDenormingStore(luvio, durableStore) {
+    const recordDenormingStore = makeRecordDenormalizingDurableStore(luvio, durableStore, () => getIngestRecords(), () => getIngestMetadata(), () => getIngestStore());
+    return recordDenormingStore;
+}
+function getRuntime() {
+    // Create stores
+    const store = new InMemoryStore();
+    const durableStore = getNimbusDurableStore();
+    const recordDenormingStore = createRecordDenormingStore(luvio, durableStore);
+    // Create environment with store + aura network adapter
+    const baseEnv = new Environment(store, networkAdapter);
+    const durableEnv = makeDurable(baseEnv, {
+        durableStore: recordDenormingStore,
+    });
+    // Set ingest records/metadata properties from durable environment
+    getIngestRecords = durableEnv.getIngestStagingStoreRecords;
+    getIngestMetadata = durableEnv.getIngestStagingStoreMetadata;
+    getIngestStore = durableEnv.getIngestStagingStore;
+    // Return new luvio instance
+    luvio = new Luvio(durableEnv, {
+        instrument: instrumentLuvio,
+    });
+    // Currently instruments store runtime perf
+    setupMobileInstrumentation(luvio, store);
+    // Initialize OneStore
+    initializeOneStore(durableStore['plugin']);
+    return luvio;
+}
+
+// so eslint doesn't complain about nimbus
+/* global __nimbus */
+function ldsRuntimeBridge() {
+    if (typeof __nimbus !== 'undefined' &&
+        __nimbus.plugins !== undefined &&
+        __nimbus.plugins.LdsSqliteStore !== undefined) {
+        if (__nimbus.plugins.GaterPlugin !== undefined &&
+            __nimbus.plugins.GaterPlugin.isUnifiedLdsCacheEnabled !== undefined) {
+            // The existence of isUnifiedLdsCacheEnabled must be synchronous, only if the feature flag is set.
+            const { luvio } = getRuntime$1();
+            setDefaultLuvio({ luvio });
+            return { name: 'ldsRuntimeMobile' };
+        }
+        else {
+            // Since LdsSqliteStore plugin is present, use Luvio with persistent store
+            const luvio = getRuntime();
+            setDefaultLuvio({ luvio });
+            return { name: 'ldsRuntimeBridge' };
+        }
+    }
+    else {
+        // Plugin not available fallback to lds-runtime-aura/ldsEngineCreator
+        return ldsEngineCreator();
+    }
+}
+
+export { ldsRuntimeBridge as default };
+// version: 0.1.0-dev1-54c03dd38c