@salesforce/lds-worker-api 1.233.0 → 1.235.0

package/dist/standalone/es/lds-worker-api.js

@@ -20,7 +20,7 @@ var SnapshotState$3;
     SnapshotState["Stale"] = "Stale";
 })(SnapshotState$3 || (SnapshotState$3 = {}));
 
-const { create: create$b, entries: entries$5, freeze: freeze$5, keys: keys$c, values: values$4 } = Object;
+const { create: create$b, entries: entries$5, freeze: freeze$5, keys: keys$c, values: values$5 } = Object;
 const { hasOwnProperty: hasOwnProperty$3 } = Object.prototype;
 const { isArray: isArray$9 } = Array;
 const { push: push$5, indexOf, slice: slice$2 } = Array.prototype;
@@ -840,14 +840,16 @@ class StringKeyInMemoryStore {
         delete this.records[canonicalKey];
     }
     publishMetadata(key, storeMetadata) {
+        this.putMetadata(key, storeMetadata, true);
+        const canonicalKey = this.getCanonicalRecordId(key);
+        this.markRefreshed(canonicalKey);
+    }
+    putMetadata(key, storeMetadata, adjustTTLOverride) {
         const { namespace, representationName, ingestionTimestamp } = storeMetadata;
         const ttlOverrideKey = getTTLOverrideKey(namespace, representationName);
         const ttlOverride = getTTLOverride$1(ttlOverrideKey, this.ttlOverrides, this.defaultTTLOverride);
         const canonicalKey = this.getCanonicalRecordId(key);
-        this.markRefreshed(canonicalKey);
-        if (ttlOverride !== undefined) {
-            // It should check if the namespace + representationName exists in the ttlOverride map.
-            // If a ttlOverride does exist, calculate a new ExpirationTimestamp with the override.
+        if (ttlOverride !== undefined && adjustTTLOverride === true) {
             const newExpiration = ingestionTimestamp + ttlOverride;
             // Create a new StoreMetadata object and publish the new object to storeMetadata.
             const metaDataOverride = {
@@ -1489,12 +1491,20 @@ class InMemoryStore {
             this.fallbackStringKeyInMemoryStore.publishMetadata(key, storeMetadata);
             return;
         }
+        this.putMetadata(key, storeMetadata, true);
+        const canonicalKey = this.getCanonicalRecordId(key);
+        this.markRefreshed(canonicalKey);
+    }
+    putMetadata(key, storeMetadata, adjustTTLOverride) {
+        if (typeof key === 'string') {
+            this.fallbackStringKeyInMemoryStore.putMetadata(key, storeMetadata, adjustTTLOverride);
+            return;
+        }
         const { namespace, representationName, ingestionTimestamp } = storeMetadata;
         const ttlOverrideKey = this.buildStructuredKey(namespace, representationName, {});
         const ttlOverride = getTTLOverride(ttlOverrideKey, this.ttlOverridesMap, this.defaultTTLOverride);
         const canonicalKey = this.getCanonicalRecordId(key);
-        this.markRefreshed(canonicalKey);
-        if (ttlOverride !== undefined) {
+        if (ttlOverride !== undefined && adjustTTLOverride) {
             // It should check if the namespace + representationName exists in the ttlOverride map.
             // If a ttlOverride does exist, calculate a new ExpirationTimestamp with the override.
             const newExpiration = ingestionTimestamp + ttlOverride;
@@ -3278,6 +3288,9 @@ class Environment {
     publishStoreMetadata(key, storeMetadata) {
         this.store.publishMetadata(key, storeMetadata);
     }
+    putStoreMetadata(key, storeMetadata, adjustTTLOverride) {
+        this.store.putMetadata(key, storeMetadata, adjustTTLOverride);
+    }
     storeSetTTLOverride(namespace, representationName, ttl) {
         this.store.setTTLOverride(namespace, representationName, ttl);
         this.recomputeTTLOverrideExpirations(namespace, representationName);
@@ -3841,7 +3854,7 @@ function createResourceParamsImpl(config, configMetadata) {
     }
     return resourceParams;
 }
-// engine version: 0.145.3-1693bfb7
+// engine version: 0.147.1-bc3a8b47
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -3968,7 +3981,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.233.0-8ab7ef233
+// version: 1.235.0-3790decf0
 
 // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
 function instrumentAdapter$1(createFunction, _metadata) {
@@ -15429,7 +15442,7 @@ function gql(literals, ...subs) {
     }
     return superResult;
 }
-// version: 1.233.0-8ab7ef233
+// version: 1.235.0-3790decf0
 
 function unwrap(data) {
     // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -15530,14 +15543,15 @@ function refreshData(data, dataToTuple, luvio) {
         return undefined;
     });
 }
-const { isArray: isArray$8 } = Array;
-const { stringify: stringify$9 } = JSON;
 
 function isPromise$1(value) {
     // check for Thenable due to test frameworks using custom Promise impls
     return value.then !== undefined;
 }
 
+const { isArray: isArray$8 } = Array;
+const { stringify: stringify$9 } = JSON;
+
 /**
  * (Re)throws an error after adding a prefix to the message.
  *
@@ -16352,7 +16366,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     const { apiFamily, name } = metadata;
     return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
 }
-// version: 1.233.0-8ab7ef233
+// version: 1.235.0-3790decf0
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -16451,7 +16465,7 @@ var TypeCheckShapes;
     TypeCheckShapes[TypeCheckShapes["Integer"] = 3] = "Integer";
     TypeCheckShapes[TypeCheckShapes["Unsupported"] = 4] = "Unsupported";
 })(TypeCheckShapes || (TypeCheckShapes = {}));
-// engine version: 0.145.3-1693bfb7
+// engine version: 0.147.1-bc3a8b47
 
 const { keys: ObjectKeys$3, create: ObjectCreate$3 } = Object;
 
@@ -41305,7 +41319,7 @@ withDefaultLuvio((luvio) => {
     throttle(60, 60000, createLDSAdapter(luvio, 'notifyListInfoUpdateAvailable', notifyUpdateAvailableFactory$1));
     throttle(60, 60000, createLDSAdapter(luvio, 'notifyQuickActionDefaultsUpdateAvailable', notifyUpdateAvailableFactory));
 });
-// version: 1.233.0-e0ba7cc7b
+// version: 1.235.0-c252f93dc
 
 var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -41425,6 +41439,15 @@ var ldsPrimingGraphqlBatch = {
     },
 };
 
+var ldsMetadataRefreshEnabled = {
+    isOpen: function (e) {
+        return e.fallback;
+    },
+    hasError: function () {
+        return !0;
+    },
+};
+
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -41999,7 +42022,7 @@ function publishDurableStoreEntries(durableRecords, put, publishMetadata) {
  * 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 = { l2Trips: [] }) {
+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.
@@ -42009,10 +42032,21 @@ function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, dura
             metrics: reviveMetrics,
         });
     }
-    // in case L1 store changes/deallocs a record while we are doing the async read
-    // we attempt to read all keys from L2 - so combine recordId with any seenRecords
-    const keysToReviveSet = new StoreKeySet().add(recordId);
-    keysToReviveSet.merge(seenRecords);
+    const 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)));
@@ -42062,7 +42096,7 @@ function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, dura
             for (let i = 0, len = newKeys.length; i < len; i++) {
                 const newSnapshotSeenKey = newKeys[i];
                 if (!alreadyRequestedOrRevivedSet.has(newSnapshotSeenKey)) {
-                    return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics);
+                    return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, revivingStore, reviveMetrics);
                 }
             }
         }
@@ -42151,8 +42185,9 @@ class DurableTTLStore {
     }
 }
 
-function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler, redirects, additionalDurableStoreOperations = []) {
+function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler, redirects, additionalDurableStoreOperations = [], enableDurableMetadataRefresh = false) {
     const durableRecords = create$6(null);
+    const refreshedDurableRecords = create$6(null);
     const evictedRecords = create$6(null);
     const { records, metadata: storeMetadata, visitedIds, refreshedIds, } = store.fallbackStringKeyInMemoryStore;
     // TODO: W-8909393 Once metadata is stored in its own segment we need to
@@ -42162,32 +42197,36 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
     for (let i = 0, len = keys$1.length; i < len; i += 1) {
         const key = keys$1[i];
         const record = records[key];
+        const wasVisited = visitedIds[key] !== undefined;
         // this record has been evicted, evict from DS
-        if (record === undefined) {
+        if (wasVisited && record === undefined) {
             evictedRecords[key] = true;
             continue;
         }
         const metadata = storeMetadata[key];
-        durableRecords[key] = {
-            data: record,
-        };
-        if (metadata !== undefined) {
-            durableRecords[key].metadata = {
-                ...metadata,
-                metadataVersion: DURABLE_METADATA_VERSION,
-            };
-        }
+        const entries = wasVisited === true || enableDurableMetadataRefresh === false
+            ? durableRecords
+            : refreshedDurableRecords;
+        setRecordTo(entries, key, record, metadata);
     }
     const durableStoreOperations = additionalDurableStoreOperations;
-    // publishes
     const recordKeys = keys$7(durableRecords);
     if (recordKeys.length > 0) {
+        // publishes with data
         durableStoreOperations.push({
             type: 'setEntries',
             entries: durableRecords,
             segment: DefaultDurableSegment,
         });
     }
+    if (keys$7(refreshedDurableRecords).length > 0) {
+        // publishes with only metadata updates
+        durableStoreOperations.push({
+            type: 'setMetadata',
+            entries: refreshedDurableRecords,
+            segment: DefaultDurableSegment,
+        });
+    }
     // redirects
     redirects.forEach((value, key) => {
         durableStoreOperations.push({
@@ -42214,6 +42253,17 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
     }
     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) {
@@ -42258,6 +42308,50 @@ async function reviveRedirects(durableStore, env) {
     }
 }
 
+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$6(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) {
@@ -42313,14 +42407,16 @@ function isUnfulfilledSnapshot$1(cachedSnapshotResult) {
  * @param durableStore A DurableStore implementation
  * @param instrumentation An instrumentation function implementation
  */
-function makeDurable(environment, { durableStore, instrumentation }) {
-    let ingestStagingStore = null;
+function makeDurable(environment, { durableStore, instrumentation, useRevivingStore, enableDurableMetadataRefresh = false, }) {
+    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$6(null);
@@ -42346,6 +42442,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         const defaultSegmentKeys = [];
         const adapterContextSegmentKeys = [];
         const redirectSegmentKeys = [];
+        const metadataRefreshSegmentKeys = [];
         const messagingSegmentKeys = [];
         let shouldBroadcast = false;
         for (let i = 0, len = changes.length; i < len; i++) {
@@ -42353,7 +42450,12 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             // we only care about changes to the data which is stored in the default
             // segment or the adapter context
             if (change.segment === DefaultDurableSegment) {
-                defaultSegmentKeys.push(...change.ids);
+                if (change.type === 'setMetadata') {
+                    metadataRefreshSegmentKeys.push(...change.ids);
+                }
+                else {
+                    defaultSegmentKeys.push(...change.ids);
+                }
             }
             else if (change.segment === AdapterContextSegment) {
                 adapterContextSegmentKeys.push(...change.ids);
@@ -42417,9 +42519,26 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                 // 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 entries = await durableStore.getMetadata(metadataRefreshSegmentKeys, DefaultDurableSegment);
+            if (entries !== undefined) {
+                const entryKeys = keys$7(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);
         }
@@ -42445,10 +42564,10 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const storePublish = function (key, data) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        ingestStagingStore.publish(key, data);
+        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
@@ -42457,26 +42576,26 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const publishStoreMetadata = function (recordId, storeMetadata) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        ingestStagingStore.publishMetadata(recordId, storeMetadata);
+        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 (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
+        environment.storeIngest(key, ingest, response, luvio, stagingStore);
     };
     const storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        environment.storeIngestError(key, errorSnapshot, storeMetadataParams, ingestStagingStore);
+        environment.storeIngestError(key, errorSnapshot, storeMetadataParams, stagingStore);
     };
     const storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
         validateNotDisposed();
@@ -42487,19 +42606,19 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const publishChangesToDurableStore = function (additionalDurableStoreOperations) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
+        if (stagingStore === null) {
             return Promise.resolve();
         }
-        const promise = flushInMemoryStoreValuesToDurableStore(ingestStagingStore, durableStore, durableStoreErrorHandler, new Map(pendingStoreRedirects), additionalDurableStoreOperations);
+        const promise = flushInMemoryStoreValuesToDurableStore(stagingStore, durableStore, durableStoreErrorHandler, new Map(pendingStoreRedirects), additionalDurableStoreOperations, enableDurableMetadataRefresh);
         pendingStoreRedirects.clear();
-        ingestStagingStore = null;
+        stagingStore = null;
         return promise;
     };
     const storeLookup = function (sel, createSnapshot, refresh, ttlStrategy) {
         validateNotDisposed();
-        // if this lookup is right after an ingest there will be a staging store
-        if (ingestStagingStore !== null) {
-            const reader = new Reader(ingestStagingStore, sel.variables, refresh, undefined, ttlStrategy);
+        // 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
@@ -42508,24 +42627,24 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const storeEvict = function (key) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        ingestStagingStore.evict(key);
+        stagingStore.evict(key);
     };
     const getNode = function (key) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        return environment.getNode(key, ingestStagingStore);
+        return environment.getNode(key, stagingStore);
     };
     const wrapNormalizedGraphNode = function (normalized) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
+        return environment.wrapNormalizedGraphNode(normalized, stagingStore);
     };
     const rebuildSnapshot = function (snapshot, onRebuild) {
         validateNotDisposed();
@@ -42537,7 +42656,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                 return;
             }
             // Do an L2 revive and emit to subscriber using the callback.
-            reviveSnapshot(environment, durableStore, rebuilt, durableStoreErrorHandler, () => {
+            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;
@@ -42578,10 +42697,10 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         // 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);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        ingestStagingStore.redirect(existingKey, canonicalKey);
+        stagingStore.redirect(existingKey, canonicalKey);
     };
     const storeSetTTLOverride = function (namespace, representationName, ttl) {
         validateNotDisposed();
@@ -42622,7 +42741,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             if (isUnfulfilledSnapshot$1(snapshot)) {
                 const start = Date.now();
                 emitDurableEnvironmentAdapterEvent({ type: 'l2-revive-start' }, adapterRequestContext.eventObservers);
-                const revivedSnapshot = reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, () => injectedStoreLookup(snapshot.select, snapshot.refresh)).then((result) => {
+                const revivedSnapshot = reviveSnapshotWrapper(snapshot, () => injectedStoreLookup(snapshot.select, snapshot.refresh)).then((result) => {
                     emitDurableEnvironmentAdapterEvent({
                         type: 'l2-revive-end',
                         snapshot: result.snapshot,
@@ -42647,15 +42766,15 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const getIngestStagingStoreRecords = function () {
         validateNotDisposed();
-        if (ingestStagingStore !== null) {
-            return ingestStagingStore.fallbackStringKeyInMemoryStore.records;
+        if (stagingStore !== null) {
+            return stagingStore.fallbackStringKeyInMemoryStore.records;
         }
         return {};
     };
     const getIngestStagingStoreMetadata = function () {
         validateNotDisposed();
-        if (ingestStagingStore !== null) {
-            return ingestStagingStore.fallbackStringKeyInMemoryStore.metadata;
+        if (stagingStore !== null) {
+            return stagingStore.fallbackStringKeyInMemoryStore.metadata;
         }
         return {};
     };
@@ -42694,22 +42813,20 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                 }
                 await Promise.all(pendingPromises);
                 const entries = await durableStore.getEntries(keysToReviveAsArray, DefaultDurableSegment);
-                ingestStagingStore = buildIngestStagingStore(environment);
+                stagingStore = buildIngestStagingStore(environment);
                 publishDurableStoreEntries(entries, (key, record) => {
                     if (typeof key === 'string') {
-                        ingestStagingStore.fallbackStringKeyInMemoryStore.records[key] =
-                            record;
+                        stagingStore.fallbackStringKeyInMemoryStore.records[key] = record;
                     }
                     else {
-                        ingestStagingStore.recordsMap.set(key, record);
+                        stagingStore.recordsMap.set(key, record);
                     }
                 }, (key, metadata) => {
                     if (typeof key === 'string') {
-                        ingestStagingStore.fallbackStringKeyInMemoryStore.metadata[key] =
-                            metadata;
+                        stagingStore.fallbackStringKeyInMemoryStore.metadata[key] = metadata;
                     }
                     else {
-                        ingestStagingStore.metadataMap.set(key, metadata);
+                        stagingStore.metadataMap.set(key, metadata);
                     }
                 });
                 snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
@@ -42738,7 +42855,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             // 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);
+            stagingStore = buildIngestStagingStore(environment);
             snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
         }
         if (snapshotFromMemoryIngest === undefined) {
@@ -42749,12 +42866,12 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         }
         // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
         const { select, refresh } = snapshotFromMemoryIngest;
-        const result = await reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(select, environment.createSnapshot, refresh));
+        const result = await reviveSnapshotWrapper(snapshotFromMemoryIngest, () => environment.storeLookup(select, environment.createSnapshot, refresh));
         return result.snapshot;
     };
     const handleErrorResponse = async function (ingestAndBroadcastFunc) {
         validateNotDisposed();
-        ingestStagingStore = buildIngestStagingStore(environment);
+        stagingStore = buildIngestStagingStore(environment);
         return ingestAndBroadcastFunc();
     };
     const getNotifyChangeStoreEntries = function (keys) {
@@ -42805,6 +42922,27 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         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(() => {
+        });
+    };
     // set the default cache policy of the base environment
     environment.setDefaultCachePolicy({
         type: 'stale-while-revalidate',
@@ -42839,6 +42977,72 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     });
 }
 
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+const API_NAMESPACE$1 = 'UiApi';
+const RECORD_REPRESENTATION_NAME$2 = 'RecordRepresentation';
+const RECORD_VIEW_ENTITY_REPRESENTATION_NAME$1 = 'RecordViewEntityRepresentation';
+const RECORD_ID_PREFIX$1 = `${API_NAMESPACE$1}::${RECORD_REPRESENTATION_NAME$2}:`;
+const RECORD_VIEW_ENTITY_ID_PREFIX$1 = `${API_NAMESPACE$1}::${RECORD_VIEW_ENTITY_REPRESENTATION_NAME$1}:Name:`;
+const RECORD_FIELDS_KEY_JUNCTION$1 = '__fields__';
+function isStoreKeyRecordId(key) {
+    return key.indexOf(RECORD_ID_PREFIX$1) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION$1) === -1;
+}
+function isStoreKeyRecordViewEntity$1(key) {
+    return (key.indexOf(RECORD_VIEW_ENTITY_ID_PREFIX$1) > -1 &&
+        key.indexOf(RECORD_FIELDS_KEY_JUNCTION$1) === -1);
+}
+function isStoreKeyRecordField(key) {
+    return key.indexOf(RECORD_ID_PREFIX$1) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION$1) > -1;
+}
+function extractRecordIdFromStoreKey$1(key) {
+    if (key === undefined ||
+        (key.indexOf(RECORD_ID_PREFIX$1) === -1 && key.indexOf(RECORD_VIEW_ENTITY_ID_PREFIX$1) === -1)) {
+        return undefined;
+    }
+    const parts = key.split(':');
+    return parts[parts.length - 1].split('_')[0];
+}
+function buildRecordFieldStoreKey(recordKey, fieldName) {
+    return `${recordKey}${RECORD_FIELDS_KEY_JUNCTION$1}${fieldName}`;
+}
+function objectsDeepEqual(lhs, rhs) {
+    if (lhs === rhs)
+        return true;
+    if (typeof lhs !== 'object' || typeof rhs !== 'object' || lhs === null || rhs === null)
+        return false;
+    const lhsKeys = Object.keys(lhs);
+    const rhsKeys = Object.keys(rhs);
+    if (lhsKeys.length !== rhsKeys.length)
+        return false;
+    for (let key of lhsKeys) {
+        if (!rhsKeys.includes(key))
+            return false;
+        if (typeof lhs[key] === 'function' || typeof rhs[key] === 'function') {
+            if (lhs[key].toString() !== rhs[key].toString())
+                return false;
+        }
+        else {
+            if (!objectsDeepEqual(lhs[key], rhs[key]))
+                return false;
+        }
+    }
+    return true;
+}
+
+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$1(key)) &&
+        entry.data.__type === undefined);
+}
+
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -43223,7 +43427,7 @@ function isFailure(result) {
 function errors(result) {
     return result.error;
 }
-function values$3(result) {
+function values$4(result) {
     return result.value;
 }
 function flattenResults(results) {
@@ -43231,7 +43435,7 @@ function flattenResults(results) {
     if (fails.length > 0) {
         return failure(fails);
     }
-    return success(results.filter(isSuccess).map(values$3));
+    return success(results.filter(isSuccess).map(values$4));
 }
 
 function getFieldInfo(apiName, fieldName, infoMap) {
@@ -44117,7 +44321,7 @@ function fieldsToFilters(fieldValues, joinAlias, apiName, input, compoundOperato
     if (failures.length > 0) {
         return failure(failures);
     }
-    const containers = results.filter(isSuccess).map(values$3);
+    const containers = results.filter(isSuccess).map(values$4);
     const predicates = [];
     containers.forEach((c) => {
         if (c.predicate !== undefined) {
@@ -44409,7 +44613,7 @@ function dateFunctions(operatorNode, extract, dataType) {
     if (fails.length > 0) {
         return failure(fails);
     }
-    const vals = results.filter(isSuccess).reduce(flatMap$1(values$3), []);
+    const vals = results.filter(isSuccess).reduce(flatMap$1(values$4), []);
     return success(vals);
 }
 function isFilterFunction(name) {
@@ -44419,7 +44623,7 @@ function fieldOperators(operatorNode, dataType) {
     const results = Object.entries(operatorNode.fields)
         .filter(([key, _]) => isFilterFunction(key) === false)
         .map(([key, value]) => operatorWithValue(key, value, dataType));
-    const _values = results.filter(isSuccess).map(values$3);
+    const _values = results.filter(isSuccess).map(values$4);
     const fails = results.filter(isFailure).reduce(flatMap$1(errors), []);
     if (fails.length > 0) {
         return failure(fails);
@@ -45340,7 +45544,7 @@ function selectionToQueryField(node, names, parentApiName, parentAlias, input, j
 }
 function recordFields(luvioSelections, names, parentApiName, parentAlias, input, joins) {
     const results = luvioSelections.map((selection) => selectionToQueryField(selection, names, parentApiName, parentAlias, input, joins));
-    const fields = results.filter(isSuccess).reduce(flatMap$1(values$3), []);
+    const fields = results.filter(isSuccess).reduce(flatMap$1(values$4), []);
     const fails = results.filter(isFailure).reduce(flatMap$1(errors), []);
     if (fails.length > 0) {
         return failure(fails);
@@ -45586,7 +45790,7 @@ function rootRecordQuery(selection, input) {
 }
 function rootQuery(recordNodes, input) {
     const results = recordNodes.map((record) => rootRecordQuery(record, input));
-    const connections = results.filter(isSuccess).map(values$3);
+    const connections = results.filter(isSuccess).map(values$4);
     const fails = results.filter(isFailure).reduce(flatMap$1(errors), []);
     if (fails.length > 0) {
         return failure(fails);
@@ -46037,7 +46241,11 @@ function makeStoreEval(preconditioner, objectInfoService, userId, contextProvide
         try {
             const { data, seenRecords } = await queryEvaluator(rootQuery, context, eventEmitter);
             const rebuildWithStoreEval = ((originalSnapshot) => {
-                return storeEval(config, originalSnapshot, observers, connectionKeyBuilder);
+                return storeEval(config, originalSnapshot, observers, connectionKeyBuilder).then((rebuiltSnapshot) => {
+                    return objectsDeepEqual(originalSnapshot.data, rebuiltSnapshot.data)
+                        ? originalSnapshot
+                        : rebuiltSnapshot;
+                });
             });
             const recordId = generateUniqueRecordId$1();
             // if the non-eval'ed snapshot was an error then we return a synthetic
@@ -46340,7 +46548,7 @@ function createDraftSynthesisErrorResponse(message = 'failed to synthesize draft
     return new DraftErrorFetchResponse(HttpStatusCode$1.BadRequest, error);
 }
 
-const { keys: keys$5, create: create$5, assign: assign$5, values: values$2 } = Object;
+const { keys: keys$5, create: create$5, assign: assign$5, values: values$3 } = Object;
 const { stringify: stringify$5, parse: parse$5 } = JSON;
 const { isArray: isArray$3 } = Array;
 
@@ -46775,7 +46983,7 @@ class DurableDraftQueue {
                 const queueOperations = handler.getQueueOperationsForCompletingDrafts(queue, action);
                 // write the queue operations to the store prior to ingesting the result
                 await this.draftStore.completeAction(queueOperations);
-                await handler.handleActionCompleted(action, queueOperations, values$2(this.handlers));
+                await handler.handleActionCompleted(action, queueOperations, values$3(this.handlers));
                 this.retryIntervalMilliseconds = 0;
                 this.uploadingActionId = undefined;
                 await this.notifyChangedListeners({
@@ -47983,49 +48191,6 @@ function makeEnvironmentDraftAware(luvio, env, durableStore, handlers, draftQueu
     });
 }
 
-/**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-
-const API_NAMESPACE$1 = 'UiApi';
-const RECORD_REPRESENTATION_NAME$2 = 'RecordRepresentation';
-const RECORD_VIEW_ENTITY_REPRESENTATION_NAME$1 = 'RecordViewEntityRepresentation';
-const RECORD_ID_PREFIX$1 = `${API_NAMESPACE$1}::${RECORD_REPRESENTATION_NAME$2}:`;
-const RECORD_VIEW_ENTITY_ID_PREFIX$1 = `${API_NAMESPACE$1}::${RECORD_VIEW_ENTITY_REPRESENTATION_NAME$1}:Name:`;
-const RECORD_FIELDS_KEY_JUNCTION$1 = '__fields__';
-function isStoreKeyRecordId(key) {
-    return key.indexOf(RECORD_ID_PREFIX$1) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION$1) === -1;
-}
-function isStoreKeyRecordViewEntity$1(key) {
-    return (key.indexOf(RECORD_VIEW_ENTITY_ID_PREFIX$1) > -1 &&
-        key.indexOf(RECORD_FIELDS_KEY_JUNCTION$1) === -1);
-}
-function isStoreKeyRecordField(key) {
-    return key.indexOf(RECORD_ID_PREFIX$1) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION$1) > -1;
-}
-function extractRecordIdFromStoreKey$1(key) {
-    if (key === undefined ||
-        (key.indexOf(RECORD_ID_PREFIX$1) === -1 && key.indexOf(RECORD_VIEW_ENTITY_ID_PREFIX$1) === -1)) {
-        return undefined;
-    }
-    const parts = key.split(':');
-    return parts[parts.length - 1].split('_')[0];
-}
-function buildRecordFieldStoreKey(recordKey, fieldName) {
-    return `${recordKey}${RECORD_FIELDS_KEY_JUNCTION$1}${fieldName}`;
-}
-
-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$1(key)) &&
-        entry.data.__type === undefined);
-}
-
 function serializeFieldArguments$1(argumentNodes, variables) {
     const mutableArgumentNodes = Object.assign([], argumentNodes);
     return `args__(${mutableArgumentNodes
@@ -48257,7 +48422,7 @@ function isArrayLike(x) {
         (x.length === 0 || (x.length > 0 && Object.prototype.hasOwnProperty.call(x, x.length - 1))));
 }
 
-const { create: create$4, keys: keys$4, values: values$1, entries: entries$3, assign: assign$4 } = Object;
+const { create: create$4, keys: keys$4, values: values$2, entries: entries$3, assign: assign$4 } = Object;
 const { stringify: stringify$4, parse: parse$4 } = JSON;
 const { isArray: isArray$2$1 } = Array;
 
@@ -48590,7 +48755,7 @@ function dateTimePredicate(input, operator, field, alias) {
         return predicate;
     }
     else if (literal !== undefined) {
-        const isAvailableLiteral = values$1(DateLiteral).includes(literal);
+        const isAvailableLiteral = values$2(DateLiteral).includes(literal);
         // eslint-disable-next-line @salesforce/lds/no-error-in-production
         if (!isAvailableLiteral)
             throw new Error(`${literal} is not a valid DateLiteral`);
@@ -49264,7 +49429,7 @@ function dedupeJoins(joins) {
     for (const join of joins) {
         deduped[join.alias + join.to] = join;
     }
-    return values$1(deduped);
+    return values$2(deduped);
 }
 function buildJoins(config) {
     let sql = '';
@@ -49912,7 +50077,7 @@ function flatten(previous, current) {
     return previous.concat(current);
 }
 function findFieldInfo(objectInfo, fieldName) {
-    return values$1(objectInfo.fields).find((field) => field.apiName === fieldName ||
+    return values$2(objectInfo.fields).find((field) => field.apiName === fieldName ||
         (field.dataType === 'Reference' && field.relationshipName === fieldName));
 }
 
@@ -49932,10 +50097,10 @@ function orderByToPredicate(orderBy, recordType, alias, objectInfoMap, joins) {
         for (let i = 0, len = keys$1.length; i < len; i++) {
             const key = keys$1[i];
             const parentFields = objectInfoMap[recordType].fields;
-            const fieldInfo = values$1(parentFields).find(findSpanningField(key));
+            const fieldInfo = values$2(parentFields).find(findSpanningField(key));
             if (fieldInfo && fieldInfo.referenceToInfos.length > 0) {
                 const { apiName } = fieldInfo.referenceToInfos[0];
-                const parentFieldInfo = values$1(objectInfoMap[recordType].fields).find(findSpanningField(fieldInfo.apiName));
+                const parentFieldInfo = values$2(objectInfoMap[recordType].fields).find(findSpanningField(fieldInfo.apiName));
                 if (parentFieldInfo !== undefined) {
                     const path = {
                         leftPath: `$.fields.${parentFieldInfo.apiName}.value`,
@@ -50077,7 +50242,7 @@ function addResolversToSchema(schema, polyFields) {
     let baseRecord = undefined;
     // Concrete types for Polymorphic field
     const polyTypes = [];
-    for (const type of values$1(schema.getTypeMap())) {
+    for (const type of values$2(schema.getTypeMap())) {
         if (type.name === 'Record') {
             recordInterface = type;
         }
@@ -50090,7 +50255,7 @@ function addResolversToSchema(schema, polyFields) {
         if (polyFields.find((fieldTypeName) => fieldTypeName === type.name) !== undefined) {
             polyTypes.push(type);
         }
-        const fields = values$1(type.getFields());
+        const fields = values$2(type.getFields());
         // initialize the fields of current type with default behavior
         for (const field of fields) {
             field.resolve = defaultFieldResolver;
@@ -50492,26 +50657,20 @@ function generateRecordQueries(objectInfos) {
     let recordConnections = ``;
     const polymorphicFieldTypeNames = new Set();
     let typedScalars = new Set();
-    for (const objectInfo of values$1(objectInfos)) {
+    let parentRelationshipFields = new Set();
+    for (const objectInfo of values$2(objectInfos)) {
         const { apiName, childRelationships } = objectInfo;
         let fields = ``;
         typedScalars.add(`${apiName}_Filter`);
         typedScalars.add(`${apiName}_OrderBy`);
-        for (const childRelationship of childRelationships) {
-            const { childObjectApiName } = childRelationship;
-            // Only add the relationship if there is relevant objectinfos for it,
-            // otherwise we'd be defining types we cannot satisfy and aren't referenced in
-            // the query.
-            if (objectInfos[childObjectApiName] !== undefined) {
-                fields += `${childRelationship.relationshipName}(first: Int, where: ${childObjectApiName}_Filter, orderBy: ${childObjectApiName}_OrderBy, scope: SupportedScopes): ${childObjectApiName}Connection \n`;
-                typedScalars.add(`${childObjectApiName}_Filter`);
-                typedScalars.add(`${childObjectApiName}_OrderBy`);
-            }
-        }
-        for (const field of values$1(objectInfo.fields)) {
+        for (const field of values$2(objectInfo.fields)) {
             if (!fieldsStaticallyAdded.includes(field.apiName)) {
                 fields += `${field.apiName}: ${dataTypeToType(field.dataType, field.apiName)}\n`;
             }
+            //handles parent relationship
+            if (field.relationshipName === null) {
+                continue;
+            }
             // For spanning parent relationships with no union types
             if (field.referenceToInfos.length === 1) {
                 const [relation] = field.referenceToInfos;
@@ -50519,11 +50678,13 @@ function generateRecordQueries(objectInfos) {
                 // otherwise we'd be defining types we cannot satisfy and aren't referenced in
                 // the query.
                 if (objectInfos[relation.apiName] !== undefined) {
+                    parentRelationshipFields.add(field.relationshipName);
                     fields += `${field.relationshipName}: ${relation.apiName}\n`;
                 }
                 // For polymorphic field, its type is 'Record' inteface. The concrete entity type name is saved for field resolving of next phase
             }
             else if (field.referenceToInfos.length > 1) {
+                parentRelationshipFields.add(field.relationshipName);
                 fields += `${field.relationshipName}: Record\n`;
                 for (const relation of field.referenceToInfos) {
                     if (objectInfos[relation.apiName] !== undefined) {
@@ -50532,6 +50693,20 @@ function generateRecordQueries(objectInfos) {
                 }
             }
         }
+        // handles child relationship
+        for (const childRelationship of childRelationships) {
+            const { childObjectApiName } = childRelationship;
+            // Only add the relationship if there is relevant objectinfos for it,
+            // otherwise we'd be defining types we cannot satisfy and aren't referenced in
+            // the query.
+            // If one field has both parent relationship and child relationship with the same name, the child relationship is ignored. This is how the server GQL has implemented as date of 08/07/2023
+            if (objectInfos[childObjectApiName] !== undefined &&
+                !parentRelationshipFields.has(childRelationship.relationshipName)) {
+                fields += `${childRelationship.relationshipName}(first: Int, where: ${childObjectApiName}_Filter, orderBy: ${childObjectApiName}_OrderBy, scope: SupportedScopes): ${childObjectApiName}Connection \n`;
+                typedScalars.add(`${childObjectApiName}_Filter`);
+                typedScalars.add(`${childObjectApiName}_OrderBy`);
+            }
+        }
         recordQueries += `${apiName}(first: Int, where: ${apiName}_Filter, orderBy: ${apiName}_OrderBy, scope: SupportedScopes): ${apiName}Connection\n`;
         const isServiceAppointment = apiName === 'ServiceAppointment';
         recordConnections += /* GraphQL */ `
@@ -51011,7 +51186,7 @@ function isMineScopeAvailable(apiNamePath, objectInfoApiMap, objectInfos) {
     const objectInfo = objectInfos[apiName[0]];
     if (!objectInfo)
         return false;
-    return values$1(objectInfo.fields).some((fieldInfo) => {
+    return values$2(objectInfo.fields).some((fieldInfo) => {
         return (fieldInfo.apiName === 'OwnerId' &&
             fieldInfo.referenceToInfos.some((referenceToInfo) => {
                 return referenceToInfo.apiName === 'User';
@@ -52262,7 +52437,7 @@ function referenceIdFieldForRelationship(relationshipName) {
  * For full license text, see the LICENSE.txt file
  */
 
-const { keys: keys$3, values, create: create$3, assign: assign$3, freeze: freeze$2 } = Object;
+const { keys: keys$3, values: values$1, create: create$3, assign: assign$3, freeze: freeze$2 } = Object;
 const { stringify: stringify$3, parse: parse$3 } = JSON;
 const { shift } = Array.prototype;
 const { isArray: isArray$1$1 } = Array;
@@ -53112,7 +53287,7 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
                 return;
             }
             const objectInfo = objectInfoMap[apiName];
-            const optionalFields = values(objectInfo.fields).map((field) => `${apiName}.${field.apiName}`);
+            const optionalFields = values$1(objectInfo.fields).map((field) => `${apiName}.${field.apiName}`);
             await getAdapterData(this.getRecordAdapter, {
                 recordId: referenceFieldInfo.id,
                 optionalFields,
@@ -53131,7 +53306,7 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
         const referenceToInfos = fieldInfo.referenceToInfos;
         const apiNames = referenceToInfos.map((referenceToInfo) => referenceToInfo.apiName);
         const objectInfoMap = await this.objectInfoService.getObjectInfos(apiNames);
-        for (const objectInfo of values(objectInfoMap)) {
+        for (const objectInfo of values$1(objectInfoMap)) {
             const { apiName, keyPrefix } = objectInfo;
             if (keyPrefix !== null && id.startsWith(keyPrefix)) {
                 return apiName;
@@ -53641,14 +53816,30 @@ function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecord
         const operationsWithDenormedRecords = [];
         for (let i = 0, len = operations.length; i < len; i++) {
             const operation = operations[i];
-            if (operation.segment !== DefaultDurableSegment || operation.type !== 'setEntries') {
-                operationsWithDenormedRecords.push(operation);
-                continue;
+            if (durableStore.plugin !== undefined &&
+                durableStore.plugin.supportsBatchUpdates !== undefined &&
+                durableStore.plugin.supportsBatchUpdates() === true) {
+                if (operation.segment !== DefaultDurableSegment ||
+                    operation.type !== 'setEntries') {
+                    operationsWithDenormedRecords.push(operation);
+                    continue;
+                }
+                operationsWithDenormedRecords.push({
+                    ...operation,
+                    entries: denormalizeEntries(operation.entries),
+                });
+            }
+            else {
+                if (operation.segment !== DefaultDurableSegment ||
+                    operation.type === 'evictEntries') {
+                    operationsWithDenormedRecords.push(operation);
+                    continue;
+                }
+                operationsWithDenormedRecords.push({
+                    ...operation,
+                    entries: denormalizeEntries(operation.entries),
+                });
             }
-            operationsWithDenormedRecords.push({
-                ...operation,
-                entries: denormalizeEntries(operation.entries),
-            });
         }
         return durableStore.batchOperations(operationsWithDenormedRecords);
     };
@@ -54196,6 +54387,9 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
             if (!rebuildResult.errors) {
                 rebuildResult = removeSyntheticFields(rebuildResult, config.query);
             }
+            if (objectsDeepEqual(rebuildResult, originalSnapshot.data)) {
+                return originalSnapshot;
+            }
             // 'originalSnapshot' is the local eval snapshot subscribed. It is always in 'Fulfilled' state. This behavior would change once W-1273462(rebuild non-evaluated snapshot when the graphql local eval rebuild is triggered) is resolved.
             return {
                 ...originalSnapshot,
@@ -56227,7 +56421,7 @@ function registerReportObserver(reportObserver) {
     };
 }
 
-const { keys: keys$9, create: create$7, assign: assign$7, entries } = Object;
+const { keys: keys$9, create: create$7, assign: assign$7, entries, values } = Object;
 const { stringify: stringify$7, parse: parse$7 } = JSON;
 
 function selectColumnsFromTableWhereKeyIn(columnNames, table, keyColumnName, whereIn) {
@@ -56261,6 +56455,22 @@ class LdsDataTable {
             }, 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$7(stringifiedMetadata),
+                        };
+                    }
+                    return entries;
+                }, {}));
+            }, reject);
+        });
+    }
     getAll() {
         return new Promise((resolve, reject) => {
             this.plugin.query(this.getAllQuery, [], (x) => {
@@ -56287,6 +56497,24 @@ class LdsDataTable {
             }, []),
         };
     }
+    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$9(entries).reduce((values, key) => {
+                const { metadata } = entries[key];
+                const row = [metadata ? stringify$7(metadata) : null];
+                values[key] = row;
+                return values;
+            }, {}),
+        };
+    }
     mapToDurableEntries(sqliteResult) {
         return sqliteResult.rows.reduce((entries, row) => {
             const [key, stringifiedData, stringifiedMetadata] = row;
@@ -56333,6 +56561,25 @@ class LdsInternalDataTable {
             }, 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$7(stringifiedMetadata),
+                        };
+                    }
+                    return entries;
+                }, {}));
+            }, reject);
+        });
+    }
     getAll(namespace) {
         return new Promise((resolve, reject) => {
             this.plugin.query(this.getAllQuery, [namespace], (x) => {
@@ -56366,6 +56613,42 @@ class LdsInternalDataTable {
             }, []),
         };
     }
+    metadataToUpdateOperations(entries, segment) {
+        return {
+            type: 'update',
+            table: this.tableName,
+            keyColumn: COLUMN_NAME_KEY$1,
+            context: {
+                segment,
+                type: 'setMetadata',
+            },
+            columns: [COLUMN_NAME_METADATA],
+            values: keys$9(entries).reduce((values, key) => {
+                const { metadata } = entries[key];
+                const row = [metadata ? stringify$7(metadata) : null];
+                values[key] = row;
+                return values;
+            }, {}),
+        };
+    }
+    metadataToUpdateSQLQueries(entries, segment) {
+        return keys$9(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$7(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;
@@ -56402,9 +56685,16 @@ class NimbusSqliteStore {
             });
         });
     }
+    batchQuery(queries) {
+        const promises = queries.map((q) => this.query(q.sql, q.params));
+        return Promise.all(promises);
+    }
     async getEntries(entryIds, segment) {
         return this.getTable(segment).getByKeys(entryIds, segment);
     }
+    async getMetadata(entryIds, segment) {
+        return this.getTable(segment).getMetadataByKeys(entryIds, segment);
+    }
     getAllEntries(segment) {
         return this.getTable(segment).getAll(segment);
     }
@@ -56413,12 +56703,30 @@ class NimbusSqliteStore {
         const upsertOperation = table.entriesToUpsertOperations(entries, segment);
         return this.batchOperationAsPromise([upsertOperation]);
     }
+    setMetadata(entries, segment) {
+        const table = this.getTable(segment);
+        const operation = this.plugin.supportsBatchUpdates === undefined ||
+            this.plugin.supportsBatchUpdates() === false
+            ? table.entriesToUpsertOperations(entries, segment)
+            : table.metadataToUpdateOperations(entries, segment);
+        return this.batchOperationAsPromise([operation]);
+    }
     batchOperations(operations) {
         const sqliteOperations = operations.reduce((acc, cur) => {
             if (cur.type === 'setEntries') {
                 const table = this.getTable(cur.segment);
                 acc.push(table.entriesToUpsertOperations(cur.entries, cur.segment));
             }
+            else if (cur.type === 'setMetadata') {
+                const table = this.getTable(cur.segment);
+                if (this.plugin.supportsBatchUpdates === undefined ||
+                    this.plugin.supportsBatchUpdates() === false) {
+                    acc.push(table.entriesToUpsertOperations(cur.entries, cur.segment));
+                }
+                else {
+                    acc.push(table.metadataToUpdateOperations(cur.entries, cur.segment));
+                }
+            }
             else {
                 acc.push(this.idsToDeleteOperation(cur.ids, cur.segment));
             }
@@ -56435,8 +56743,15 @@ class NimbusSqliteStore {
         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.context.type !== undefined) {
+                    type = c.context.type;
+                }
                 return {
-                    type: c.type === 'upsert' ? 'setEntries' : 'evictEntries',
+                    type,
                     ids: c.keys,
                     isExternalChange: false,
                     segment: c.context.segment,
@@ -56503,6 +56818,10 @@ class AbstractKeyValueDataTable {
             }, reject);
         });
     }
+    getMetadataByKeys(_keys) {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
+        throw new Error(`There is no metadata in the ${this.tableName} table.`);
+    }
     getAll() {
         const getAllQuery = `SELECT ${this.columnNames.join(',')} FROM ${this.tableName}`;
         return new Promise((resolve, reject) => {
@@ -56528,6 +56847,10 @@ class AbstractKeyValueDataTable {
             }, []),
         };
     }
+    metadataToUpdateOperations(_entries, _segment) {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
+        throw new Error(`There is no metadata in the ${this.tableName} table.`);
+    }
     mapToDurableEntries(sqliteResult) {
         return sqliteResult.rows.reduce((entries, row) => {
             const [key, stringifiedData] = row;
@@ -57865,6 +58188,7 @@ function getRuntime() {
         const gqlEnv = makeEnvironmentGraphqlAware(baseEnv);
         const durableEnv = makeDurable(gqlEnv, {
             durableStore: recordDenormingStore,
+            enableDurableMetadataRefresh: ldsMetadataRefreshEnabled.isOpen({ fallback: false }),
         });
         getIngestRecords = durableEnv.getIngestStagingStoreRecords;
         getIngestMetadata = durableEnv.getIngestStagingStoreMetadata;
@@ -57963,7 +58287,7 @@ register({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$1,
 });
-// version: 1.233.0-8ab7ef233
+// version: 1.235.0-3790decf0
 
 const { create: create$2, keys: keys$2 } = Object;
 const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -76434,7 +76758,7 @@ register({
     configuration: { ...configurationForGraphQLAdapters },
     instrument,
 });
-// version: 1.233.0-e0ba7cc7b
+// version: 1.235.0-c252f93dc
 
 // On core the unstable adapters are re-exported with different names,
 
@@ -78681,7 +79005,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.233.0-e0ba7cc7b
+// version: 1.235.0-c252f93dc
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -79395,4 +79719,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, invokeAdapter, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, subscribeToAdapter };
-// version: 1.233.0-8ab7ef233
+// version: 1.235.0-3790decf0