@salesforce/lds-worker-api 1.233.0 → 1.235.0

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

@@ -26,7 +26,7 @@
         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;
@@ -846,14 +846,16 @@
             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 = {
@@ -1495,12 +1497,20 @@
                 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;
@@ -3284,6 +3294,9 @@
         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);
@@ -3847,7 +3860,7 @@
         }
         return resourceParams;
     }
-    // engine version: 0.145.3-1693bfb7
+    // engine version: 0.147.1-bc3a8b47
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -3974,7 +3987,7 @@
         }
         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) {
@@ -15435,7 +15448,7 @@
         }
         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".
@@ -15536,14 +15549,15 @@
             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.
      *
@@ -16358,7 +16372,7 @@
         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.,
@@ -16457,7 +16471,7 @@
         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;
 
@@ -41311,7 +41325,7 @@
         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';
 
@@ -41431,6 +41445,15 @@
         },
     };
 
+    var ldsMetadataRefreshEnabled = {
+        isOpen: function (e) {
+            return e.fallback;
+        },
+        hasError: function () {
+            return !0;
+        },
+    };
+
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
      * All rights reserved.
@@ -42005,7 +42028,7 @@
      * 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.
@@ -42015,10 +42038,21 @@
                 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)));
@@ -42068,7 +42102,7 @@
                 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);
                     }
                 }
             }
@@ -42157,8 +42191,9 @@
         }
     }
 
-    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
@@ -42168,32 +42203,36 @@
         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({
@@ -42220,6 +42259,17 @@
         }
         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) {
@@ -42264,6 +42314,50 @@
         }
     }
 
+    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) {
@@ -42319,14 +42413,16 @@
      * @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);
@@ -42352,6 +42448,7 @@
             const defaultSegmentKeys = [];
             const adapterContextSegmentKeys = [];
             const redirectSegmentKeys = [];
+            const metadataRefreshSegmentKeys = [];
             const messagingSegmentKeys = [];
             let shouldBroadcast = false;
             for (let i = 0, len = changes.length; i < len; i++) {
@@ -42359,7 +42456,12 @@
                 // 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);
@@ -42423,9 +42525,26 @@
                     // 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);
             }
@@ -42451,10 +42570,10 @@
         };
         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
@@ -42463,26 +42582,26 @@
         };
         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();
@@ -42493,19 +42612,19 @@
         };
         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
@@ -42514,24 +42633,24 @@
         };
         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();
@@ -42543,7 +42662,7 @@
                     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;
@@ -42584,10 +42703,10 @@
             // 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();
@@ -42628,7 +42747,7 @@
                 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,
@@ -42653,15 +42772,15 @@
         };
         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 {};
         };
@@ -42700,22 +42819,20 @@
                     }
                     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();
@@ -42744,7 +42861,7 @@
                 // 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) {
@@ -42755,12 +42872,12 @@
             }
             // 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) {
@@ -42811,6 +42928,27 @@
             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',
@@ -42845,6 +42983,72 @@
         });
     }
 
+    /**
+     * 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.
@@ -43229,7 +43433,7 @@
     function errors(result) {
         return result.error;
     }
-    function values$3(result) {
+    function values$4(result) {
         return result.value;
     }
     function flattenResults(results) {
@@ -43237,7 +43441,7 @@
         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) {
@@ -44123,7 +44327,7 @@
         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) {
@@ -44415,7 +44619,7 @@
         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) {
@@ -44425,7 +44629,7 @@
         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);
@@ -45346,7 +45550,7 @@
     }
     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);
@@ -45592,7 +45796,7 @@
     }
     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);
@@ -46043,7 +46247,11 @@
             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
@@ -46346,7 +46554,7 @@
         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;
 
@@ -46781,7 +46989,7 @@
                     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({
@@ -47989,49 +48197,6 @@
         });
     }
 
-    /**
-     * 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
@@ -48263,7 +48428,7 @@
             (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;
 
@@ -48596,7 +48761,7 @@
             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`);
@@ -49270,7 +49435,7 @@
         for (const join of joins) {
             deduped[join.alias + join.to] = join;
         }
-        return values$1(deduped);
+        return values$2(deduped);
     }
     function buildJoins(config) {
         let sql = '';
@@ -49918,7 +50083,7 @@
         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));
     }
 
@@ -49938,10 +50103,10 @@
             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`,
@@ -50083,7 +50248,7 @@
         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;
             }
@@ -50096,7 +50261,7 @@
             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;
@@ -50498,26 +50663,20 @@
         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;
@@ -50525,11 +50684,13 @@
                     // 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) {
@@ -50538,6 +50699,20 @@
                     }
                 }
             }
+            // 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 */ `
@@ -51017,7 +51192,7 @@
         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';
@@ -52268,7 +52443,7 @@
      * 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;
@@ -53118,7 +53293,7 @@
                     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,
@@ -53137,7 +53312,7 @@
             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;
@@ -53647,14 +53822,30 @@
             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);
         };
@@ -54202,6 +54393,9 @@
                 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,
@@ -56233,7 +56427,7 @@
         };
     }
 
-    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) {
@@ -56267,6 +56461,22 @@
                 }, 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) => {
@@ -56293,6 +56503,24 @@
                 }, []),
             };
         }
+        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;
@@ -56339,6 +56567,25 @@
                 }, 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) => {
@@ -56372,6 +56619,42 @@
                 }, []),
             };
         }
+        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;
@@ -56408,9 +56691,16 @@
                 });
             });
         }
+        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);
         }
@@ -56419,12 +56709,30 @@
             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));
                 }
@@ -56441,8 +56749,15 @@
             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,
@@ -56509,6 +56824,10 @@
                 }, 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) => {
@@ -56534,6 +56853,10 @@
                 }, []),
             };
         }
+        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;
@@ -57871,6 +58194,7 @@
             const gqlEnv = makeEnvironmentGraphqlAware(baseEnv);
             const durableEnv = makeDurable(gqlEnv, {
                 durableStore: recordDenormingStore,
+                enableDurableMetadataRefresh: ldsMetadataRefreshEnabled.isOpen({ fallback: false }),
             });
             getIngestRecords = durableEnv.getIngestStagingStoreRecords;
             getIngestMetadata = durableEnv.getIngestStagingStoreMetadata;
@@ -57969,7 +58293,7 @@
         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;
@@ -76440,7 +76764,7 @@
         configuration: { ...configurationForGraphQLAdapters },
         instrument,
     });
-    // version: 1.233.0-e0ba7cc7b
+    // version: 1.235.0-c252f93dc
 
     // On core the unstable adapters are re-exported with different names,
 
@@ -78687,7 +79011,7 @@
         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,
@@ -79418,4 +79742,4 @@
     Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-// version: 1.233.0-8ab7ef233
+// version: 1.235.0-3790decf0