@salesforce/lds-worker-api 1.130.10 → 1.131.0-dev11

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

@@ -26,26 +26,26 @@
         SnapshotState["Stale"] = "Stale";
     })(SnapshotState$3 || (SnapshotState$3 = {}));
 
-    const { create: create$9, entries: entries$4, freeze: freeze$4, keys: keys$9, values: values$3 } = Object;
+    const { create: create$9, entries: entries$4, freeze: freeze$4, keys: keys$a, values: values$3 } = Object;
     const { hasOwnProperty: hasOwnProperty$3 } = Object.prototype;
     const { isArray: isArray$a } = Array;
     const { push: push$4, indexOf, slice: slice$2 } = Array.prototype;
     const { parse: parse$9, stringify: stringify$9 } = JSON;
 
-    function deepFreeze$R(value) {
+    function deepFreeze$S(value) {
         // No need to freeze primitives
         if (typeof value !== 'object' || value === null) {
             return;
         }
         if (isArray$a(value)) {
             for (let i = 0, len = value.length; i < len; i += 1) {
-                deepFreeze$R(value[i]);
+                deepFreeze$S(value[i]);
             }
         }
         else {
-            const keys$1 = keys$9(value);
+            const keys$1 = keys$a(value);
             for (let i = 0, len = keys$1.length; i < len; i += 1) {
-                deepFreeze$R(value[keys$1[i]]);
+                deepFreeze$S(value[keys$1[i]]);
             }
         }
         freeze$4(value);
@@ -67,7 +67,7 @@
         return snapshot.state === SnapshotState$3.Pending;
     }
     function createErrorSnapshot$1(error, refresh) {
-        deepFreeze$R(error);
+        deepFreeze$S(error);
         const snap = {
             error,
             state: SnapshotState$3.Error,
@@ -304,7 +304,7 @@
         if (node === null) {
             return 'null';
         }
-        const keys$1 = keys$9(node).sort();
+        const keys$1 = keys$a(node).sort();
         out = '';
         for (i = 0; i < keys$1.length; i++) {
             const key = keys$1[i];
@@ -575,13 +575,13 @@
             return this.records[this.getCanonicalRecordId(key)];
         }
         getNumEntries() {
-            return keys$9(this.records).length;
+            return keys$a(this.records).length;
         }
         readMetadata(key) {
             return this.metadata[this.getCanonicalRecordId(key)];
         }
         readMetadataWhere(query) {
-            const keys$1 = keys$9(this.metadata);
+            const keys$1 = keys$a(this.metadata);
             const results = [];
             const hasNamespaceQuery = hasOwnProperty$3.call(query, 'namespace');
             const hasRepresentationNameQuery = hasOwnProperty$3.call(query, 'representationName');
@@ -606,9 +606,8 @@
             }
             return results;
         }
-        publish(recordId, record) {
+        put(recordId, record) {
             const { records, insertedIds, pendingTrimKeys, retainedIds } = this;
-            // make sure we publish to the canonical record id in case it's been redirected
             const canonicalKey = this.getCanonicalRecordId(recordId);
             if (hasOwnProperty$3.call(records, canonicalKey) === false) {
                 insertedIds[canonicalKey] = true;
@@ -621,6 +620,11 @@
             if (retainedIds[canonicalKey] === undefined) {
                 pendingTrimKeys.add(canonicalKey);
             }
+        }
+        publish(recordId, record) {
+            // make sure we publish to the canonical record id in case it's been redirected
+            const canonicalKey = this.getCanonicalRecordId(recordId);
+            this.put(canonicalKey, record);
             this.markVisited(canonicalKey);
             // TODO: Emit event for store publish once structured keys are used everywhere.
         }
@@ -657,7 +661,8 @@
             if (key === canonicalKey) {
                 throw new Error('cannot redirect a key to itself');
             }
-            if (reverseRedirectKeys[canonicalKey] !== undefined) {
+            if (reverseRedirectKeys[canonicalKey] !== undefined &&
+                reverseRedirectKeys[canonicalKey] !== key) {
                 throw new Error('cannot have multiple redirects keys point to the same canonical key');
             }
             if (redirectKeys[canonicalKey] !== undefined) {
@@ -673,8 +678,8 @@
             // Note: we should always get the subscription references from this at the beginning
             // of the function, in case the reference changes (because of an unsubscribe)
             const { snapshotSubscriptions, watchSubscriptions, visitedIds, refreshedIds, insertedIds } = this;
-            const allVisitedIds = keys$9(visitedIds);
-            const allRefreshedIds = keys$9(refreshedIds);
+            const allVisitedIds = keys$a(visitedIds);
+            const allRefreshedIds = keys$a(refreshedIds);
             // Early exit if nothing has changed
             if (allVisitedIds.length === 0 && allRefreshedIds.length === 0) {
                 return Promise.resolve();
@@ -829,14 +834,7 @@
             // find and evict the canonical key
             const canonicalKey = this.getCanonicalRecordId(key);
             delete this.records[canonicalKey];
-            this.visitedIds[canonicalKey] = true;
-            // mark all redirects leading up to the canonical key as visited so
-            // affected snapshots are updated
-            let redirectKey = this.reverseRedirectKeys[canonicalKey];
-            while (redirectKey !== undefined) {
-                this.visitedIds[redirectKey] = true;
-                redirectKey = this.reverseRedirectKeys[redirectKey];
-            }
+            this.markVisited(canonicalKey);
         }
         /**
          * Deallocates data at the canonical key location for in-memory (L1) cache
@@ -1128,7 +1126,7 @@
             hasOverlappingIds(snapshot, visitedIds) === false);
     }
     function getMatchingIds(partialKey, visitedIds) {
-        const keys$1 = keys$9(partialKey);
+        const keys$1 = keys$a(partialKey);
         return visitedIds.filter((visitedId) => {
             return keys$1.every((key) => {
                 return partialKey[key] === visitedId[key];
@@ -1214,9 +1212,9 @@
             }
             return results;
         }
-        publish(recordId, record) {
+        put(recordId, record) {
             if (typeof recordId === 'string') {
-                this.fallbackStringKeyInMemoryStore.publish(recordId, record);
+                this.fallbackStringKeyInMemoryStore.put(recordId, record);
                 return;
             }
             const { recordsMap, insertedIdsSet, pendingTrims, retainedIdsMap } = this;
@@ -1233,6 +1231,14 @@
             if (retainedIdsMap.get(canonicalKey) === undefined) {
                 pendingTrims.add(canonicalKey);
             }
+        }
+        publish(recordId, record) {
+            if (typeof recordId === 'string') {
+                this.fallbackStringKeyInMemoryStore.publish(recordId, record);
+                return;
+            }
+            const canonicalKey = this.getCanonicalRecordId(recordId);
+            this.put(canonicalKey, record);
             this.markVisited(canonicalKey);
             this.emitStorePublishEvent(recordId);
         }
@@ -1469,14 +1475,7 @@
             // find and evict the canonical key
             const canonicalKey = this.getCanonicalRecordId(key);
             this.recordsMap.delete(canonicalKey);
-            this.visitedIdsSet.add(canonicalKey);
-            // mark all redirects leading up to the canonical key as visited so
-            // affected snapshots are updated
-            let redirectKey = this.reverseRedirectKeysMap.get(canonicalKey);
-            while (redirectKey !== undefined) {
-                this.visitedIdsSet.add(redirectKey);
-                redirectKey = this.reverseRedirectKeysMap.get(redirectKey);
-            }
+            this.markVisited(canonicalKey);
         }
         /**
          * Deallocates data at the canonical key location for in-memory (L1) cache
@@ -1754,8 +1753,8 @@
             } while (redirectKey !== undefined);
         }
         isUsingStringKeys() {
-            return (keys$9(this.fallbackStringKeyInMemoryStore.visitedIds).length !== 0 ||
-                keys$9(this.fallbackStringKeyInMemoryStore.refreshedIds).length !== 0);
+            return (keys$a(this.fallbackStringKeyInMemoryStore.visitedIds).length !== 0 ||
+                keys$a(this.fallbackStringKeyInMemoryStore.refreshedIds).length !== 0);
         }
         delegateToFallbackStringKeyStore(snapshot) {
             return !isErrorSnapshot$3(snapshot) && typeof snapshot.recordId === 'string';
@@ -1797,7 +1796,7 @@
         buildKeySchema(keyMetadata) {
             // pull NamespacedType type out of NormalizedKeyMetadata
             const { namespace: _ns, representationName: _rn, ...keyParamValues } = keyMetadata;
-            const keySchema = keys$9(keyParamValues).sort();
+            const keySchema = keys$a(keyParamValues).sort();
             return ['namespace', 'representationName', ...keySchema];
         }
     }
@@ -2085,7 +2084,7 @@
             return value;
         }
         keys() {
-            return keys$9(this.data);
+            return keys$a(this.data);
         }
         isScalar(propertyName) {
             // TODO W-6900046 - merge.ts casts these to any and manually sets `data`
@@ -2463,7 +2462,7 @@
             }
         }
         selectAllObject(record, data, visitedKeys) {
-            const recordKeys = keys$9(record);
+            const recordKeys = keys$a(record);
             const { length } = recordKeys;
             for (let i = 0; i < length; i += 1) {
                 const key = recordKeys[i];
@@ -2646,7 +2645,7 @@
             }
             const { baseSnapshotValue } = this.currentPath;
             if (isDefined$1(baseSnapshotValue)) {
-                this.snapshotChanged = keys$1.length !== keys$9(baseSnapshotValue).length;
+                this.snapshotChanged = keys$1.length !== keys$a(baseSnapshotValue).length;
             }
         }
         checkIfChanged(value) {
@@ -2682,7 +2681,7 @@
                 return this.markMissing();
             }
             const sink = (data[propertyName] = {});
-            const keys$1 = keys$9(obj);
+            const keys$1 = keys$a(obj);
             this.checkIfObjectKeysLengthChanged(keys$1);
             for (let i = 0, len = keys$1.length; i < len; i += 1) {
                 const key = keys$1[i];
@@ -2694,7 +2693,7 @@
         }
         readLinkMap(propertyName, selection, record, data) {
             const map = record[propertyName];
-            const keys$1 = keys$9(map);
+            const keys$1 = keys$a(map);
             const sink = {};
             this.checkIfObjectKeysLengthChanged(keys$1);
             for (let i = 0, len = keys$1.length; i < len; i += 1) {
@@ -2824,7 +2823,7 @@
                 return;
             }
             const sink = (data[propertyName] = {});
-            const keys$1 = keys$9(obj);
+            const keys$1 = keys$a(obj);
             this.checkIfObjectKeysLengthChanged(keys$1);
             for (let i = 0, len = keys$1.length; i < len; i += 1) {
                 const key = keys$1[i];
@@ -3172,9 +3171,14 @@
             // since broadcast only deals with cached recordIds
             this.store.broadcastNonCachedSnapshot(key, errorSnapshot);
         }
+        // Adds the given data to the store at the given key and marks the key as visited.  Will cause subscribers to rebuild.
         storePublish(key, data) {
             this.store.publish(key, data);
         }
+        // Adds the given data to the store at the given key (does NOT mark the key as visited).  Will NOT cause subscribers to rebuild.  NOTE: This should really only be used by internal Luvio APIs.
+        storePut(key, data) {
+            this.store.put(key, data);
+        }
         storeRedirect(existingKey, redirectKey) {
             this.store.redirect(existingKey, redirectKey);
         }
@@ -3655,7 +3659,7 @@
             return this.environment.buildStructuredKey(namespace, representationName, idValues);
         }
     }
-    // engine version: 0.138.8-480e18f2
+    // engine version: 0.138.8-244.1-492a715e
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -3782,7 +3786,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.130.10-0fac4c295
+    // version: 1.131.0-dev11-b15472a13
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -3791,6 +3795,15 @@
     function setLdsNetworkAdapterInstrumentation(_networkAdapterRegistration) { }
     function instrumentLuvio(_context) { }
 
+    var excludeStaleRecordsGate = {
+        isOpen: function (e) {
+            return e.fallback;
+        },
+        hasError: function () {
+            return !0;
+        },
+    };
+
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
      * All rights reserved.
@@ -15206,7 +15219,7 @@
         updateReferenceMapWithKnownKey(ast, luvioDocumentNode);
         return luvioDocumentNode;
     }
-    // version: 1.130.10-0fac4c295
+    // version: 1.131.0-dev11-b15472a13
 
     function unwrap(data) {
         // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16119,7 +16132,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.130.10-0fac4c295
+    // version: 1.131.0-dev11-b15472a13
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -16202,7 +16215,7 @@
     ({
         state: FragmentReadResultState.Missing,
     });
-    // engine version: 0.138.8-480e18f2
+    // engine version: 0.138.8-244.1-492a715e
 
     const { keys: ObjectKeys$3, freeze: ObjectFreeze$3, create: ObjectCreate$3 } = Object;
 
@@ -16548,7 +16561,7 @@
                 return `Unexpected HTTP Status Code: ${status}`;
         }
     }
-    function isUnfulfilledSnapshot$1(snapshot) {
+    function isUnfulfilledSnapshot$1$1(snapshot) {
         return snapshot.state === SNAPSHOT_STATE_UNFULFILLED;
     }
     const keyPrefix$1 = 'UiApi';
@@ -16588,20 +16601,20 @@
         }
         return true;
     }
-    function deepFreeze$P(value) {
+    function deepFreeze$Q(value) {
         // No need to freeze primitives
         if (typeof value !== 'object' || value === null) {
             return;
         }
         if (ArrayIsArray$2(value)) {
             for (let i = 0, len = value.length; i < len; i += 1) {
-                deepFreeze$P(value[i]);
+                deepFreeze$Q(value[i]);
             }
         }
         else {
             const keys = ObjectKeys$2(value);
             for (let i = 0, len = keys.length; i < len; i += 1) {
-                deepFreeze$P(value[keys[i]]);
+                deepFreeze$Q(value[keys[i]]);
             }
         }
         ObjectFreeze$2(value);
@@ -16669,7 +16682,7 @@
             ]
         };
     };
-    function deepFreeze$O(input) {
+    function deepFreeze$P(input) {
         const input_operandLabels = input.operandLabels;
         ObjectFreeze$2(input_operandLabels);
         ObjectFreeze$2(input);
@@ -16747,7 +16760,7 @@
             ]
         };
     };
-    function deepFreeze$N(input) {
+    function deepFreeze$O(input) {
         ObjectFreeze$2(input);
     }
 
@@ -16771,7 +16784,7 @@
             ]
         };
     };
-    function deepFreeze$M(input) {
+    function deepFreeze$N(input) {
         const input_columnWidths = input.columnWidths;
         const input_columnWidths_keys = Object.keys(input_columnWidths);
         const input_columnWidths_length = input_columnWidths_keys.length;
@@ -16790,7 +16803,7 @@
     }
 
     const TTL$x = 900000;
-    const VERSION$18 = "ce51760eb46b65c484f42de806102162";
+    const VERSION$18 = "69101560544e3433c988f3a2b202744b";
     const RepresentationType$Q = 'ListInfoRepresentation';
     function keyBuilder$1R(luvio, config) {
         return keyPrefix$1 + '::' + RepresentationType$Q + ':' + (config.listViewApiName === null ? '' : config.listViewApiName) + ':' + config.objectApiName + ':' + config.type;
@@ -16856,11 +16869,6 @@
                     kind: 'Object',
                     selections: ListReferenceRepresentation__selections
                 },
-                {
-                    name: 'objectApiNames',
-                    kind: 'Scalar',
-                    plural: true
-                },
                 {
                     name: 'orderedByInfo',
                     kind: 'Object',
@@ -16987,7 +16995,7 @@
         }
         return true;
     }
-    function deepFreeze$L(input) {
+    function deepFreeze$M(input) {
         ObjectFreeze$2(input);
     }
 
@@ -17047,10 +17055,10 @@
         }
         return true;
     }
-    function deepFreeze$K(input) {
+    function deepFreeze$L(input) {
         const input_value = input.value;
         if (input_value !== null && typeof input_value === 'object') {
-            deepFreeze$I(input_value);
+            deepFreeze$J(input_value);
         }
         ObjectFreeze$2(input);
     }
@@ -17094,7 +17102,7 @@
         return rootKeySet;
     }
 
-    const { assign: assign$6, create: create$7, freeze: freeze$3, keys: keys$8 } = Object;
+    const { assign: assign$7, create: create$7, freeze: freeze$3, keys: keys$9 } = Object;
     const { hasOwnProperty: hasOwnProperty$1 } = Object.prototype;
     const { split, endsWith } = String.prototype;
     const { isArray: isArray$8 } = Array;
@@ -17112,7 +17120,7 @@
             mergeable: true,
         });
         const input_childRelationships = input.childRelationships;
-        const input_childRelationships_keys = keys$8(input_childRelationships);
+        const input_childRelationships_keys = keys$9(input_childRelationships);
         const input_childRelationships_length = input_childRelationships_keys.length;
         for (let i = 0; i < input_childRelationships_length; i++) {
             const key = input_childRelationships_keys[i];
@@ -17120,7 +17128,7 @@
             rootKeySet.merge(cacheKeys);
         }
         const input_fields = input.fields;
-        const input_fields_keys = keys$8(input_fields);
+        const input_fields_keys = keys$9(input_fields);
         const input_fields_length = input_fields_keys.length;
         for (let i = 0; i < input_fields_length; i++) {
             const key = input_fields_keys[i];
@@ -17243,11 +17251,11 @@
         }
         return true;
     }
-    function deepFreeze$J(input) {
+    function deepFreeze$K(input) {
         const input_records = input.records;
         for (let i = 0; i < input_records.length; i++) {
             const input_records_item = input_records[i];
-            deepFreeze$I(input_records_item);
+            deepFreeze$J(input_records_item);
         }
         ObjectFreeze$2(input_records);
         ObjectFreeze$2(input);
@@ -17540,14 +17548,14 @@
         }
         return true;
     }
-    function deepFreeze$I(input) {
+    function deepFreeze$J(input) {
         const input_childRelationships = input.childRelationships;
         const input_childRelationships_keys = Object.keys(input_childRelationships);
         const input_childRelationships_length = input_childRelationships_keys.length;
         for (let i = 0; i < input_childRelationships_length; i++) {
             const key = input_childRelationships_keys[i];
             const input_childRelationships_prop = input_childRelationships[key];
-            deepFreeze$J(input_childRelationships_prop);
+            deepFreeze$K(input_childRelationships_prop);
         }
         ObjectFreeze$2(input_childRelationships);
         const input_fields = input.fields;
@@ -17556,12 +17564,12 @@
         for (let i = 0; i < input_fields_length; i++) {
             const key = input_fields_keys[i];
             const input_fields_prop = input_fields[key];
-            deepFreeze$K(input_fields_prop);
+            deepFreeze$L(input_fields_prop);
         }
         ObjectFreeze$2(input_fields);
         const input_recordTypeInfo = input.recordTypeInfo;
         if (input_recordTypeInfo !== null && typeof input_recordTypeInfo === 'object') {
-            deepFreeze$L(input_recordTypeInfo);
+            deepFreeze$M(input_recordTypeInfo);
         }
         ObjectFreeze$2(input);
     }
@@ -17621,7 +17629,7 @@
         for (let i = 0, len = value.length; i < len; i += 1) {
             result[value[i]] = true;
         }
-        return keys$8(result);
+        return keys$9(result);
     }
     /**
      * @param source The array of string to filter
@@ -19069,7 +19077,7 @@
     function createPathSelection(propertyName, fieldDefinition) {
         const fieldsSelection = [];
         const { children } = fieldDefinition;
-        const childrenKeys = keys$8(children);
+        const childrenKeys = keys$9(children);
         for (let i = 0, len = childrenKeys.length; i < len; i += 1) {
             const childKey = childrenKeys[i];
             const childFieldDefinition = children[childKey];
@@ -19114,7 +19122,7 @@
      */
     function createPathSelectionFromValue(fields) {
         const fieldsSelection = [];
-        const fieldNames = keys$8(fields);
+        const fieldNames = keys$9(fields);
         for (let i = 0, len = fieldNames.length; i < len; i++) {
             const fieldName = fieldNames[i];
             const { value: fieldValue } = fields[fieldName];
@@ -19153,7 +19161,7 @@
     }
     function extractRecordFieldsRecursively(record) {
         const fields = [];
-        const fieldNames = keys$8(record.fields);
+        const fieldNames = keys$9(record.fields);
         for (let i = 0, len = fieldNames.length; i < len; i++) {
             const fieldName = fieldNames[i];
             const { value: fieldValue } = record.fields[fieldName];
@@ -19341,7 +19349,7 @@
                         continue;
                     }
                     extractTrackedFieldsToTrie(spanningLink.data.__ref, spanning, next, config, spanningVisitedRecordIds, depth + 1);
-                    if (keys$8(next.children).length > 0) {
+                    if (keys$9(next.children).length > 0) {
                         current.children[key] = next;
                     }
                     else {
@@ -19393,13 +19401,13 @@
         return endsWith.call(spanningNode.scalar('apiName'), CUSTOM_EXTERNAL_OBJECT_FIELD_SUFFIX);
     }
     function convertTrieToFields(root) {
-        if (keys$8(root.children).length === 0) {
+        if (keys$9(root.children).length === 0) {
             return [];
         }
         return convertTrieToFieldsRecursively(root);
     }
     function convertTrieToFieldsRecursively(root) {
-        const childKeys = keys$8(root.children);
+        const childKeys = keys$9(root.children);
         if (childKeys.length === 0) {
             if (root.name === '') {
                 return [];
@@ -19436,7 +19444,7 @@
     function mergeFieldsTries(rootA, rootB) {
         const rootAchildren = rootA.children;
         const rootBchildren = rootB.children;
-        const childBKeys = keys$8(rootBchildren);
+        const childBKeys = keys$9(rootBchildren);
         for (let i = 0, len = childBKeys.length; i < len; i++) {
             const childBKey = childBKeys[i];
             if (rootAchildren[childBKey] === undefined) {
@@ -19589,8 +19597,8 @@
         }
         const childrenA = a.children;
         const childrenB = b.children;
-        const childKeysA = keys$8(childrenA);
-        const childKeysB = keys$8(childrenB);
+        const childKeysA = keys$9(childrenA);
+        const childKeysB = keys$9(childrenB);
         const childKeysBLength = childKeysB.length;
         if (childKeysBLength > childKeysA.length) {
             return false;
@@ -19614,7 +19622,7 @@
         // RecordRepresentationNormalized['fields'] to include `pending:true` property
         const mergedFields = { ...newRecord.fields };
         const merged = { ...newRecord, fields: mergedFields };
-        const existingFields = keys$8(oldRecord.fields);
+        const existingFields = keys$9(oldRecord.fields);
         for (let i = 0, len = existingFields.length; i < len; i += 1) {
             const spanningFieldName = existingFields[i];
             if (newRecord.fields[spanningFieldName] === undefined) {
@@ -19747,7 +19755,7 @@
             if (isGraphNode(node)) {
                 const dependencies = node.retrieve();
                 if (dependencies !== null) {
-                    const depKeys = keys$8(dependencies);
+                    const depKeys = keys$9(dependencies);
                     for (let i = 0, len = depKeys.length; i < len; i++) {
                         luvio.storeEvict(depKeys[i]);
                     }
@@ -19894,7 +19902,7 @@
         }
         for (let i = 0; i < fieldSubtries.length; i++) {
             const subtrie = fieldSubtries[i];
-            const fieldNames = keys$8(subtrie.children);
+            const fieldNames = keys$9(subtrie.children);
             for (let i = 0; i < fieldNames.length; i++) {
                 const fieldName = fieldNames[i];
                 const childTrie = subtrie.children[fieldName];
@@ -20006,9 +20014,9 @@
                 return false;
             }
         }
-        const headersKeys = keys$8(headers);
+        const headersKeys = keys$9(headers);
         const headersKeyLength = headersKeys.length;
-        if (headersKeyLength !== keys$8(existingHeaders).length) {
+        if (headersKeyLength !== keys$9(existingHeaders).length) {
             return false;
         }
         for (let i = 0, len = headersKeyLength; i < len; i++) {
@@ -20780,7 +20788,7 @@
 
     // iterate through the map to build configs for network calls
     function resolveConflict(luvio, map) {
-        const ids = keys$8(map.conflicts);
+        const ids = keys$9(map.conflicts);
         if (ids.length === 0) {
             instrumentation$2.recordConflictsResolved(map.serverRequestCount);
             return;
@@ -21962,18 +21970,18 @@
         return {
             getRecordSelectionFieldSets() {
                 const optionalPlusDefaultFields = { ...optionalFields_ };
-                const fields = keys$8(defaultFields_);
+                const fields = keys$9(defaultFields_);
                 for (let i = 0; i < fields.length; ++i) {
                     const field = fields[i];
                     if (!fields_[field] && !defaultServerFieldStatus.missingFields[field]) {
                         optionalPlusDefaultFields[field] = true;
                     }
                 }
-                return [keys$8(fields_).sort(), keys$8(optionalPlusDefaultFields).sort()];
+                return [keys$9(fields_).sort(), keys$9(optionalPlusDefaultFields).sort()];
             },
             processRecords(records) {
                 const { missingFields } = defaultServerFieldStatus;
-                const fields = keys$8(missingFields);
+                const fields = keys$9(missingFields);
                 for (let i = 0; i < fields.length; ++i) {
                     const field = fields[i], splitField = field.split('.').slice(1);
                     for (let i = 0; i < records.length; ++i) {
@@ -22799,7 +22807,7 @@
             config,
             resolve: () => buildNetworkSnapshot$U(luvio, config, snapshotRefreshOptions$1)
         });
-        if (isUnfulfilledSnapshot$1(cacheSnapshot) && cacheSnapshot.data !== undefined) {
+        if (isUnfulfilledSnapshot$1$1(cacheSnapshot) && cacheSnapshot.data !== undefined) {
             context.cacheSnapshot = cacheSnapshot;
         }
         return cacheSnapshot;
@@ -23685,39 +23693,39 @@
             return null;
         }, { contextId: contextId$4 });
     };
-    function deepFreeze$H(input) {
+    function deepFreeze$I(input) {
         const input_junctionIdListNames = input.junctionIdListNames;
         ObjectFreeze$2(input_junctionIdListNames);
         const input_junctionReferenceTo = input.junctionReferenceTo;
         ObjectFreeze$2(input_junctionReferenceTo);
         ObjectFreeze$2(input);
     }
-    function deepFreeze$G(input) {
+    function deepFreeze$H(input) {
         const input_controllingFields = input.controllingFields;
         ObjectFreeze$2(input_controllingFields);
         ObjectFreeze$2(input);
     }
-    function deepFreeze$F(input) {
+    function deepFreeze$G(input) {
         const input_nameFields = input.nameFields;
         ObjectFreeze$2(input_nameFields);
         ObjectFreeze$2(input);
     }
-    function deepFreeze$E(input) {
+    function deepFreeze$F(input) {
         const input_controllingFields = input.controllingFields;
         ObjectFreeze$2(input_controllingFields);
         const input_filteredLookupInfo = input.filteredLookupInfo;
         if (input_filteredLookupInfo !== null && typeof input_filteredLookupInfo === 'object') {
-            deepFreeze$G(input_filteredLookupInfo);
+            deepFreeze$H(input_filteredLookupInfo);
         }
         const input_referenceToInfos = input.referenceToInfos;
         for (let i = 0; i < input_referenceToInfos.length; i++) {
             const input_referenceToInfos_item = input_referenceToInfos[i];
-            deepFreeze$F(input_referenceToInfos_item);
+            deepFreeze$G(input_referenceToInfos_item);
         }
         ObjectFreeze$2(input_referenceToInfos);
         ObjectFreeze$2(input);
     }
-    function deepFreeze$D(input) {
+    function deepFreeze$E(input) {
         ObjectFreeze$2(input);
     }
 
@@ -23847,11 +23855,11 @@
         }
         return true;
     }
-    function deepFreeze$C(input) {
+    function deepFreeze$D(input) {
         const input_childRelationships = input.childRelationships;
         for (let i = 0; i < input_childRelationships.length; i++) {
             const input_childRelationships_item = input_childRelationships[i];
-            deepFreeze$H(input_childRelationships_item);
+            deepFreeze$I(input_childRelationships_item);
         }
         ObjectFreeze$2(input_childRelationships);
         const input_dependentFields = input.dependentFields;
@@ -23869,7 +23877,7 @@
         for (let i = 0; i < input_fields_length; i++) {
             const key = input_fields_keys[i];
             const input_fields_prop = input_fields[key];
-            deepFreeze$E(input_fields_prop);
+            deepFreeze$F(input_fields_prop);
         }
         ObjectFreeze$2(input_fields);
         const input_nameFields = input.nameFields;
@@ -23880,12 +23888,12 @@
         for (let i = 0; i < input_recordTypeInfos_length; i++) {
             const key = input_recordTypeInfos_keys[i];
             const input_recordTypeInfos_prop = input_recordTypeInfos[key];
-            deepFreeze$L(input_recordTypeInfos_prop);
+            deepFreeze$M(input_recordTypeInfos_prop);
         }
         ObjectFreeze$2(input_recordTypeInfos);
         const input_themeInfo = input.themeInfo;
         if (input_themeInfo !== null && typeof input_themeInfo === 'object') {
-            deepFreeze$D(input_themeInfo);
+            deepFreeze$E(input_themeInfo);
         }
         ObjectFreeze$2(input);
     }
@@ -23899,7 +23907,7 @@
             propertyName: path.propertyName,
             ttl: ttlToUse
         });
-        deepFreeze$C(input);
+        deepFreeze$D(input);
         if (existingRecord === undefined || equals$N(existingRecord, incomingRecord) === false) {
             luvio.storePublish(key, incomingRecord);
         }
@@ -24088,7 +24096,7 @@
         return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
         buildCachedSnapshotCachePolicy$H, buildNetworkSnapshotCachePolicy$I);
     };
-    function deepFreeze$B(input) {
+    function deepFreeze$C(input) {
         ObjectFreeze$2(input);
     }
 
@@ -24101,32 +24109,32 @@
         DiscriminatorValues["Field"] = "Field";
         DiscriminatorValues["CustomLink"] = "CustomLink";
     })(DiscriminatorValues$4 || (DiscriminatorValues$4 = {}));
-    function deepFreeze$A(input) {
+    function deepFreeze$B(input) {
         ObjectFreeze$2(input);
     }
-    function deepFreeze$z(input) {
+    function deepFreeze$A(input) {
         const input_layoutComponents = input.layoutComponents;
         for (let i = 0; i < input_layoutComponents.length; i++) {
             const input_layoutComponents_item = input_layoutComponents[i];
-            deepFreeze$A(input_layoutComponents_item);
+            deepFreeze$B(input_layoutComponents_item);
         }
         ObjectFreeze$2(input_layoutComponents);
         ObjectFreeze$2(input);
     }
-    function deepFreeze$y(input) {
+    function deepFreeze$z(input) {
         const input_layoutItems = input.layoutItems;
         for (let i = 0; i < input_layoutItems.length; i++) {
             const input_layoutItems_item = input_layoutItems[i];
-            deepFreeze$z(input_layoutItems_item);
+            deepFreeze$A(input_layoutItems_item);
         }
         ObjectFreeze$2(input_layoutItems);
         ObjectFreeze$2(input);
     }
-    function deepFreeze$x(input) {
+    function deepFreeze$y(input) {
         const input_layoutRows = input.layoutRows;
         for (let i = 0; i < input_layoutRows.length; i++) {
             const input_layoutRows_item = input_layoutRows[i];
-            deepFreeze$y(input_layoutRows_item);
+            deepFreeze$z(input_layoutRows_item);
         }
         ObjectFreeze$2(input_layoutRows);
         ObjectFreeze$2(input);
@@ -24197,17 +24205,17 @@
         }
         return true;
     }
-    function deepFreeze$w(input) {
+    function deepFreeze$x(input) {
         const input_saveOptions = input.saveOptions;
         for (let i = 0; i < input_saveOptions.length; i++) {
             const input_saveOptions_item = input_saveOptions[i];
-            deepFreeze$B(input_saveOptions_item);
+            deepFreeze$C(input_saveOptions_item);
         }
         ObjectFreeze$2(input_saveOptions);
         const input_sections = input.sections;
         for (let i = 0; i < input_sections.length; i++) {
             const input_sections_item = input_sections[i];
-            deepFreeze$x(input_sections_item);
+            deepFreeze$y(input_sections_item);
         }
         ObjectFreeze$2(input_sections);
         ObjectFreeze$2(input);
@@ -24222,7 +24230,7 @@
             propertyName: path.propertyName,
             ttl: ttlToUse
         });
-        deepFreeze$w(input);
+        deepFreeze$x(input);
         if (existingRecord === undefined || equals$M(existingRecord, incomingRecord) === false) {
             luvio.storePublish(key, incomingRecord);
         }
@@ -24248,7 +24256,7 @@
         });
         return rootKeySet;
     }
-    function deepFreeze$v(input) {
+    function deepFreeze$w(input) {
         ObjectFreeze$2(input);
     }
 
@@ -24299,14 +24307,14 @@
         }
         return true;
     }
-    function deepFreeze$u(input) {
+    function deepFreeze$v(input) {
         const input_sectionUserStates = input.sectionUserStates;
         const input_sectionUserStates_keys = Object.keys(input_sectionUserStates);
         const input_sectionUserStates_length = input_sectionUserStates_keys.length;
         for (let i = 0; i < input_sectionUserStates_length; i++) {
             const key = input_sectionUserStates_keys[i];
             const input_sectionUserStates_prop = input_sectionUserStates[key];
-            deepFreeze$v(input_sectionUserStates_prop);
+            deepFreeze$w(input_sectionUserStates_prop);
         }
         ObjectFreeze$2(input_sectionUserStates);
         ObjectFreeze$2(input);
@@ -24321,7 +24329,7 @@
             propertyName: path.propertyName,
             ttl: ttlToUse
         });
-        deepFreeze$u(input);
+        deepFreeze$v(input);
         if (existingRecord === undefined || equals$L(existingRecord, incomingRecord) === false) {
             luvio.storePublish(key, incomingRecord);
         }
@@ -24848,7 +24856,7 @@
         const lookupFields = {};
         const { apiName, fields: recordFields } = record;
         const { fields: objectInfoFields } = objectInfo;
-        const objectInfoFieldNames = keys$8(objectInfoFields);
+        const objectInfoFieldNames = keys$9(objectInfoFields);
         for (let i = 0, len = objectInfoFieldNames.length; i < len; i += 1) {
             const fieldName = objectInfoFieldNames[i];
             const field = objectInfoFields[fieldName];
@@ -24867,12 +24875,12 @@
             const nameField = `${apiName}.${relationshipName}.${getNameField(objectInfo, fieldName)}`;
             lookupFields[nameField] = true;
         }
-        return keys$8(lookupFields);
+        return keys$9(lookupFields);
     }
     function getRecordUiMissingRecordLookupFields(recordUi) {
         const { records, objectInfos } = recordUi;
         const recordLookupFields = {};
-        const recordIds = keys$8(records);
+        const recordIds = keys$9(records);
         for (let i = 0, len = recordIds.length; i < len; i += 1) {
             const recordId = recordIds[i];
             const recordData = records[recordId];
@@ -24910,19 +24918,19 @@
     }
     function eachLayout(recordUi, cb) {
         const { layouts } = recordUi;
-        const layoutApiNames = keys$8(layouts);
+        const layoutApiNames = keys$9(layouts);
         for (let a = 0, len = layoutApiNames.length; a < len; a += 1) {
             const apiName = layoutApiNames[a];
             const apiNameData = layouts[apiName];
-            const recordTypeIds = keys$8(apiNameData);
+            const recordTypeIds = keys$9(apiNameData);
             for (let b = 0, recordTypeIdsLen = recordTypeIds.length; b < recordTypeIdsLen; b += 1) {
                 const recordTypeId = recordTypeIds[b];
                 const recordTypeData = apiNameData[recordTypeId];
-                const layoutTypes = keys$8(recordTypeData);
+                const layoutTypes = keys$9(recordTypeData);
                 for (let c = 0, layoutTypesLen = layoutTypes.length; c < layoutTypesLen; c += 1) {
                     const layoutType = layoutTypes[c];
                     const layoutTypeData = recordTypeData[layoutType];
-                    const modes = keys$8(layoutTypeData);
+                    const modes = keys$9(layoutTypeData);
                     for (let d = 0, modesLen = modes.length; d < modesLen; d += 1) {
                         const mode = modes[d];
                         const layout = layoutTypeData[mode];
@@ -25133,7 +25141,7 @@
             const node = luvio.getNode(recordDepKey);
             if (isGraphNode(node)) {
                 const recordDeps = node.retrieve();
-                assign$6(dependencies, recordDeps);
+                assign$7(dependencies, recordDeps);
             }
             luvio.storePublish(recordDepKey, dependencies);
         }
@@ -25301,11 +25309,11 @@
     ];
     function getFieldsFromLayoutMap(layoutMap, objectInfo) {
         let fields = [];
-        const layoutTypes = keys$8(layoutMap);
+        const layoutTypes = keys$9(layoutMap);
         for (let i = 0, layoutTypesLen = layoutTypes.length; i < layoutTypesLen; i += 1) {
             const layoutType = layoutTypes[i];
             const modesMap = layoutMap[layoutType];
-            const modes = keys$8(modesMap);
+            const modes = keys$9(modesMap);
             for (let m = 0, modesLen = modes.length; m < modesLen; m += 1) {
                 const mode = modes[m];
                 const modeKeys = getQualifiedFieldApiNamesFromLayout(modesMap[mode], objectInfo);
@@ -25522,7 +25530,7 @@
                 }
                 const { layoutType, mode, snapshot } = container;
                 if (wrapper.layoutMap[layoutType] === undefined) {
-                    wrapper.layoutMap = assign$6({}, wrapper.layoutMap, {
+                    wrapper.layoutMap = assign$7({}, wrapper.layoutMap, {
                         [layoutType]: {},
                     });
                 }
@@ -25797,6 +25805,49 @@
         return rootKeySet;
     }
 
+    function serializeFieldArguments$1(argumentNodes, variables) {
+        const mutableArgumentNodes = Object.assign([], argumentNodes);
+        return `args__(${mutableArgumentNodes.sort((a, b) => {
+        const aName = a.name.value.toUpperCase();
+        const bName = b.name.value.toUpperCase();
+        return aName < bName ? -1 : (aName > bName) ? 1 : 0;
+    }).map(node => serializeArgNode$1(node, variables)).join("::")})`;
+    }
+    function serializeArgNode$1(argumentNode, variables) {
+        const argName = argumentNode.name.value;
+        return `${argName}:${serializeValueNode$2(argumentNode.value, variables)}`;
+    }
+    function serializeValueNode$2(valueNode, variables) {
+        switch (valueNode.kind) {
+            case ("BooleanValue"):
+                return valueNode.value + '';
+            case ("IntValue"):
+            case ("FloatValue"):
+            case ("EnumValue"):
+            case ("StringValue"):
+                return valueNode.value;
+            case ("ListValue"):
+                const mutableValueNodeList = Object.assign([], valueNode.values);
+                return mutableValueNodeList.sort((a, b) => {
+                    const aVal = serializeValueNode$2(a, variables).toUpperCase();
+                    const bVal = serializeValueNode$2(b, variables).toUpperCase();
+                    return aVal < bVal ? -1 : (aVal > bVal) ? 1 : 0;
+                }).map((val, i) => serializeValueNode$2(val, variables) + `[${i}]`).join(',');
+            case ("Variable"):
+                const variableValue = variables[valueNode.name.value];
+                return typeof variableValue === "string" ? variableValue : JSON.stringify(variableValue);
+            case ("NullValue"):
+                return "null";
+            case ("ObjectValue"):
+                const mutableFieldNodeList = Object.assign([], valueNode.fields);
+                return mutableFieldNodeList.sort((a, b) => {
+                    const aName = a.name.value.toUpperCase();
+                    const bName = b.name.value.toUpperCase();
+                    return aName < bName ? -1 : (aName > bName) ? 1 : 0;
+                }).map(field => field.name.value + ":" + serializeValueNode$2(field.value, variables)).join(',');
+        }
+    }
+
     const VERSION$V = "3f49d751896cf66e6e29788d8880e2cc";
     const RepresentationType$D = 'PlatformActionRepresentation';
     function keyBuilder$1y(luvio, config) {
@@ -26533,9 +26584,9 @@
         }
         return true;
     }
-    function deepFreeze$t(input) {
+    function deepFreeze$u(input) {
         const input_layout = input.layout;
-        deepFreeze$w(input_layout);
+        deepFreeze$x(input_layout);
         ObjectFreeze$2(input);
     }
     const ingest$t$1 = function QuickActionLayoutRepresentationIngest(input, path, luvio, store, timestamp) {
@@ -26548,7 +26599,7 @@
             propertyName: path.propertyName,
             ttl: ttlToUse
         });
-        deepFreeze$t(input);
+        deepFreeze$u(input);
         if (existingRecord === undefined || equals$F(existingRecord, incomingRecord) === false) {
             luvio.storePublish(key, incomingRecord);
         }
@@ -27191,7 +27242,7 @@
         }
         return true;
     }
-    function deepFreeze$s(input) {
+    function deepFreeze$t(input) {
         const input_records = input.records;
         ObjectFreeze$2(input_records);
         ObjectFreeze$2(input);
@@ -27206,7 +27257,7 @@
             propertyName: path.propertyName,
             ttl: ttlToUse
         });
-        deepFreeze$s(input);
+        deepFreeze$t(input);
         if (existingRecord === undefined || equals$E(existingRecord, incomingRecord) === false) {
             luvio.storePublish(key, incomingRecord);
         }
@@ -28232,7 +28283,7 @@
         buildCachedSnapshotCachePolicy$z, buildNetworkSnapshotCachePolicy$A);
     };
 
-    function validate$10(obj, path = 'ActionRelatedListSingleBatchInputRepresentation') {
+    function validate$11(obj, path = 'ActionRelatedListSingleBatchInputRepresentation') {
         const v_error = (() => {
             if (typeof obj !== 'object' || ArrayIsArray$2(obj) || obj === null) {
                 return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -28623,7 +28674,7 @@
             const untrustedConfig_relatedListsActionParameters_array = [];
             for (let i = 0, arrayLength = untrustedConfig_relatedListsActionParameters.length; i < arrayLength; i++) {
                 const untrustedConfig_relatedListsActionParameters_item = untrustedConfig_relatedListsActionParameters[i];
-                const referenceActionRelatedListSingleBatchInputRepresentationValidationError = validate$10(untrustedConfig_relatedListsActionParameters_item);
+                const referenceActionRelatedListSingleBatchInputRepresentationValidationError = validate$11(untrustedConfig_relatedListsActionParameters_item);
                 if (referenceActionRelatedListSingleBatchInputRepresentationValidationError === null) {
                     untrustedConfig_relatedListsActionParameters_array.push(untrustedConfig_relatedListsActionParameters_item);
                 }
@@ -29158,14 +29209,14 @@
         }
         return true;
     }
-    function deepFreeze$r(input) {
+    function deepFreeze$s(input) {
         const input_attributes = input.attributes;
         const input_attributes_keys = Object.keys(input_attributes);
         const input_attributes_length = input_attributes_keys.length;
         for (let i = 0; i < input_attributes_length; i++) {
             const key = input_attributes_keys[i];
             const input_attributes_prop = input_attributes[key];
-            deepFreeze$P(input_attributes_prop);
+            deepFreeze$Q(input_attributes_prop);
         }
         ObjectFreeze$2(input_attributes);
         const input_state = input.state;
@@ -29189,7 +29240,7 @@
             propertyName: path.propertyName,
             ttl: ttlToUse
         });
-        deepFreeze$r(input);
+        deepFreeze$s(input);
         if (existingRecord === undefined || equals$C(existingRecord, incomingRecord) === false) {
             luvio.storePublish(key, incomingRecord);
         }
@@ -32952,24 +33003,24 @@
         return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
         buildCachedSnapshotCachePolicy$l, buildNetworkSnapshotCachePolicy$m);
     };
-    function deepFreeze$q(input) {
+    function deepFreeze$r(input) {
         const input_recordIds = input.recordIds;
         ObjectFreeze$2(input_recordIds);
         ObjectFreeze$2(input);
     }
-    function deepFreeze$p(input) {
+    function deepFreeze$q(input) {
         const input_matchResultInfo = input.matchResultInfo;
-        deepFreeze$q(input_matchResultInfo);
+        deepFreeze$r(input_matchResultInfo);
         ObjectFreeze$2(input);
     }
-    function deepFreeze$o(input) {
+    function deepFreeze$p(input) {
         const input_duplicateResultInfos = input.duplicateResultInfos;
         const input_duplicateResultInfos_keys = Object.keys(input_duplicateResultInfos);
         const input_duplicateResultInfos_length = input_duplicateResultInfos_keys.length;
         for (let i = 0; i < input_duplicateResultInfos_length; i++) {
             const key = input_duplicateResultInfos_keys[i];
             const input_duplicateResultInfos_prop = input_duplicateResultInfos[key];
-            deepFreeze$p(input_duplicateResultInfos_prop);
+            deepFreeze$q(input_duplicateResultInfos_prop);
         }
         ObjectFreeze$2(input_duplicateResultInfos);
         const input_recordIds = input.recordIds;
@@ -32997,13 +33048,13 @@
         }
         return true;
     }
-    function deepFreeze$n(input) {
+    function deepFreeze$o(input) {
         const input_duplicateRules = input.duplicateRules;
         ObjectFreeze$2(input_duplicateRules);
         const input_matches = input.matches;
         for (let i = 0; i < input_matches.length; i++) {
             const input_matches_item = input_matches[i];
-            deepFreeze$o(input_matches_item);
+            deepFreeze$p(input_matches_item);
         }
         ObjectFreeze$2(input_matches);
         ObjectFreeze$2(input);
@@ -33018,7 +33069,7 @@
             propertyName: path.propertyName,
             ttl: ttlToUse
         });
-        deepFreeze$n(input);
+        deepFreeze$o(input);
         if (existingRecord === undefined || equals$u(existingRecord, incomingRecord) === false) {
             luvio.storePublish(key, incomingRecord);
         }
@@ -34363,7 +34414,7 @@
                 }
             }
             if (records.length > 0) {
-                assign$6(config, { records });
+                assign$7(config, { records });
             }
         }
         return config;
@@ -34534,7 +34585,7 @@
         }
         return true;
     }
-    function deepFreeze$m(input) {
+    function deepFreeze$n(input) {
         ObjectFreeze$2(input);
     }
 
@@ -35197,7 +35248,7 @@
         return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
         buildCachedSnapshotCachePolicy$g, buildNetworkSnapshotCachePolicy$h);
     };
-    function deepFreeze$l(input) {
+    function deepFreeze$m(input) {
         const input_picklistValues = input.picklistValues;
         for (let i = 0; i < input_picklistValues.length; i++) {
             const input_picklistValues_item = input_picklistValues[i];
@@ -35333,11 +35384,11 @@
         }
         return true;
     }
-    function deepFreeze$k(input) {
+    function deepFreeze$l(input) {
         const input_displayColumns = input.displayColumns;
         for (let i = 0; i < input_displayColumns.length; i++) {
             const input_displayColumns_item = input_displayColumns[i];
-            deepFreeze$l(input_displayColumns_item);
+            deepFreeze$m(input_displayColumns_item);
         }
         ObjectFreeze$2(input_displayColumns);
         const input_fields = input.fields;
@@ -35345,11 +35396,11 @@
         const input_filteredByInfo = input.filteredByInfo;
         for (let i = 0; i < input_filteredByInfo.length; i++) {
             const input_filteredByInfo_item = input_filteredByInfo[i];
-            deepFreeze$O(input_filteredByInfo_item);
+            deepFreeze$P(input_filteredByInfo_item);
         }
         ObjectFreeze$2(input_filteredByInfo);
         const input_listReference = input.listReference;
-        deepFreeze$m(input_listReference);
+        deepFreeze$n(input_listReference);
         const input_objectApiNames = input.objectApiNames;
         ObjectFreeze$2(input_objectApiNames);
         const input_optionalFields = input.optionalFields;
@@ -35357,11 +35408,11 @@
         const input_orderedByInfo = input.orderedByInfo;
         for (let i = 0; i < input_orderedByInfo.length; i++) {
             const input_orderedByInfo_item = input_orderedByInfo[i];
-            deepFreeze$N(input_orderedByInfo_item);
+            deepFreeze$O(input_orderedByInfo_item);
         }
         ObjectFreeze$2(input_orderedByInfo);
         const input_userPreferences = input.userPreferences;
-        deepFreeze$M(input_userPreferences);
+        deepFreeze$N(input_userPreferences);
         ObjectFreeze$2(input);
     }
     const ingest$b$1 = function RelatedListInfoRepresentationIngest(input, path, luvio, store, timestamp) {
@@ -35374,7 +35425,7 @@
             propertyName: path.propertyName,
             ttl: ttlToUse
         });
-        deepFreeze$k(input);
+        deepFreeze$l(input);
         if (existingRecord === undefined || equals$h(existingRecord, incomingRecord) === false) {
             luvio.storePublish(key, incomingRecord);
         }
@@ -35859,10 +35910,10 @@
         return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
         buildCachedSnapshotCachePolicy$f, buildNetworkSnapshotCachePolicy$g);
     };
-    function deepFreeze$j(input) {
+    function deepFreeze$k(input) {
         const input_themeInfo = input.themeInfo;
         if (input_themeInfo !== null && typeof input_themeInfo === 'object') {
-            deepFreeze$D(input_themeInfo);
+            deepFreeze$E(input_themeInfo);
         }
         ObjectFreeze$2(input);
     }
@@ -35912,11 +35963,11 @@
         }
         return true;
     }
-    function deepFreeze$i(input) {
+    function deepFreeze$j(input) {
         const input_relatedLists = input.relatedLists;
         for (let i = 0; i < input_relatedLists.length; i++) {
             const input_relatedLists_item = input_relatedLists[i];
-            deepFreeze$j(input_relatedLists_item);
+            deepFreeze$k(input_relatedLists_item);
         }
         ObjectFreeze$2(input_relatedLists);
         ObjectFreeze$2(input);
@@ -35931,7 +35982,7 @@
             propertyName: path.propertyName,
             ttl: ttlToUse
         });
-        deepFreeze$i(input);
+        deepFreeze$j(input);
         if (existingRecord === undefined || equals$g(existingRecord, incomingRecord) === false) {
             luvio.storePublish(key, incomingRecord);
         }
@@ -36299,7 +36350,7 @@
         buildCachedSnapshotCachePolicy$d, buildNetworkSnapshotCachePolicy$e);
     };
 
-    function validate$t(obj, path = 'ListOrderedByInfoInputRepresentation') {
+    function validate$u(obj, path = 'ListOrderedByInfoInputRepresentation') {
         const v_error = (() => {
             if (typeof obj !== 'object' || ArrayIsArray$2(obj) || obj === null) {
                 return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -36318,7 +36369,7 @@
         return v_error === undefined ? null : v_error;
     }
 
-    function validate$s(obj, path = 'ListUserPreferenceInputRepresentation') {
+    function validate$t(obj, path = 'ListUserPreferenceInputRepresentation') {
         const v_error = (() => {
             if (typeof obj !== 'object' || ArrayIsArray$2(obj) || obj === null) {
                 return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -36450,7 +36501,7 @@
             const untrustedConfig_orderedByInfo_array = [];
             for (let i = 0, arrayLength = untrustedConfig_orderedByInfo.length; i < arrayLength; i++) {
                 const untrustedConfig_orderedByInfo_item = untrustedConfig_orderedByInfo[i];
-                const referenceListOrderedByInfoInputRepresentationValidationError = validate$t(untrustedConfig_orderedByInfo_item);
+                const referenceListOrderedByInfoInputRepresentationValidationError = validate$u(untrustedConfig_orderedByInfo_item);
                 if (referenceListOrderedByInfoInputRepresentationValidationError === null) {
                     untrustedConfig_orderedByInfo_array.push(untrustedConfig_orderedByInfo_item);
                 }
@@ -36458,7 +36509,7 @@
             config.orderedByInfo = untrustedConfig_orderedByInfo_array;
         }
         const untrustedConfig_userPreferences = untrustedConfig.userPreferences;
-        const referenceListUserPreferenceInputRepresentationValidationError = validate$s(untrustedConfig_userPreferences);
+        const referenceListUserPreferenceInputRepresentationValidationError = validate$t(untrustedConfig_userPreferences);
         if (referenceListUserPreferenceInputRepresentationValidationError === null) {
             config.userPreferences = untrustedConfig_userPreferences;
         }
@@ -36485,7 +36536,7 @@
                 return luvio.storeBroadcast().then(() => snapshot);
             }, () => getResponseCacheKeys$k(luvio, resourceParams, response.body));
         }, (response) => {
-            deepFreeze$P(response);
+            deepFreeze$Q(response);
             throw response;
         });
     }
@@ -36529,7 +36580,7 @@
         }
         return true;
     }
-    function deepFreeze$h(input) {
+    function deepFreeze$i(input) {
         const input_columnWidths = input.columnWidths;
         const input_columnWidths_keys = Object.keys(input_columnWidths);
         const input_columnWidths_length = input_columnWidths_keys.length;
@@ -36547,7 +36598,7 @@
         const input_orderedBy = input.orderedBy;
         for (let i = 0; i < input_orderedBy.length; i++) {
             const input_orderedBy_item = input_orderedBy[i];
-            deepFreeze$N(input_orderedBy_item);
+            deepFreeze$O(input_orderedBy_item);
         }
         ObjectFreeze$2(input_orderedBy);
         ObjectFreeze$2(input);
@@ -36562,7 +36613,7 @@
             propertyName: path.propertyName,
             ttl: ttlToUse
         });
-        deepFreeze$h(input);
+        deepFreeze$i(input);
         if (existingRecord === undefined || equals$f(existingRecord, incomingRecord) === false) {
             luvio.storePublish(key, incomingRecord);
         }
@@ -37214,7 +37265,7 @@
             const untrustedConfig_orderedBy_array = [];
             for (let i = 0, arrayLength = untrustedConfig_orderedBy.length; i < arrayLength; i++) {
                 const untrustedConfig_orderedBy_item = untrustedConfig_orderedBy[i];
-                const referenceListOrderedByInfoInputRepresentationValidationError = validate$t(untrustedConfig_orderedBy_item);
+                const referenceListOrderedByInfoInputRepresentationValidationError = validate$u(untrustedConfig_orderedBy_item);
                 if (referenceListOrderedByInfoInputRepresentationValidationError === null) {
                     untrustedConfig_orderedBy_array.push(untrustedConfig_orderedBy_item);
                 }
@@ -37243,7 +37294,7 @@
                 return luvio.storeBroadcast().then(() => snapshot);
             }, () => getResponseCacheKeys$h(luvio, resourceParams, response.body));
         }, (response) => {
-            deepFreeze$P(response);
+            deepFreeze$Q(response);
             throw response;
         });
     }
@@ -37258,7 +37309,7 @@
         };
     };
 
-    function validate$q(obj, path = 'RelatedListRecordsSingleBatchInputRepresentation') {
+    function validate$r(obj, path = 'RelatedListRecordsSingleBatchInputRepresentation') {
         const v_error = (() => {
             if (typeof obj !== 'object' || ArrayIsArray$2(obj) || obj === null) {
                 return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
@@ -38232,7 +38283,7 @@
             const untrustedConfig_relatedListParameters_array = [];
             for (let i = 0, arrayLength = untrustedConfig_relatedListParameters.length; i < arrayLength; i++) {
                 const untrustedConfig_relatedListParameters_item = untrustedConfig_relatedListParameters[i];
-                const referenceRelatedListRecordsSingleBatchInputRepresentationValidationError = validate$q(untrustedConfig_relatedListParameters_item);
+                const referenceRelatedListRecordsSingleBatchInputRepresentationValidationError = validate$r(untrustedConfig_relatedListParameters_item);
                 if (referenceRelatedListRecordsSingleBatchInputRepresentationValidationError === null) {
                     untrustedConfig_relatedListParameters_array.push(untrustedConfig_relatedListParameters_item);
                 }
@@ -38545,7 +38596,7 @@
             config,
             resolve: () => buildNetworkSnapshot$h(luvio, config, snapshotRefreshOptions$1)
         });
-        if (isUnfulfilledSnapshot$1(cacheSnapshot) && cacheSnapshot.data !== undefined) {
+        if (isUnfulfilledSnapshot$1$1(cacheSnapshot) && cacheSnapshot.data !== undefined) {
             context.cacheSnapshot = cacheSnapshot;
         }
         return cacheSnapshot;
@@ -38578,7 +38629,7 @@
             ]
         };
     };
-    function deepFreeze$g(input) {
+    function deepFreeze$h(input) {
         ObjectFreeze$2(input);
     }
 
@@ -39015,11 +39066,11 @@
         }
         return true;
     }
-    function deepFreeze$f(input) {
+    function deepFreeze$g(input) {
         const input_options = input.options;
         for (let i = 0; i < input_options.length; i++) {
             const input_options_item = input_options[i];
-            deepFreeze$g(input_options_item);
+            deepFreeze$h(input_options_item);
         }
         ObjectFreeze$2(input_options);
         ObjectFreeze$2(input);
@@ -39034,7 +39085,7 @@
             propertyName: path.propertyName,
             ttl: ttlToUse
         });
-        deepFreeze$f(input);
+        deepFreeze$g(input);
         if (existingRecord === undefined || equals$a(existingRecord, incomingRecord) === false) {
             luvio.storePublish(key, incomingRecord);
         }
@@ -39227,28 +39278,28 @@
         return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
         buildCachedSnapshotCachePolicy$7, buildNetworkSnapshotCachePolicy$8);
     };
-    function deepFreeze$e(input) {
+    function deepFreeze$f(input) {
         const input_displayFields = input.displayFields;
         ObjectFreeze$2(input_displayFields);
         ObjectFreeze$2(input);
     }
-    function deepFreeze$d(input) {
+    function deepFreeze$e(input) {
         const input_matchingFields = input.matchingFields;
         ObjectFreeze$2(input_matchingFields);
         ObjectFreeze$2(input);
     }
-    function deepFreeze$c(input) {
+    function deepFreeze$d(input) {
         const input_displayLayout = input.displayLayout;
-        deepFreeze$e(input_displayLayout);
+        deepFreeze$f(input_displayLayout);
         const input_matchingInfo = input.matchingInfo;
-        deepFreeze$d(input_matchingInfo);
+        deepFreeze$e(input_matchingInfo);
         ObjectFreeze$2(input);
     }
-    function deepFreeze$b(input) {
+    function deepFreeze$c(input) {
         const input_fullSearchInfo = input.fullSearchInfo;
-        deepFreeze$c(input_fullSearchInfo);
+        deepFreeze$d(input_fullSearchInfo);
         const input_suggestionsInfo = input.suggestionsInfo;
-        deepFreeze$c(input_suggestionsInfo);
+        deepFreeze$d(input_suggestionsInfo);
         ObjectFreeze$2(input);
     }
 
@@ -39282,14 +39333,14 @@
         }
         return true;
     }
-    function deepFreeze$a(input) {
+    function deepFreeze$b(input) {
         const input_targetInfo = input.targetInfo;
         const input_targetInfo_keys = Object.keys(input_targetInfo);
         const input_targetInfo_length = input_targetInfo_keys.length;
         for (let i = 0; i < input_targetInfo_length; i++) {
             const key = input_targetInfo_keys[i];
             const input_targetInfo_prop = input_targetInfo[key];
-            deepFreeze$b(input_targetInfo_prop);
+            deepFreeze$c(input_targetInfo_prop);
         }
         ObjectFreeze$2(input_targetInfo);
         ObjectFreeze$2(input);
@@ -39304,7 +39355,7 @@
             propertyName: path.propertyName,
             ttl: ttlToUse
         });
-        deepFreeze$a(input);
+        deepFreeze$b(input);
         if (existingRecord === undefined || equals$9(existingRecord, incomingRecord) === false) {
             luvio.storePublish(key, incomingRecord);
         }
@@ -39489,11 +39540,11 @@
         return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
         buildCachedSnapshotCachePolicy$6, buildNetworkSnapshotCachePolicy$7);
     };
-    function deepFreeze$9(input) {
+    function deepFreeze$a(input) {
         ObjectFreeze$2(input);
     }
 
-    function deepFreeze$8(input) {
+    function deepFreeze$9(input) {
         const input_fields = input.fields;
         const input_fields_keys = Object.keys(input_fields);
         const input_fields_length = input_fields_keys.length;
@@ -39504,57 +39555,66 @@
         ObjectFreeze$2(input);
     }
 
-    function deepFreeze$7(input) {
+    function deepFreeze$8(input) {
         ObjectFreeze$2(input);
     }
 
-    function deepFreeze$6(input) {
+    function deepFreeze$7(input) {
         const input_highlightInfo = input.highlightInfo;
         if (input_highlightInfo !== undefined) {
-            deepFreeze$8(input_highlightInfo);
+            deepFreeze$9(input_highlightInfo);
         }
         const input_record = input.record;
-        deepFreeze$I(input_record);
+        deepFreeze$J(input_record);
         const input_searchInfo = input.searchInfo;
-        deepFreeze$7(input_searchInfo);
+        deepFreeze$8(input_searchInfo);
         ObjectFreeze$2(input);
     }
-    function deepFreeze$5(input) {
+    function deepFreeze$6(input) {
         const input_error = input.error;
         if (input_error !== null && typeof input_error === 'object') {
-            deepFreeze$9(input_error);
+            deepFreeze$a(input_error);
         }
         const input_orderBy = input.orderBy;
         for (let i = 0; i < input_orderBy.length; i++) {
             const input_orderBy_item = input_orderBy[i];
-            deepFreeze$N(input_orderBy_item);
+            deepFreeze$O(input_orderBy_item);
         }
         ObjectFreeze$2(input_orderBy);
         const input_records = input.records;
         for (let i = 0; i < input_records.length; i++) {
             const input_records_item = input_records[i];
-            deepFreeze$6(input_records_item);
+            deepFreeze$7(input_records_item);
         }
         ObjectFreeze$2(input_records);
         const input_relatedObjectApiNames = input.relatedObjectApiNames;
         ObjectFreeze$2(input_relatedObjectApiNames);
         ObjectFreeze$2(input);
     }
-    function deepFreeze$4(input) {
+    function deepFreeze$5(input) {
         const input_results = input.results;
         for (let i = 0; i < input_results.length; i++) {
             const input_results_item = input_results[i];
-            deepFreeze$5(input_results_item);
+            deepFreeze$6(input_results_item);
         }
         ObjectFreeze$2(input_results);
         ObjectFreeze$2(input);
     }
+    function deepFreeze$4(input) {
+        ObjectFreeze$2(input);
+    }
     function deepFreeze$3(input) {
+        const input_records = input.records;
+        for (let i = 0; i < input_records.length; i++) {
+            const input_records_item = input_records[i];
+            deepFreeze$4(input_records_item);
+        }
+        ObjectFreeze$2(input_records);
         ObjectFreeze$2(input);
     }
 
     const TTL$6 = 200;
-    const VERSION$8$1 = "9760c93d10288bb6889882c757514189";
+    const VERSION$8$1 = "da21e889922062e90012ba48c4a733e2";
     const RepresentationType$9 = 'SearchResultsSummaryRepresentation';
     function keyBuilder$f$1(luvio, config) {
         return keyPrefix$1 + '::' + RepresentationType$9 + ':' + config.query;
@@ -39585,7 +39645,7 @@
     function deepFreeze$2$1(input) {
         const input_keywordSearchResults = input.keywordSearchResults;
         if (input_keywordSearchResults !== null && typeof input_keywordSearchResults === 'object') {
-            deepFreeze$4(input_keywordSearchResults);
+            deepFreeze$5(input_keywordSearchResults);
         }
         const input_qnaResult = input.qnaResult;
         if (input_qnaResult !== null && typeof input_qnaResult === 'object') {
@@ -39914,7 +39974,7 @@
     }
     function deepFreeze$1$1(input) {
         const input_keywordSearchResult = input.keywordSearchResult;
-        deepFreeze$5(input_keywordSearchResult);
+        deepFreeze$6(input_keywordSearchResult);
         ObjectFreeze$2(input);
     }
     const ingest$3$1 = function KeywordSearchResultsSummaryRepresentationIngest(input, path, luvio, store, timestamp) {
@@ -40280,7 +40340,7 @@
                 return luvio.storeBroadcast().then(() => snapshot);
             }, () => getResponseCacheKeys$9(luvio, resourceParams, response.body));
         }, (response) => {
-            deepFreeze$P(response);
+            deepFreeze$Q(response);
             throw response;
         });
     }
@@ -40424,7 +40484,7 @@
                 return luvio.storeBroadcast().then(() => snapshot);
             }, () => getResponseCacheKeys$8(luvio, resourceParams, response.body));
         }, (response) => {
-            deepFreeze$P(response);
+            deepFreeze$Q(response);
             throw response;
         });
     }
@@ -40441,20 +40501,20 @@
 
     const factory$c = performQuickActionAdapterFactory;
 
-    function deepFreeze$Q(value) {
+    function deepFreeze$R(value) {
         // No need to freeze primitives
         if (typeof value !== 'object' || value === null) {
             return;
         }
         if (isArray$8(value)) {
             for (let i = 0, len = value.length; i < len; i += 1) {
-                deepFreeze$Q(value[i]);
+                deepFreeze$R(value[i]);
             }
         }
         else {
-            const keys$1 = keys$8(value);
+            const keys$1 = keys$9(value);
             for (let i = 0, len = keys$1.length; i < len; i += 1) {
-                deepFreeze$Q(value[keys$1[i]]);
+                deepFreeze$R(value[keys$1[i]]);
             }
         }
         freeze$3(value);
@@ -40510,7 +40570,7 @@
             const { body } = response;
             return luvio.handleSuccessResponse(() => ingestAndBroadcast(luvio, key, config, body), () => getTypeCacheKeys$G$1(luvio, body));
         }, (err) => {
-            deepFreeze$Q(err);
+            deepFreeze$R(err);
             throw err;
         });
     }
@@ -40534,7 +40594,7 @@
         let clonedLayoutUserStateSections;
         const { sectionUserStates } = layoutUserStateInput;
         const { sectionUserStates: cachedSectionUserStates } = cachedLayoutUserState;
-        const sectionUserStateKeys = keys$8(sectionUserStates);
+        const sectionUserStateKeys = keys$9(sectionUserStates);
         for (let i = 0, len = sectionUserStateKeys.length; i < len; i += 1) {
             const sectionId = sectionUserStateKeys[i];
             if (cachedSectionUserStates[sectionId] === undefined) {
@@ -40830,7 +40890,7 @@
             config,
             resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions$1)
         });
-        if (isUnfulfilledSnapshot$1(cacheSnapshot) && cacheSnapshot.data !== undefined) {
+        if (isUnfulfilledSnapshot$1$1(cacheSnapshot) && cacheSnapshot.data !== undefined) {
             context.cacheSnapshot = cacheSnapshot;
         }
         return cacheSnapshot;
@@ -41104,7 +41164,7 @@
                     .map((targetApiName) => body.lookupResults[targetApiName].records)
                     .reduce((allRecords, records) => allRecords.concat(records), [])
                     .forEach((record) => removeEtags(record));
-                deepFreeze$Q(body);
+                deepFreeze$R(body);
                 return Promise.resolve({
                     state: 'Fulfilled',
                     recordId: key,
@@ -41274,7 +41334,7 @@
                     return luvio.storeBroadcast().then(() => snapshot);
                 }, () => getTypeCacheKeys$n$1(luvio, body));
             }, (err) => {
-                deepFreeze$Q(err);
+                deepFreeze$R(err);
                 throw err;
             });
         };
@@ -43132,7 +43192,7 @@
         return luvio.dispatchResourceRequest(request).then((response) => {
             return luvio.handleSuccessResponse(() => onResponseSuccess$1(luvio, response, recordIngest, conflictMap), () => getResponseCacheKeys$3(luvio, resourceParams, response.body));
         }, (err) => {
-            deepFreeze$Q(err);
+            deepFreeze$R(err);
             throw err;
         });
     }
@@ -43233,7 +43293,7 @@
                 return luvio.storeBroadcast();
             }, () => getResponseCacheKeys$2$1(luvio, resourceParams));
         }, (response) => {
-            deepFreeze$P(response);
+            deepFreeze$Q(response);
             throw response;
         });
     }
@@ -43467,7 +43527,7 @@
         return luvio.dispatchResourceRequest(request).then((response) => {
             return luvio.handleSuccessResponse(() => onResponseSuccess(luvio, response, recordId, recordIngest, conflictMap), () => getResponseCacheKeys$1$1(luvio, resourceParams, response.body));
         }, (err) => {
-            deepFreeze$Q(err);
+            deepFreeze$R(err);
             throw err;
         });
     }
@@ -43723,7 +43783,7 @@
                 return luvio.storeBroadcast().then(() => snapshot);
             }, () => getResponseCacheKeys$T(luvio, {}, response.body));
         }, (response) => {
-            deepFreeze$P(response);
+            deepFreeze$Q(response);
             throw response;
         });
     }
@@ -43790,7 +43850,7 @@
                 return luvio.storeBroadcast().then(() => snapshot);
             }, () => getResponseCacheKeys$T(luvio, resourceParams, response.body));
         }, (response) => {
-            deepFreeze$P(response);
+            deepFreeze$Q(response);
             throw response;
         });
     }
@@ -44418,7 +44478,7 @@
             dropFunction: instrumentation$2.notifyRecordUpdateAvailableDropped,
         });
     });
-    // version: 1.130.10-b649bb8d1
+    // version: 1.131.0-dev11-734408c01
 
     var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -44444,6 +44504,15 @@
         declarePollableTaskMulti,
     };
 
+    var ldsUseShortUrlGate = {
+        isOpen: function (e) {
+            return e.fallback;
+        },
+        hasError: function () {
+            return !0;
+        },
+    };
+
     var LOCALE = 'en-US';
 
     var CURRENCY = 'USD';
@@ -44481,6 +44550,33 @@
         return pattern;
     }
 
+    var eagerEvalValidAt = {
+        isOpen: function (e) {
+            return e.fallback;
+        },
+        hasError: function () {
+            return !0;
+        },
+    };
+
+    var eagerEvalStaleWhileRevalidate = {
+        isOpen: function (e) {
+            return e.fallback;
+        },
+        hasError: function () {
+            return !0;
+        },
+    };
+
+    var eagerEvalDefaultCachePolicy = {
+        isOpen: function (e) {
+            return e.fallback;
+        },
+        hasError: function () {
+            return !0;
+        },
+    };
+
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
      * All rights reserved.
@@ -44496,7 +44592,7 @@
     const { parse: parse$5, stringify: stringify$5 } = JSON;
     const { join: join$2, push: push$2, unshift } = Array.prototype;
     const { isArray: isArray$6 } = Array;
-    const { entries: entries$3, keys: keys$6 } = Object;
+    const { entries: entries$3, keys: keys$7 } = Object;
 
     const UI_API_BASE_URI = '/services/data/v58.0/ui-api';
 
@@ -44561,7 +44657,7 @@
     function mergeRecordFields$1(first, second) {
         const { fields: targetFields } = first;
         const { fields: sourceFields } = second;
-        const fieldNames = keys$6(sourceFields);
+        const fieldNames = keys$7(sourceFields);
         for (let i = 0, len = fieldNames.length; i < len; i += 1) {
             const fieldName = fieldNames[i];
             const sourceField = sourceFields[fieldName];
@@ -44964,8 +45060,9 @@
         return false;
     }
     const DefaultDurableSegment = 'DEFAULT';
+    const RedirectDurableSegment = 'REDIRECT_KEYS';
 
-    const { keys: keys$5, create: create$5, assign: assign$4, freeze: freeze$1$1 } = Object;
+    const { keys: keys$6, create: create$5, assign: assign$5, freeze: freeze$1$1 } = Object;
     const { isArray: isArray$5 } = Array;
 
     //Durable store error instrumentation key
@@ -45000,7 +45097,7 @@
             }
         }
         else {
-            const keys$1 = keys$5(value);
+            const keys$1 = keys$6(value);
             for (let i = 0, len = keys$1.length; i < len; i += 1) {
                 deepFreeze$2(value[keys$1[i]]);
             }
@@ -45023,13 +45120,13 @@
      * @param pendingWriter the PendingWriter (this is going away soon)
      * @returns
      */
-    function publishDurableStoreEntries(durableRecords, publish, publishMetadata) {
+    function publishDurableStoreEntries(durableRecords, put, publishMetadata) {
         const revivedKeys = new StoreKeySet();
         let hadUnexpectedShape = false;
         if (durableRecords === undefined) {
             return { revivedKeys, hadUnexpectedShape };
         }
-        const durableKeys = keys$5(durableRecords);
+        const durableKeys = keys$6(durableRecords);
         if (durableKeys.length === 0) {
             // no records to revive
             return { revivedKeys, hadUnexpectedShape };
@@ -45061,7 +45158,7 @@
                 // freeze errors on way into L1
                 deepFreeze$2(data.error);
             }
-            publish(key, data);
+            put(key, data);
             revivedKeys.add(key);
         }
         return { revivedKeys, hadUnexpectedShape };
@@ -45101,7 +45198,7 @@
             // TODO [W-10072584]: instead of implicitly using L1 we should take in
             // publish and publishMetadata funcs, so callers can decide where to
             // revive to (like they pass in how to do the buildL1Snapshot)
-            baseEnvironment.storePublish.bind(baseEnvironment), baseEnvironment.publishStoreMetadata.bind(baseEnvironment));
+            baseEnvironment.storePut.bind(baseEnvironment), baseEnvironment.publishStoreMetadata.bind(baseEnvironment));
             // if the data coming back from DS had an unexpected shape then just
             // return the L1 snapshot
             if (hadUnexpectedShape === true) {
@@ -45203,7 +45300,7 @@
                         overrides,
                     };
                 }
-                const keys$1 = keys$5(entries);
+                const keys$1 = keys$6(entries);
                 for (let i = 0, len = keys$1.length; i < len; i++) {
                     const key = keys$1[i];
                     const entry = entries[key];
@@ -45234,14 +45331,14 @@
         }
         return { ...source };
     }
-    function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler) {
+    function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler, redirects, additionalDurableStoreOperations = []) {
         const durableRecords = create$5(null);
         const evictedRecords = create$5(null);
         const { records, metadata: storeMetadata, visitedIds, refreshedIds, } = store.fallbackStringKeyInMemoryStore;
         // TODO: W-8909393 Once metadata is stored in its own segment we need to
         // call setEntries for the visitedIds on default segment and call setEntries
         // on the metadata segment for the refreshedIds
-        const keys$1 = keys$5({ ...visitedIds, ...refreshedIds });
+        const keys$1 = keys$6({ ...visitedIds, ...refreshedIds });
         for (let i = 0, len = keys$1.length; i < len; i += 1) {
             const key = keys$1[i];
             const record = records[key];
@@ -45263,9 +45360,9 @@
                 };
             }
         }
-        const durableStoreOperations = [];
+        const durableStoreOperations = additionalDurableStoreOperations;
         // publishes
-        const recordKeys = keys$5(durableRecords);
+        const recordKeys = keys$6(durableRecords);
         if (recordKeys.length > 0) {
             durableStoreOperations.push({
                 type: 'setEntries',
@@ -45273,8 +45370,20 @@
                 segment: DefaultDurableSegment,
             });
         }
+        // redirects
+        redirects.forEach((value, key) => {
+            durableStoreOperations.push({
+                type: 'setEntries',
+                entries: {
+                    [key]: {
+                        data: { key, redirect: value },
+                    },
+                },
+                segment: RedirectDurableSegment,
+            });
+        });
         // evicts
-        const evictedKeys = keys$5(evictedRecords);
+        const evictedKeys = keys$6(evictedRecords);
         if (evictedKeys.length > 0) {
             durableStoreOperations.push({
                 type: 'evictEntries',
@@ -45318,6 +45427,19 @@
         return environment.storeBuildIngestionStagingStore();
     }
 
+    async function reviveRedirects(durableStore, env) {
+        const entries = await durableStore.getAllEntries(RedirectDurableSegment);
+        if (entries) {
+            for (const durableEntry of Object.keys(entries)) {
+                const entry = entries[durableEntry];
+                const { data: { key, redirect }, } = entry;
+                if (entry) {
+                    env.storeRedirect(key, redirect);
+                }
+            }
+        }
+    }
+
     const AdapterContextSegment = 'ADAPTER-CONTEXT';
     const ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
     async function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded) {
@@ -45355,7 +45477,7 @@
         }
         return contextReturn();
     }
-    function isUnfulfilledSnapshot(cachedSnapshotResult) {
+    function isUnfulfilledSnapshot$1(cachedSnapshotResult) {
         if (cachedSnapshotResult === undefined) {
             return false;
         }
@@ -45380,13 +45502,18 @@
         // 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();
+        // redirects that need to be flushed to the durable store
+        const pendingStoreRedirects = new Map();
         const contextStores = create$5(null);
         let initializationPromise = new Promise((resolve) => {
             const finish = () => {
                 resolve();
                 initializationPromise = undefined;
             };
-            reviveTTLOverrides(durableTTLStore, environment).then(finish);
+            Promise.all([
+                reviveTTLOverrides(durableTTLStore, environment),
+                reviveRedirects(durableStore, environment),
+            ]).then(finish);
         });
         //instrumentation for durable store errors
         const durableStoreErrorHandler = handleDurableStoreRejection(instrumentation);
@@ -45399,6 +45526,8 @@
         const unsubscribe = durableStore.registerOnChangedListener(async (changes) => {
             const defaultSegmentKeys = [];
             const adapterContextSegmentKeys = [];
+            const redirectSegmentKeys = [];
+            let shouldBroadcast = false;
             for (let i = 0, len = changes.length; i < len; i++) {
                 const change = changes[i];
                 // we only care about changes to the data which is stored in the default
@@ -45409,6 +45538,20 @@
                 else if (change.segment === AdapterContextSegment) {
                     adapterContextSegmentKeys.push(...change.ids);
                 }
+                else if (change.segment === RedirectDurableSegment) {
+                    redirectSegmentKeys.push(...change.ids);
+                }
+            }
+            if (redirectSegmentKeys.length > 0) {
+                const redirectEntries = await durableStore.getEntries(redirectSegmentKeys, RedirectDurableSegment);
+                if (redirectEntries !== undefined) {
+                    const redirectKeys = Object.keys(redirectEntries);
+                    for (const key of redirectKeys) {
+                        const redirectData = redirectEntries[key];
+                        environment.storeRedirect(redirectData.data.key, redirectData.data.redirect);
+                        shouldBroadcast = true;
+                    }
+                }
             }
             // process adapter context changes
             const adapterContextKeysFromDifferentInstance = [];
@@ -45428,7 +45571,7 @@
                 try {
                     const entries = await durableStore.getEntries(adapterContextKeysFromDifferentInstance, AdapterContextSegment);
                     if (entries !== undefined) {
-                        const entryKeys = keys$5(entries);
+                        const entryKeys = keys$6(entries);
                         for (let i = 0, len = entryKeys.length; i < len; i++) {
                             const entryKey = entryKeys[i];
                             const entry = entries[entryKey];
@@ -45445,10 +45588,6 @@
             if (defaultSegmentKeysLength > 0) {
                 for (let i = 0; i < defaultSegmentKeysLength; i++) {
                     const key = defaultSegmentKeys[i];
-                    const canonical = environment.storeGetCanonicalKey(key);
-                    if (canonical !== key) {
-                        continue;
-                    }
                     // TODO: W-8909393 If expiration is the only thing that changed we should not evict the data... so
                     // if we stored expiration and data at different keys (or same keys in different segments)
                     // then we could know if only the expiration has changed and we wouldn't need to evict
@@ -45456,6 +45595,9 @@
                     // call base environment storeEvict so this evict is not tracked for durable deletion
                     environment.storeEvict(key);
                 }
+                shouldBroadcast = true;
+            }
+            if (shouldBroadcast) {
                 await environment.storeBroadcast(rebuildSnapshot, environment.snapshotAvailable);
             }
         });
@@ -45506,12 +45648,13 @@
             // call the base storeBroadcast
             return publishChangesToDurableStore();
         };
-        const publishChangesToDurableStore = function () {
+        const publishChangesToDurableStore = function (additionalDurableStoreOperations) {
             validateNotDisposed();
             if (ingestStagingStore === null) {
                 return Promise.resolve();
             }
-            const promise = flushInMemoryStoreValuesToDurableStore(ingestStagingStore, durableStore, durableStoreErrorHandler);
+            const promise = flushInMemoryStoreValuesToDurableStore(ingestStagingStore, durableStore, durableStoreErrorHandler, new Map(pendingStoreRedirects), additionalDurableStoreOperations);
+            pendingStoreRedirects.clear();
             ingestStagingStore = null;
             return promise;
         };
@@ -45593,6 +45736,7 @@
         };
         const storeRedirect = function (existingKey, canonicalKey) {
             validateNotDisposed();
+            pendingStoreRedirects.set(existingKey, canonicalKey);
             // call redirect on staging store so "old" keys are removed from L2 on
             // the next publishChangesToDurableStore.  NOTE: we don't need to call
             // redirect on the base environment store because staging store and base
@@ -45638,7 +45782,7 @@
                 const snapshot = buildCachedSnapshot(injectedBuildSnapshotContext, injectedStoreLookup, luvio);
                 // if the adapter attempted to do an L1 lookup and it was unfulfilled
                 // then we can attempt an L2 lookup
-                if (isUnfulfilledSnapshot(snapshot)) {
+                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) => {
@@ -46245,6 +46389,12 @@
     function stringLiteral(value, safe = false, isCaseSensitive = false) {
         return { type: ValueType.StringLiteral, value, safe, isCaseSensitive };
     }
+    function isStringLiteral(expression) {
+        return expression.type === ValueType.StringLiteral;
+    }
+    function isStringArray(expression) {
+        return expression.type === ValueType.StringArray;
+    }
     function comparison(left, operator, right) {
         return { type: PredicateType$1.comparison, left, right, operator };
     }
@@ -46504,7 +46654,7 @@
             case ComparisonOperator.eq:
                 return '=';
             case ComparisonOperator.ne:
-                return '!=';
+                return 'IS NOT';
             case ComparisonOperator.gt:
                 return '>';
             case ComparisonOperator.gte:
@@ -46544,9 +46694,13 @@
     const pathPrefix = '$';
     const recordsCTE = 'recordsCTE';
     const MultiPickListValueSeparator$1 = ';';
+    const recordCTESQL = excludeStaleRecordsGate.isOpen({ fallback: false })
+        ? `WITH ${recordsCTE} AS NOT materialized ` +
+            `(select data, metadata from lds_data where key like 'UiApi::RecordRepresentation:%')`
+        : `WITH ${recordsCTE} AS NOT materialized ` +
+            `(select data from lds_data where key like 'UiApi::RecordRepresentation:%')`;
     function cteSql() {
-        return (`WITH ${recordsCTE} AS NOT materialized ` +
-            `(select data from lds_data where key like 'UiApi::RecordRepresentation:%')`);
+        return recordCTESQL;
     }
     function computeSql(rootQuery) {
         const fields = rootQuery.connections.map((connection) => {
@@ -46823,6 +46977,14 @@
                 if (expression.subfield === 'displayValue' && targetDataType === 'Boolean') {
                     return { sql: 'null', bindings: [] };
                 }
+                // metadata extract is somewhat different than a data extract
+                if (expression.metadata === true) {
+                    let sql = `json_extract("${expression.jsonAlias}".metadata, '${pathPrefix}.${expression.field}')`;
+                    if (targetDataType !== undefined) {
+                        sql = coerceToTargetDataType(sql, targetDataType);
+                    }
+                    return { sql, bindings: [] };
+                }
                 let path = extractPath(expression.field, expression.subfield);
                 // For multiple picklist includes/excluding filtering, we need to prefix and suffix the field value with ';'
                 // to make the match safe.
@@ -47015,6 +47177,9 @@
         }
     }
 
+    const { isArray: isArray$4 } = Array;
+    const { keys: keys$5 } = Object;
+
     function isListValueNode(node) {
         return node.kind === 'ListValue';
     }
@@ -47067,13 +47232,13 @@
     const NotOperator = 'not';
     const { eq, ne, gt, gte, lt, lte, nin, like, includes, excludes } = ComparisonOperator;
     const inOp = ComparisonOperator.in;
-    function fieldsToFilters(fieldValues, joinAlias, apiName, input, compoundOperator = CompoundOperator.and, joins) {
+    function fieldsToFilters(fieldValues, joinAlias, apiName, input, compoundOperator = CompoundOperator.and, joins, draftFunctions) {
         const results = fieldValues
             .map((value) => {
             if (!isObjectValueNode$1(value)) {
                 return [failure([message('Parent filter node should be an object.')])];
             }
-            return Object.entries(value.fields).map(([key, value]) => filter(key, value, joinAlias, apiName, input, joins));
+            return Object.entries(value.fields).map(([key, value]) => filter(key, value, joinAlias, apiName, input, joins, draftFunctions));
         })
             .reduce(flatten$1, []);
         const failures = results.filter(isFailure).reduce(flatMap$1(errors), []);
@@ -47095,22 +47260,22 @@
         return success({ predicate: resolvedPredicate });
     }
     //{where: {Field: ... | and: ... | or: ... | not: ...}}
-    function recordFilter(where, joinAlias, apiName, input, joins) {
+    function recordFilter(where, joinAlias, apiName, input, joins, draftFunctions) {
         if (where === undefined) {
             return success(undefined);
         }
         // when 'recordFilter' starts, there is no 'NotPredicated'
-        return fieldsToFilters([where.value], joinAlias, apiName, input, CompoundOperator.and, joins).map((result) => result.predicate === undefined || isEmptyPredicate(result.predicate) ? undefined : result);
+        return fieldsToFilters([where.value], joinAlias, apiName, input, CompoundOperator.and, joins, draftFunctions).map((result) => result.predicate === undefined || isEmptyPredicate(result.predicate) ? undefined : result);
     }
-    function filter(name, value, tableAlias, apiName, input, joins) {
+    function filter(name, value, tableAlias, apiName, input, joins, draftFunctions) {
         if (isCompoundOperator(name)) {
             if (!isListValueNode(value)) {
                 return failure([message(`Value for ${name} node must be a list.`)]);
             }
-            return compoundPredicate(name, value, tableAlias, apiName, input, joins);
+            return compoundPredicate(name, value, tableAlias, apiName, input, joins, draftFunctions);
         }
         if (name === NotOperator) {
-            const children = fieldsToFilters([value], tableAlias, apiName, input, CompoundOperator.and, joins);
+            const children = fieldsToFilters([value], tableAlias, apiName, input, CompoundOperator.and, joins, draftFunctions);
             // take the children of a not predicate
             // and wrap them all inside it
             return children.flatMap((container) => {
@@ -47128,10 +47293,10 @@
         if (!isObjectValueNode$1(value)) {
             return failure([message('Filter node must be an object or list.')]);
         }
-        return fieldFilter(name, value, tableAlias, apiName, input, joins);
+        return fieldFilter(name, value, tableAlias, apiName, input, joins, draftFunctions);
     }
-    function compoundPredicate(operator, list, joinAlias, apiName, input, joins) {
-        return fieldsToFilters(list.values, joinAlias, apiName, input, operator, joins);
+    function compoundPredicate(operator, list, joinAlias, apiName, input, joins, draftFunctions) {
+        return fieldsToFilters(list.values, joinAlias, apiName, input, operator, joins, draftFunctions);
     }
     /**
      * spans a FieldNode with its ObjectValueNode is passed. All the predicates is added into the 'join' array.
@@ -47142,7 +47307,7 @@
      * @param joins
      * @returns undefined predicate
      */
-    function spanningFilter(fieldInfo, fieldNode, alias, input, joins) {
+    function spanningFilter(fieldInfo, fieldNode, alias, input, joins, draftFunctions) {
         const { apiName: fieldName, referenceToInfos, relationshipName } = fieldInfo;
         const referenceInfo = referenceToInfos[0];
         const jsonAlias = `${alias}.${relationshipName}`;
@@ -47161,7 +47326,7 @@
         joins.push(join);
         // moves constraint predicate to where
         const constraintPredicates = [];
-        const filterResult = fieldsToFilters([fieldNode], jsonAlias, apiName, input, CompoundOperator.and, joins);
+        const filterResult = fieldsToFilters([fieldNode], jsonAlias, apiName, input, CompoundOperator.and, joins, draftFunctions);
         if (filterResult.isSuccess === false) {
             return filterResult;
         }
@@ -47173,7 +47338,11 @@
         });
         return success({ predicate: combinePredicates(constraintPredicates, CompoundOperator.and) });
     }
-    function fieldFilter(fieldName, fieldNode, alias, apiName, input, joins) {
+    function isIDValueField$1(fieldInfo) {
+        return (fieldInfo.apiName === 'Id' ||
+            (fieldInfo.referenceToInfos !== undefined && fieldInfo.referenceToInfos.length > 0));
+    }
+    function fieldFilter(fieldName, fieldNode, alias, apiName, input, joins, draftFunctions) {
         const fieldInfoResult = getFieldInfo(apiName, fieldName, input);
         if (fieldInfoResult.isSuccess === false) {
             return failure([fieldInfoResult.error]);
@@ -47183,8 +47352,9 @@
             return failure([message(`Field ${fieldName} for type ${apiName} not found.`)]);
         }
         if (fieldInfo.dataType === 'Reference' && fieldInfo.relationshipName === fieldName) {
-            return spanningFilter(fieldInfo, fieldNode, alias, input, joins);
+            return spanningFilter(fieldInfo, fieldNode, alias, input, joins, draftFunctions);
         }
+        const idProcessingNeeded = isIDValueField$1(fieldInfo);
         const extract = {
             type: ValueType.Extract,
             jsonAlias: alias,
@@ -47272,7 +47442,29 @@
                     children,
                 };
             }
-            return comparison(extract, op.operator, op.value);
+            const rightOperand = op.value;
+            if (idProcessingNeeded) {
+                if (isStringLiteral(rightOperand)) {
+                    if (rightOperand.value !== null) {
+                        if (draftFunctions.isDraftId(rightOperand.value)) {
+                            rightOperand.value = draftFunctions.getCanonicalId(rightOperand.value);
+                        }
+                    }
+                }
+                else if (isStringArray(rightOperand)) {
+                    if (rightOperand.value !== null) {
+                        rightOperand.value = rightOperand.value.map((originalId) => {
+                            if (originalId !== null) {
+                                if (draftFunctions.isDraftId(originalId)) {
+                                    return draftFunctions.getCanonicalId(originalId);
+                                }
+                            }
+                            return originalId;
+                        });
+                    }
+                }
+            }
+            return comparison(extract, op.operator, rightOperand);
         });
         const combined = combinePredicates(comparisons.concat(...dateFunction.value), CompoundOperator.and);
         const container = {
@@ -47479,7 +47671,11 @@
         }
         if (objectInfoDataType === 'Double') {
             if (isScalarOperatorType(operator)) {
-                return is(valueNode, 'FloatValue')
+                // allow a float/double value to be passed
+                // also allow an integer to be passed to a double, but not a double to an integer
+                const isFloatOrInt = is(valueNode, 'FloatValue') ||
+                    is(valueNode, 'IntValue');
+                return isFloatOrInt
                     ? success({
                         type: 'DoubleOperator',
                         operator,
@@ -48368,7 +48564,7 @@
         const orderByJoins = [];
         const orderByResult = parseOrderBy(orderByArg, alias, apiName, input.objectInfoMap, orderByJoins);
         const filterJoins = [];
-        const whereResult = recordFilter(whereArg, alias, apiName, input.objectInfoMap, filterJoins);
+        const whereResult = recordFilter(whereArg, alias, apiName, input.objectInfoMap, filterJoins, input.draftFunctions);
         const scopeJoins = [];
         const scopeResult = scopeFilter(scopeArg, alias, apiName, input, scopeJoins);
         let additionalPredicates = [];
@@ -48416,6 +48612,33 @@
         const draftsField = { type: FieldType.Scalar, extract, path: 'node._drafts' };
         const idExtract = { type: ValueType.Extract, jsonAlias: alias, field: 'Id' };
         const idField = { type: FieldType.Scalar, extract: idExtract, path: 'node.Id' };
+        // When the exclude stale records gate is open and there is a root timestamp
+        // in the parser input, inject an additional predicate to limit the search
+        // to records that either have drafts associated to them or were ingested at
+        // least as recently as the query.
+        if (excludeStaleRecordsGate.isOpen({ fallback: false }) && input.rootTimestamp !== undefined) {
+            const timestampCheck = {
+                type: PredicateType$1.comparison,
+                left: {
+                    type: ValueType.Extract,
+                    jsonAlias: alias,
+                    field: 'ingestionTimestamp',
+                    metadata: true,
+                },
+                operator: ComparisonOperator.gte,
+                right: { type: ValueType.IntLiteral, value: input.rootTimestamp },
+            };
+            const isDraft = {
+                type: PredicateType$1.nullComparison,
+                left: { type: ValueType.Extract, jsonAlias: alias, field: 'drafts' },
+                operator: NullComparisonOperator.isNot,
+            };
+            predicates.push({
+                type: PredicateType$1.compound,
+                operator: CompoundOperator.or,
+                children: [timestampCheck, isDraft],
+            });
+        }
         return queryContainer(internalFields, alias, apiName, predicates).map((result) => {
             const { fields, predicates } = result;
             const allFields = removeDuplicateFields(fields.concat(...[draftsField, idField]));
@@ -48464,6 +48687,20 @@
         if (input.objectInfoMap[alias] === undefined) {
             return failure([missingObjectInfo(apiName)]);
         }
+        // When the exclude stale records gate is open and the query has an
+        // ingestion timestamp in its cache metadata, associate that with the input
+        // so it can later be used to limit the search to records were ingested at
+        // least as recently as the query.
+        if (excludeStaleRecordsGate.isOpen({ fallback: false })) {
+            const key = input.connectionKeyBuilder(selection, input.config.variables);
+            const queryMetadata = input.metadata[key];
+            // If there is no metadata for this query or it somehow lacks a timestamp
+            // skip setting the root timestamp
+            if (queryMetadata !== undefined && queryMetadata.ingestionTimestamp !== undefined) {
+                // subtract 10ms from timestamp to account for ingestion processing time
+                input.rootTimestamp = queryMetadata.ingestionTimestamp - 10;
+            }
+        }
         return recordQuery(selection, alias, apiName, [], input);
     }
     function rootQuery(recordNodes, input) {
@@ -48530,27 +48767,19 @@
                 ? node.arguments
                     .map((args) => {
                     const { value, name } = args;
+                    //The variable is on the top level, for example `where: ${filter}`
                     if (is(value, 'Variable')) {
-                        const variable = variables[value.name];
-                        if (variable) {
-                            const jsonString = JSON.stringify(variable);
-                            const buildRecordQueryString = (name, query, transform) => {
-                                return `${name}: ${transform(query)}`;
-                            };
-                            switch (name) {
-                                case 'scope':
-                                case 'orderBy':
-                                    return buildRecordQueryString(name, jsonString, removeAllQuotations);
-                                default:
-                                    return buildRecordQueryString(name, jsonString, removeQuotationsFromKeys);
-                            }
-                        }
-                        return '';
+                        return generateVariableNodeQuery(value, name, name, variables);
+                    }
+                    else if (isObjectValueNode$1(value)) {
+                        return generateVariableSubQuery(value, name, name, variables);
                     }
                 })
                     .filter(Boolean)
                 : undefined;
-            return gqlArguments ? `${node.name}(${gqlArguments.join(',')}) { Id }` : '';
+            return gqlArguments
+                ? `${node.name} ${gqlArguments.length > 0 ? '(' + gqlArguments.join(',') + ')' : ''} { Id }`
+                : '';
         })
             //remove empty strings
             .filter(Boolean)
@@ -48560,6 +48789,51 @@
             return [accu.slice(0, 1), query, accu.slice(1, length)].join('');
         }, '{ }'));
     }
+    /**
+     * Given a  LuvioValueNode, generates a sql with its variable node replaced with actual value.
+     * @param valueNode G
+     * @param name
+     * @param type
+     * @param variables
+     * @returns
+     */
+    function generateVariableSubQuery(valueNode, name, type, variables) {
+        switch (valueNode.kind) {
+            case Kind.OBJECT: {
+                // For example, `{ Id: { eq: $draftId } }` is a `ObjectValueNode`, which has field keys 'Id'
+                const resultQuery = keys$5(valueNode.fields)
+                    .map((key) => generateVariableSubQuery(valueNode.fields[key], key, type, variables))
+                    .filter((subquery) => subquery.length > 0)
+                    .join(',');
+                if (resultQuery.length > 0) {
+                    return `${name}: {${resultQuery}}`;
+                }
+                return resultQuery;
+            }
+            case Kind.VARIABLE:
+                return generateVariableNodeQuery(valueNode, name, type, variables);
+            default:
+                return '';
+        }
+    }
+    // Generate a sql for the variable node with its actual value.
+    function generateVariableNodeQuery(value, name, type, variables) {
+        const variable = variables[value.name];
+        if (variable) {
+            const jsonString = JSON.stringify(variable);
+            const buildRecordQueryString = (name, query, transform) => {
+                return `${name}: ${transform(query)}`;
+            };
+            switch (type) {
+                case 'scope':
+                case 'orderBy':
+                    return buildRecordQueryString(name, jsonString, removeAllQuotations);
+                default:
+                    return buildRecordQueryString(name, jsonString, removeQuotationsFromKeys);
+            }
+        }
+        return '';
+    }
     /**
      * Given an AST with variables
      * Swap out the LuvioArgumentNodes on the original AST with ones generated from its variables.
@@ -48578,14 +48852,43 @@
                 const { name } = node;
                 const first = allArgumentRecords.find((n) => n.name === name);
                 if (first) {
-                    // if we had arguments that did not contain variables we still want those
-                    first.arguments = flatten$1(first.arguments
-                        ? first.arguments.filter((x) => x.value.kind !== 'Variable')
-                        : [], node.arguments ? node.arguments : []);
+                    const swappedArgments = swapArgumentWithVariableNodes(node.arguments, first.arguments);
+                    first.arguments = swappedArgments ? swappedArgments : [];
                 }
             });
         }
     }
+    // Replaces the variable node  in original LuvioArgumentNode with the actual value in the swapped node with the same path.
+    function swapArgumentWithVariableNodes(swapped, original) {
+        if (swapped === undefined || original === undefined) {
+            return original;
+        }
+        return original.map((x) => {
+            const targetNode = swapped.find((y) => y.name === x.name);
+            if (targetNode === undefined) {
+                return x;
+            }
+            if (x.value.kind === 'Variable') {
+                return targetNode;
+            }
+            swapValueNodeWithVariableNodes(x.value, targetNode.value);
+            return x;
+        });
+    }
+    function swapValueNodeWithVariableNodes(original, swapped) {
+        if (original.kind === Kind.OBJECT) {
+            for (const key of keys$5(original.fields)) {
+                if (isObjectValueNode$1(swapped) && swapped.fields[key]) {
+                    if (is(original.fields[key], 'Variable')) {
+                        original.fields[key] = swapped.fields[key];
+                    }
+                    else {
+                        swapValueNodeWithVariableNodes(original.fields[key], swapped.fields[key]);
+                    }
+                }
+            }
+        }
+    }
     //find top level record queries
     function findRecordSelections$1(document) {
         return document.definitions
@@ -48620,12 +48923,24 @@
          * Missing object info records triggers the objectInfoService (same instance shared with Drafts code), to
          * use the getObjectInfos adapter to efficiently fetch the necessary records.
          */
-        async createRootQuery(config, objectInfoService, userId) {
+        async createRootQuery(config, objectInfoService, userId, draftFunctions, connectionKeyBuilder, sqliteStore) {
             const { query: ast, variables } = config;
             swapVariableArguments(ast, variables);
             // Parse out top-level record queries types we know we will need, since spanning fields will
             // require at least this top level record present to resolve relationship lookups
-            const topLevelNeededRecords = findRecordSelections$1(ast).map((selection) => selection.name);
+            const recordSelections = findRecordSelections$1(ast);
+            let metadata = {};
+            if (excludeStaleRecordsGate.isOpen({ fallback: false })) {
+                const keys = recordSelections.map((rs) => connectionKeyBuilder(rs, variables));
+                let sqlResult = await sqliteStore.query(`select key, metadata from lds_data where key in (${keys
+                .map(() => '?')
+                .join(',')})`, keys);
+                metadata = sqlResult.rows.reduce((metadata, row) => {
+                    metadata[row[0]] = JSON.parse(row[1]);
+                    return metadata;
+                }, {});
+            }
+            const topLevelNeededRecords = recordSelections.map((selection) => selection.name);
             // Seed the initial list of things to fetch
             const neededObjectInfos = new Set(topLevelNeededRecords);
             // Seed the list of things we've _tried_ to fetch.  As we iterate and
@@ -48665,8 +48980,12 @@
                 };
                 // Attempt to parse the AST given what we know already...
                 astTransformResult = transform(ast, {
+                    config,
                     userId,
                     objectInfoMap,
+                    draftFunctions,
+                    connectionKeyBuilder,
+                    metadata,
                 });
                 if (astTransformResult.isSuccess === false) {
                     for (const error of astTransformResult.error) {
@@ -48704,8 +49023,6 @@
         }
     }
 
-    const { isArray: isArray$4 } = Array;
-
     /**
      * Checks a GraphQL-shaped network response for errors, returning true if it does
      * and false otherwise
@@ -48743,15 +49060,15 @@
         return { data, seenRecords };
     }
     const wrapStartEndEvents = (storeEval) => {
-        return async (config, nonEvaluatedSnapshotOrPromise, observers) => {
+        return async (config, nonEvaluatedSnapshotOrPromise, observers, connectionKeyBuilder) => {
             const eventEmitter = createCustomAdapterEventEmitter(GRAPHQL_EVAL_NAMESPACE$1, observers);
             eventEmitter({ type: 'graphql-eval-start' });
-            const snapshot = await storeEval(config, nonEvaluatedSnapshotOrPromise, observers);
+            const snapshot = await storeEval(config, nonEvaluatedSnapshotOrPromise, observers, connectionKeyBuilder);
             eventEmitter({ type: 'graphql-eval-end' });
             return snapshot;
         };
     };
-    function sqliteStoreEvalFactory(userId, sqliteStore, objectInfoService) {
+    function sqliteStoreEvalFactory(userId, sqliteStore, objectInfoService, draftFunctions) {
         // if the store does not support eval then use the noop version
         if (sqliteStore.isEvalSupported() === false) {
             return noopStoreEval;
@@ -48759,7 +49076,7 @@
         const preconditioner = new StoreEvalPreconditioner();
         return makeStoreEval(preconditioner, objectInfoService, userId, async () => {
             return undefined;
-        }, (query, _context, eventEmitter) => evaluateSqlite(query, eventEmitter, sqliteStore));
+        }, (query, _context, eventEmitter) => evaluateSqlite(query, eventEmitter, sqliteStore), draftFunctions, sqliteStore);
     }
     async function noopStoreEval(_config, nonEvaluatedSnapshotOrPromise, _observers) {
         return nonEvaluatedSnapshotOrPromise;
@@ -48778,8 +49095,8 @@
     function generateUniqueRecordId$1() {
         return `${GRAPHQL_ROOT_KEY$1}${Date.now() + Math.random().toFixed(5).split('.')[1]}`;
     }
-    function makeStoreEval(preconditioner, objectInfoService, userId, contextProvider, queryEvaluator) {
-        const storeEval = async (config, nonEvaluatedSnapshotOrPromise, observers) => {
+    function makeStoreEval(preconditioner, objectInfoService, userId, contextProvider, queryEvaluator, draftFunctions, sqliteStore) {
+        const storeEval = async (config, nonEvaluatedSnapshotOrPromise, observers, connectionKeyBuilder) => {
             const eventEmitter = createCustomAdapterEventEmitter(GRAPHQL_EVAL_NAMESPACE$1, observers);
             // the non-eval'ed input could either be a snapshot or promise of one so
             // await it here to normalize the input to a snapshot
@@ -48808,7 +49125,7 @@
                 context = await contextProvider();
                 // Ensures ObjectInfo metadata is available for the request.  Sourcing records from L1/L2/Network
                 // is delegated to the getObjectInfo adapter via objectInfoService
-                rootQuery = await preconditioner.createRootQuery(config, objectInfoService, userId);
+                rootQuery = await preconditioner.createRootQuery(config, objectInfoService, userId, draftFunctions, connectionKeyBuilder, sqliteStore);
             }
             catch (error) {
                 eventEmitter({
@@ -48839,7 +49156,7 @@
             try {
                 const { data, seenRecords } = await queryEvaluator(rootQuery, context, eventEmitter);
                 const rebuildWithStoreEval = ((originalSnapshot) => {
-                    return storeEval(config, originalSnapshot, observers);
+                    return storeEval(config, originalSnapshot, observers, connectionKeyBuilder);
                 });
                 const recordId = generateUniqueRecordId$1();
                 // if the non-eval'ed snapshot was an error then we return a synthetic
@@ -49138,7 +49455,7 @@
         return new DraftErrorFetchResponse(HttpStatusCode$1.BadRequest, error);
     }
 
-    const { keys: keys$4, create: create$4, assign: assign$3, values: values$1 } = Object;
+    const { keys: keys$4, create: create$4, assign: assign$4, values: values$1 } = Object;
     const { stringify: stringify$4, parse: parse$4 } = JSON;
     const { isArray: isArray$3 } = Array;
 
@@ -49185,7 +49502,6 @@
     }
 
     const DraftIdMappingKeyPrefix240 = 'DraftIdMapping::';
-    const DraftKeyMappingKeyPrefix = 'DraftKeyMapping::V2::';
     const DRAFT_ID_MAPPINGS_SEGMENT = 'DRAFT_ID_MAPPINGS';
     function isLegacyDraftIdMapping(key, data) {
         return key.startsWith(DraftIdMappingKeyPrefix240);
@@ -49195,9 +49511,6 @@
     function getRecordKeyForId$1(id) {
         return `UiApi::RecordRepresentation:${id}`;
     }
-    function generateDraftIdMappingKey(draftIdMapping) {
-        return `${DraftKeyMappingKeyPrefix}${draftIdMapping.draftKey}::${draftIdMapping.canonicalKey}`;
-    }
     /**
      *
      * @param mappingIds (optional) requested mapping ids, if undefined all will be retrieved
@@ -49231,6 +49544,15 @@
         }
         return mappings;
     }
+    async function clearDraftIdSegment(durableStore) {
+        const entries = await durableStore.getAllEntries(DRAFT_ID_MAPPINGS_SEGMENT);
+        if (entries) {
+            const keys$1 = keys$4(entries);
+            if (keys$1.length > 0) {
+                await durableStore.evictEntries(keys$1, DRAFT_ID_MAPPINGS_SEGMENT);
+            }
+        }
+    }
 
     /**
      * Generates a time-ordered, unique id to associate with a DraftAction. Ensures
@@ -49321,9 +49643,6 @@
             });
             return queueOperations;
         };
-        const getRedirectMappings = (_action) => {
-            return undefined;
-        };
         return {
             handlerId: id,
             enqueue: (data) => {
@@ -49335,7 +49654,6 @@
             handleReplaceAction: () => {
                 throw Error('replaceAction not supported for custom actions');
             },
-            getRedirectMappings,
             handleActionRemoved: () => Promise.resolve(),
             handleActionCompleted: () => Promise.resolve(),
             handleActionEnqueued: () => Promise.resolve(),
@@ -49510,17 +49828,11 @@
                     const handler = this.getHandler(action.handler);
                     let queue = await this.getQueueActions();
                     const queueOperations = handler.getQueueOperationsForCompletingDrafts(queue, action);
-                    const idAndKeyMappings = handler.getRedirectMappings(action);
-                    const keyMappings = idAndKeyMappings === undefined
-                        ? undefined
-                        : idAndKeyMappings.map((m) => {
-                            return { draftKey: m.draftKey, canonicalKey: m.canonicalKey };
-                        });
-                    await this.draftStore.completeAction(queueOperations, keyMappings);
-                    queue = await this.getQueueActions();
+                    // write the queue operations to the store prior to ingesting the result
+                    await this.draftStore.completeAction(queueOperations);
+                    await handler.handleActionCompleted(action, queueOperations, values$1(this.handlers));
                     this.retryIntervalMilliseconds = 0;
                     this.uploadingActionId = undefined;
-                    await handler.handleActionCompleted(action, queueOperations, queue, values$1(this.handlers));
                     await this.notifyChangedListeners({
                         type: DraftQueueEventType.ActionCompleted,
                         action,
@@ -49839,7 +50151,7 @@
             };
             return this.enqueueAction(deleteAction);
         }
-        completeAction(queueOperations, mappings) {
+        completeAction(queueOperations) {
             const action = () => {
                 const durableStoreOperations = [];
                 const { draftStore } = this;
@@ -49872,18 +50184,6 @@
                         });
                     }
                 }
-                if (mappings !== undefined) {
-                    const entries = {};
-                    for (const mapping of mappings) {
-                        const mappingKey = generateDraftIdMappingKey(mapping);
-                        entries[mappingKey] = { data: mapping };
-                    }
-                    durableStoreOperations.push({
-                        entries,
-                        type: 'setEntries',
-                        segment: DRAFT_ID_MAPPINGS_SEGMENT,
-                    });
-                }
                 return this.durableStore.batchOperations(durableStoreOperations);
             };
             return this.enqueueAction(action);
@@ -50148,7 +50448,7 @@
                 },
             ];
         }
-        async handleActionCompleted(action, queueOperations, _queue, allHandlers) {
+        async handleActionCompleted(action, queueOperations, allHandlers) {
             const { data: request, tag } = action;
             const { method } = request;
             if (method === 'delete') {
@@ -50225,6 +50525,8 @@
             };
             // overlay metadata
             merged.metadata = { ...targetMetadata, ...sourceMetadata };
+            // put status back to pending to auto upload if queue is active and targed is at the head.
+            merged.status = DraftActionStatus.Pending;
             return merged;
         }
         shouldDeleteActionByTagOnRemoval(action) {
@@ -50260,11 +50562,18 @@
         async ingestResponses(responses, action) {
             const luvio = this.getLuvio();
             await luvio.handleSuccessResponse(() => {
+                if (action.status === DraftActionStatus.Completed) {
+                    const mappings = this.getRedirectMappings(action);
+                    if (mappings) {
+                        mappings.forEach((mapping) => {
+                            luvio.storeRedirect(mapping.draftKey, mapping.canonicalKey);
+                        });
+                    }
+                }
                 for (const entry of responses) {
                     const { response, synchronousIngest } = entry;
                     synchronousIngest(response, action);
                 }
-                // must call base broadcast
                 return luvio.storeBroadcast();
             }, 
             // getTypeCacheKeysRecord uses the response, not the full path factory
@@ -50592,6 +50901,8 @@
 
     function makeEnvironmentDraftAware(luvio, env, durableStore, handlers, draftQueue) {
         const draftMetadata = {};
+        // in 246 luvio took charge of persisting redirect mappings, this needs to stick around
+        // for a couple of releases to support older environments
         // setup existing store redirects when bootstrapping the environment
         (async () => {
             const mappings = await getDraftIdMappings(durableStore);
@@ -50599,23 +50910,9 @@
                 const { draftKey, canonicalKey } = mapping;
                 env.storeRedirect(draftKey, canonicalKey);
             });
+            await env.storeBroadcast(env.rebuildSnapshot, env.snapshotAvailable);
+            await clearDraftIdSegment(durableStore);
         })();
-        durableStore.registerOnChangedListener(async (changes) => {
-            const draftIdMappingsIds = [];
-            for (let i = 0, len = changes.length; i < len; i++) {
-                const change = changes[i];
-                if (change.segment === DRAFT_ID_MAPPINGS_SEGMENT) {
-                    draftIdMappingsIds.push(...change.ids);
-                }
-            }
-            if (draftIdMappingsIds.length > 0) {
-                const mappings = await getDraftIdMappings(durableStore, draftIdMappingsIds);
-                mappings.forEach((mapping) => {
-                    const { draftKey, canonicalKey } = mapping;
-                    env.storeRedirect(draftKey, canonicalKey);
-                });
-            }
-        });
         const handleSuccessResponse = async function (ingestAndBroadcastFunc, getResponseCacheKeysFunc) {
             const queue = await draftQueue.getQueueActions();
             if (queue.length === 0) {
@@ -50683,16 +50980,23 @@
 
     const API_NAMESPACE = 'UiApi';
     const RECORD_REPRESENTATION_NAME$1 = 'RecordRepresentation';
+    const RECORD_VIEW_ENTITY_REPRESENTATION_NAME = 'RecordViewEntityRepresentation';
     const RECORD_ID_PREFIX = `${API_NAMESPACE}::${RECORD_REPRESENTATION_NAME$1}:`;
+    const RECORD_VIEW_ENTITY_ID_PREFIX = `${API_NAMESPACE}::${RECORD_VIEW_ENTITY_REPRESENTATION_NAME}:Name:`;
     const RECORD_FIELDS_KEY_JUNCTION = '__fields__';
     function isStoreKeyRecordId(key) {
         return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1;
     }
+    function isStoreKeyRecordViewEntity(key) {
+        return (key.indexOf(RECORD_VIEW_ENTITY_ID_PREFIX) > -1 &&
+            key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1);
+    }
     function isStoreKeyRecordField(key) {
         return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) > -1;
     }
     function extractRecordIdFromStoreKey(key) {
-        if (key === undefined || key.indexOf(RECORD_ID_PREFIX) === -1) {
+        if (key === undefined ||
+            (key.indexOf(RECORD_ID_PREFIX) === -1 && key.indexOf(RECORD_VIEW_ENTITY_ID_PREFIX) === -1)) {
             return undefined;
         }
         const parts = key.split(':');
@@ -50707,7 +51011,8 @@
     }
     function isEntryDurableRecordRepresentation(entry, key) {
         // Either a DurableRecordRepresentation or StoreRecordError can live at a record key
-        return isStoreKeyRecordId(key) && entry.data.__type === undefined;
+        return ((isStoreKeyRecordId(key) || isStoreKeyRecordViewEntity(key)) &&
+            entry.data.__type === undefined);
     }
 
     /**
@@ -50843,7 +51148,7 @@
             (x.length === 0 || (x.length > 0 && Object.prototype.hasOwnProperty.call(x, x.length - 1))));
     }
 
-    const { create: create$3, keys: keys$3, values, entries: entries$2 } = Object;
+    const { create: create$3, keys: keys$3, values, entries: entries$2, assign: assign$3 } = Object;
     const { stringify: stringify$3, parse: parse$3 } = JSON;
     const { isArray: isArray$2 } = Array;
 
@@ -51282,6 +51587,10 @@
         };
     }
 
+    const JSON_EXTRACT_PATH_INGESTION_TIMESTAMP = '$.ingestionTimestamp';
+    const JSON_EXTRACT_PATH_INGESTION_APINAME = '$.apiName';
+    const JSON_EXTRACT_PATH_DRAFTS = '$.drafts';
+
     const MultiPickListValueSeparator = ';';
     function filterToPredicates(where, recordType, alias, objectInfoMap, joins, draftFunctions) {
         if (!where)
@@ -51343,7 +51652,7 @@
                         return [
                             {
                                 alias: childAlias,
-                                leftPath: '$.apiName',
+                                leftPath: JSON_EXTRACT_PATH_INGESTION_APINAME,
                                 operator: '=',
                                 value: entityName,
                                 dataType: 'String',
@@ -51643,15 +51952,10 @@
                 // If an explicit collating sequence is required on an IN operator it should be applied to the left operand,
                 // like this: "x COLLATE NOCASE IN (y,z, ...)".
                 const nullCheck = `json_extract("${alias}".data, '${leftPath}') ${operator === 'IN' ? 'IS' : 'IS NOT'} ?`;
-                //if we only have a null in/nin then dont add the IN (y, z, ...)
-                if (valueBinding.length > 0) {
-                    sql = `json_extract("${alias}".data, '${leftPath}')${isCaseSensitive === true ? '' : ` COLLATE NOCASE`} ${operator} ${questionSql} ${includesNull ? `OR ${nullCheck}` : ''}`;
-                }
-                else {
-                    sql = `${includesNull ? nullCheck : ''}`;
-                }
+                sql = `json_extract("${alias}".data, '${leftPath}')${isCaseSensitive === true ? '' : ` COLLATE NOCASE`} ${operator} ${questionSql}`;
                 binding.push(...valueBinding);
                 if (includesNull) {
+                    sql = `(${sql} OR ${nullCheck})`;
                     binding.push(null);
                 }
             }
@@ -51799,11 +52103,18 @@
         const joins = buildJoins(config);
         const predicates = buildPredicates(config);
         const orderBy = buildOrderBy(config);
+        const staleRecordsSql = excludeStaleRecordsGate.isOpen({ fallback: false })
+            ? `AND (
+            json_extract("${config.alias}".metadata, '${JSON_EXTRACT_PATH_INGESTION_TIMESTAMP}') >= ?
+            OR json_extract("${config.alias}".data, '${JSON_EXTRACT_PATH_DRAFTS}') IS NOT NULL
+          )`
+            : '';
         const sql = `
         SELECT "${config.alias}".data
         FROM lds_data "${config.alias}" ${joins.sql}
         WHERE "${config.alias}".key like 'UiApi::RecordRepresentation:%'
-          AND json_extract("${config.alias}".data, '$.apiName') = ?
+          AND json_extract("${config.alias}".data, '${JSON_EXTRACT_PATH_INGESTION_APINAME}') = ?
+          ${staleRecordsSql}
           ${predicates.sql}
           ${orderBy.sql}
         LIMIT ?
@@ -51816,6 +52127,7 @@
             ...joins.bindings,
             // the api name for the main record type
             config.alias,
+            ...(excludeStaleRecordsGate.isOpen({ fallback: false }) ? [config.ingestionTimestamp] : []),
             // where clause and parent scope bindings
             ...predicates.bindings,
             // limit binding
@@ -51841,19 +52153,33 @@
         if (allJoins.length === 0)
             return { sql, bindings };
         sql = allJoins.reduce((joinAccumulator, join) => {
+            let timestampAdded = false;
             const joinConditions = join.conditions.reduce((conditionAccumulator, condition) => {
                 let joined_sql;
+                const joinMetadataTimestamp = excludeStaleRecordsGate.isOpen({ fallback: false })
+                    ? ` AND (json_extract("${join.alias}".metadata, '${JSON_EXTRACT_PATH_INGESTION_TIMESTAMP}') >= ? OR json_extract("${join.alias}".data, '${JSON_EXTRACT_PATH_DRAFTS}') IS NOT NULL)`
+                    : '';
                 // predicate on a value, use the newly joined table
                 if ('type' in condition) {
                     const { sql, binding } = predicateToSQL(condition, join.alias);
-                    joined_sql = ` AND ${sql}`;
+                    joined_sql = ` AND ${sql}${timestampAdded ? '' : joinMetadataTimestamp}`;
                     bindings.push(...binding);
+                    if (excludeStaleRecordsGate.isOpen({ fallback: false }) &&
+                        timestampAdded === false) {
+                        bindings.push(config.ingestionTimestamp);
+                        timestampAdded = true;
+                    }
                 }
                 else {
                     // predicate on a path
                     const left = ` AND json_extract("${join.to}".data, '${condition.leftPath}')`;
                     const right = `json_extract("${join.alias}".data, '${condition.rightPath}')`;
-                    joined_sql = `${left} = ${right}`;
+                    joined_sql = `${left} = ${right}${timestampAdded ? '' : joinMetadataTimestamp}`;
+                    if (excludeStaleRecordsGate.isOpen({ fallback: false }) &&
+                        timestampAdded === false) {
+                        bindings.push(config.ingestionTimestamp);
+                        timestampAdded = true;
+                    }
                 }
                 conditionAccumulator += joined_sql;
                 return conditionAccumulator;
@@ -52532,7 +52858,7 @@
     function pathForKey(key) {
         switch (key) {
             case 'ApiName':
-                return '$.apiName';
+                return JSON_EXTRACT_PATH_INGESTION_APINAME;
             case 'WeakEtag':
                 return '$.weakEtag';
             case 'Id':
@@ -52554,7 +52880,7 @@
                     {
                         type: PredicateType.single,
                         alias: 'ServiceAppointment_AssignedResource',
-                        leftPath: '$.apiName',
+                        leftPath: JSON_EXTRACT_PATH_INGESTION_APINAME,
                         operator: '=',
                         value: 'AssignedResource',
                         dataType: 'String',
@@ -52575,7 +52901,7 @@
                     {
                         type: PredicateType.single,
                         alias: 'ServiceAppointment_AssignedResource_ServiceResource',
-                        leftPath: '$.apiName',
+                        leftPath: JSON_EXTRACT_PATH_INGESTION_APINAME,
                         operator: '=',
                         value: 'ServiceResource',
                         dataType: 'String',
@@ -52680,14 +53006,21 @@
                 // Fields of the `RecordQuery` type are the record queries for the entity types
                 // supported for the org
                 for (const recordQuery of fields) {
-                    recordQuery.resolve = function recordConnectionResolver(record, args) {
+                    recordQuery.resolve = async function recordConnectionResolver(record, args, { query }, info) {
+                        const { name: currentFieldName } = recordQuery;
+                        let ingestionTimestamp = 0;
+                        if (excludeStaleRecordsGate.isOpen({ fallback: false })) {
+                            // at our record query we fetch each ingestion time stamp and pass it down to each lower resolver to query against
+                            ingestionTimestamp = await fetchIngestionTimeStampFromDatabase(currentFieldName, info, args, query);
+                        }
                         // In the SF schema, the relevant arguments are passed into RecordQuery fields, but actually used
                         // down in the edge resolvers.  For this resolver, we can just return what was passed in
                         // to make it available to the next execution step
                         return {
                             parentArgs: args,
                             parentRecord: record,
-                            currentFieldName: recordQuery.name,
+                            currentFieldName,
+                            ingestionTimestamp,
                         };
                     };
                 }
@@ -52733,10 +53066,11 @@
                 // }
                 for (const field of fields) {
                     if (field.name === 'node') {
-                        field.resolve = function nodeResolver(record, _args, { seenRecordIds }) {
+                        field.resolve = function nodeResolver(obj, _args, { seenRecordIds }) {
+                            const { record, ingestionTimestamp } = obj;
                             const recordRepresentation = parse$3(record);
                             seenRecordIds.add(recordRepresentation.id);
-                            return recordRepresentation;
+                            return { recordRepresentation, ingestionTimestamp };
                         };
                     }
                 }
@@ -52759,40 +53093,40 @@
                 for (const field of fields) {
                     switch (field.name) {
                         case 'Id':
-                            field.resolve = (record) => record.id;
+                            field.resolve = ({ recordRepresentation: record }) => record.id;
                             break;
                         case 'ApiName':
-                            field.resolve = (record) => record.apiName;
+                            field.resolve = ({ recordRepresentation: record }) => record.apiName;
                             break;
                         case 'WeakEtag':
-                            field.resolve = (record) => record.weakEtag;
+                            field.resolve = ({ recordRepresentation: record }) => record.weakEtag;
                             break;
                         case '_drafts':
-                            field.resolve = (record) => {
+                            field.resolve = ({ recordRepresentation: record, }) => {
                                 return record.drafts ? record.drafts : null;
                             };
                             break;
                         case 'LastModifiedById':
-                            field.resolve = (record) => {
+                            field.resolve = ({ recordRepresentation: record }) => {
                                 return record.lastModifiedById
                                     ? { value: record.lastModifiedById }
                                     : null;
                             };
                             break;
                         case 'LastModifiedDate':
-                            field.resolve = (record) => {
+                            field.resolve = ({ recordRepresentation: record }) => {
                                 return record.lastModifiedDate
                                     ? { value: record.lastModifiedDate }
                                     : null;
                             };
                             break;
                         case 'SystemModstamp':
-                            field.resolve = (record) => {
+                            field.resolve = ({ recordRepresentation: record }) => {
                                 return record.systemModstamp ? { value: record.systemModstamp } : null;
                             };
                             break;
                         case 'RecordTypeId':
-                            field.resolve = (record) => {
+                            field.resolve = ({ recordRepresentation: record }) => {
                                 return record.recordTypeId ? { value: record.recordTypeId } : null;
                             };
                             break;
@@ -52804,7 +53138,17 @@
                                     .getInterfaces()
                                     .find((iface) => iface.name === 'Record')) ||
                                 (recordFieldType && recordFieldType.name === 'Record')) {
-                                field.resolve = function relationResolver(record, _args, { Record, seenRecordIds }) {
+                                field.resolve = async function relationResolver(obj, _args, { Record, seenRecordIds }) {
+                                    const fetchRecordOrNull = async (key) => {
+                                        const recordRepresentation = await Record.load(key);
+                                        return recordRepresentation !== null
+                                            ? {
+                                                recordRepresentation,
+                                                ingestionTimestamp,
+                                            }
+                                            : null;
+                                    };
+                                    const { recordRepresentation: record, ingestionTimestamp } = obj;
                                     const fieldName = field.name.endsWith('__r')
                                         ? field.name.replace('__r', '__c')
                                         : field.name;
@@ -52814,26 +53158,28 @@
                                     if (!id)
                                         return null;
                                     if (id['__ref'] !== undefined) {
-                                        return Record.load(record.fields[`${field.name}Id`].value);
+                                        return fetchRecordOrNull(record.fields[`${field.name}Id`].value);
                                     }
                                     seenRecordIds.add(id);
-                                    return Record.load(id);
+                                    return fetchRecordOrNull(id);
                                 };
                             }
                             else if (isObjectType(recordFieldType) &&
                                 field.type.name.endsWith('Connection')) {
                                 // spanning field to a connection
-                                field.resolve = (record, args, { seenRecordIds }) => {
-                                    seenRecordIds.add(record.id);
+                                field.resolve = async ({ recordRepresentation, ingestionTimestamp }, args, { seenRecordIds }) => {
+                                    seenRecordIds.add(recordRepresentation.id);
+                                    const { name: currentFieldName } = field;
                                     return {
                                         parentArgs: args,
-                                        parentRecord: record,
-                                        currentFieldName: field.name,
+                                        parentRecord: recordRepresentation,
+                                        currentFieldName,
+                                        ingestionTimestamp,
                                     };
                                 };
                             }
                             else {
-                                field.resolve = function recordFieldResolver(record) {
+                                field.resolve = function recordFieldResolver({ recordRepresentation: record, }) {
                                     return record.fields[field.name] || null;
                                 };
                             }
@@ -52845,7 +53191,7 @@
         if (recordInterface !== undefined && baseRecord !== undefined) {
             // Applys 'resolveType' of GraphQLInterfaceType to 'Record' interface. Since all the heterogenous types are named as 'apiName', the type with same name as the loaded record 'apiName' property is the type wanted.
             // GraphQL executor would  match InLineFragment' condition with type and keeps the deeper level field resolving going.
-            recordInterface.resolveType = function (value) {
+            recordInterface.resolveType = function ({ recordRepresentation: value, }) {
                 const targetType = polyTypes.find((type) => type.name === value.apiName);
                 return targetType === undefined ? baseRecord : targetType;
             };
@@ -52853,7 +53199,7 @@
         return schema;
     }
     async function connectionEdgeResolver(obj, _args, context) {
-        const { parentArgs = {}, parentRecord, currentFieldName } = obj;
+        const { parentArgs = {}, parentRecord, currentFieldName, ingestionTimestamp } = obj;
         const { query, objectInfos, draftFunctions } = context;
         let joins = [];
         let alias = currentFieldName;
@@ -52884,10 +53230,19 @@
             predicates,
             orderBy: orderByToPredicate(parentArgs.orderBy, alias, alias, context.objectInfos),
             limit: parentArgs.first,
+            ingestionTimestamp,
         };
         const { sql, bindings } = buildQuery(queryConfig);
         const results = await query(sql, bindings);
-        return results.rows.map((row) => row[0]);
+        //map each sql result with the ingestion timestamp to pass it down a level
+        return results.rows
+            .map((row) => row[0])
+            .map((record) => {
+            return {
+                record,
+                ingestionTimestamp,
+            };
+        });
     }
     /**
      * Converts a childRelationship into a predicate
@@ -52913,6 +53268,53 @@
         const interfaces = type.getInterfaces();
         return Boolean(interfaces.find((iface) => iface.name === 'Record'));
     }
+    /**
+     * Builds the top level record query key based on AST data
+     * @param operation
+     * @param variables
+     * @param argumentNodes
+     * @param currentFieldName
+     * @returns
+     */
+    function buildKeyStringForRecordQuery(variables, argumentNodes, currentFieldName) {
+        const filteredArgumentNodes = assign$3([], argumentNodes).filter((node) => node.name.value !== 'first' && node.name.value !== 'after');
+        const argumentString = filteredArgumentNodes.length > 0
+            ? `__${serializeFieldArguments$1(filteredArgumentNodes, variables)}`
+            : '';
+        return `UiApi::GraphQLRepresentation__uiapi__query__${currentFieldName}${argumentString}`;
+    }
+    /**
+     * fetches a query level ingestion time stamp from the L2 cache
+     * if no query has been seen then the timestamp is 0
+     * @param apiName
+     * @param info
+     * @param args
+     * @param query
+     * @returns
+     */
+    async function fetchIngestionTimeStampFromDatabase(apiName, info, args, query) {
+        const { variableValues } = info;
+        // if we cannot find the query key in the database then default to 0 as we assume we have not seen the query
+        // and all the data is not stale
+        let ingestionTimestamp = 0;
+        if (info.fieldNodes.length > 0 && info.fieldNodes[0].arguments !== undefined) {
+            const key = buildKeyStringForRecordQuery(
+            // join varables passed from query to the argument variables given from the AST
+            { ...variableValues, ...args }, info.fieldNodes[0].arguments, apiName);
+            const sql = `
+                    SELECT json_extract(metadata, '${JSON_EXTRACT_PATH_INGESTION_TIMESTAMP}') 
+                    FROM lds_data 
+                    WHERE key IS ?
+                    `;
+            const results = await query(sql, [key]);
+            const [timestamp] = results.rows.map((row) => row[0]);
+            if (timestamp !== null && typeof timestamp === 'number') {
+                //go back 10 ms to adjust for margin of error when top level query is stored and when raml objects are stored
+                ingestionTimestamp = timestamp - 10;
+            }
+        }
+        return ingestionTimestamp;
+    }
 
     const baseTypeDefinitions = /* GraphQL */ `
     schema {
@@ -55135,6 +55537,14 @@
     function getRecordKeyForId(luvio, recordId) {
         return keyBuilder$1Q(luvio, { recordId });
     }
+    /**
+     * Drafts are stored with denormalized fields and normalized field links. This method
+     * filters out the field links and returns a flattened record representation.
+     *
+     * Note that reference field links get re-applied during draft record ingestion
+     * @param record draft record representation
+     * @returns flattened record representation
+     */
     function filterOutReferenceFieldsAndLinks(record) {
         const filteredFields = {};
         const fieldNames = keys$2$1(record.fields);
@@ -55153,32 +55563,6 @@
         delete filteredRecords.links;
         return filteredRecords;
     }
-    async function resolveReferencesOneLevelDeep(record, getRecordFromKey) {
-        const fieldNames = keys$2$1(record.fields);
-        const resolvedFields = {};
-        for (const fieldName of fieldNames) {
-            const field = record.fields[fieldName];
-            if (isFieldLink(field)) {
-                const denormalizedRecord = await getRecordFromKey(field.value.__ref);
-                if (denormalizedRecord !== undefined) {
-                    resolvedFields[fieldName] = {
-                        value: filterOutReferenceFieldsAndLinks(denormalizedRecord),
-                        displayValue: null,
-                    };
-                }
-                else {
-                    resolvedFields[fieldName] = {
-                        value: null,
-                        displayValue: null,
-                    };
-                }
-            }
-            else {
-                resolvedFields[fieldName] = field;
-            }
-        }
-        return { ...record, fields: resolvedFields };
-    }
 
     /**
      * Checks if a resource request is a GET method on the record endpoint
@@ -55475,11 +55859,15 @@
      */
     function replayDraftsOnRecord(record, draftMetadata) {
         let objectInfo;
+        let luvio;
         if (record && draftMetadata) {
             objectInfo = draftMetadata.objectInfos.get(record.apiName);
         }
+        if (draftMetadata) {
+            luvio = draftMetadata.luvio;
+        }
         // remove drafts before reapply
-        const baseRecord = record === undefined ? undefined : removeDrafts(record, objectInfo);
+        const baseRecord = record === undefined ? undefined : removeDrafts(record, luvio, objectInfo);
         // record is a draft create
         if (baseRecord === undefined) {
             if (draftMetadata === undefined) {
@@ -55602,7 +55990,7 @@
      * @param record record with drafts applied
      * @returns
      */
-    function removeDrafts(record, objectInfo) {
+    function removeDrafts(record, luvio, objectInfo) {
         const { drafts, fields } = record;
         if (drafts === undefined) {
             return record;
@@ -55618,6 +56006,12 @@
             const originalField = drafts.serverValues[fieldName];
             if (originalField !== undefined) {
                 updatedFields[fieldName] = originalField;
+                if (objectInfo && luvio) {
+                    const reference = getReferenceInfoForKey(fieldName, originalField, luvio, objectInfo);
+                    if (reference) {
+                        updatedFields[reference.referenceFieldName] = reference.field;
+                    }
+                }
                 // restore the record type id on the root of the record
                 if (fieldName === DEFAULT_FIELD_RECORD_TYPE_ID) {
                     const originalRecordTypeId = originalField.value;
@@ -55655,7 +56049,6 @@
      * @param fields List of draft record fields
      */
     function buildRecordFieldValueRepresentationsFromDraftFields(luvio, apiName, fields, objectInfos, referencedRecords, formatDisplayValue) {
-        var _a;
         const fieldNames = keys$2$1(fields);
         const recordFields = {};
         const objectInfo = objectInfos.get(apiName);
@@ -55669,7 +56062,7 @@
             if (objectInfo !== undefined) {
                 const fieldInfo = objectInfo.fields[fieldName];
                 if (fieldInfo !== undefined) {
-                    const { dataType, relationshipName, referenceToInfos } = fieldInfo;
+                    const { dataType } = fieldInfo;
                     recordFields[fieldName].displayValue = formatDisplayValue(draftField, dataType);
                     if (dataType === 'DateTime' &&
                         draftField !== null &&
@@ -55681,46 +56074,6 @@
                             throw Error('date field value not valid');
                         }
                     }
-                    if (dataType === 'Reference' && relationshipName !== null && draftField !== null) {
-                        if (typeof draftField !== 'string') {
-                            throw Error('reference field value is not a string');
-                        }
-                        const key = getRecordKeyForId(luvio, draftField);
-                        const referencedRecord = referencedRecords.get(key);
-                        if (referencedRecord) {
-                            recordFields[relationshipName] = {
-                                displayValue: null,
-                                value: createLink$2(key),
-                            };
-                        }
-                        else {
-                            recordFields[relationshipName] = {
-                                displayValue: null,
-                                value: null,
-                            };
-                        }
-                        // for custom objects, we select the 'Name' field
-                        // otherwise we check the object info for name fields.
-                        //if there are multiple we select 'Name' if it exists, otherwise the first one
-                        if (referencedRecord !== undefined && referenceToInfos.length > 0) {
-                            let nameField;
-                            const referenceToInfo = referenceToInfos[0];
-                            const nameFields = referenceToInfo.nameFields;
-                            if (nameFields.length !== 0) {
-                                nameField = nameFields.find((x) => x === 'Name');
-                                if (nameField === undefined) {
-                                    nameField = nameFields[0];
-                                }
-                            }
-                            if (nameField !== undefined) {
-                                const nameFieldRef = referencedRecord.fields[nameField];
-                                if (nameFieldRef) {
-                                    recordFields[relationshipName].displayValue =
-                                        (_a = nameFieldRef.displayValue) !== null && _a !== void 0 ? _a : nameFieldRef.value;
-                                }
-                            }
-                        }
-                    }
                 }
             }
         }
@@ -55794,9 +56147,78 @@
             },
         };
     }
+    function applyReferenceLinksToDraft(record, draftMetadata) {
+        var _a;
+        const { objectInfos, referencedRecords, luvio } = draftMetadata;
+        const objectInfo = objectInfos.get(record.apiName);
+        if (objectInfo === undefined) {
+            return record;
+        }
+        let fieldNames = Object.keys(record.fields);
+        const recordFields = { ...record.fields };
+        for (const draftField of fieldNames) {
+            const fieldInfo = objectInfo.fields[draftField];
+            if (fieldInfo === undefined) {
+                continue;
+            }
+            const { dataType, relationshipName, referenceToInfos } = fieldInfo;
+            const draftFieldValue = record.fields[draftField].value;
+            if (dataType === 'Reference' && relationshipName !== null && draftFieldValue !== null) {
+                if (typeof draftFieldValue !== 'string') {
+                    throw Error('reference field value is not a string');
+                }
+                const key = getRecordKeyForId(luvio, draftFieldValue);
+                const referencedRecord = referencedRecords.get(key);
+                recordFields[relationshipName] = {
+                    displayValue: null,
+                    value: createLink$2(key),
+                };
+                // for custom objects, we select the 'Name' field
+                // otherwise we check the object info for name fields.
+                //if there are multiple we select 'Name' if it exists, otherwise the first one
+                if (referencedRecord !== undefined && referenceToInfos.length > 0) {
+                    let nameField;
+                    const referenceToInfo = referenceToInfos[0];
+                    const nameFields = referenceToInfo.nameFields;
+                    if (nameFields.length !== 0) {
+                        nameField = nameFields.find((x) => x === 'Name');
+                        if (nameField === undefined) {
+                            nameField = nameFields[0];
+                        }
+                    }
+                    if (nameField !== undefined) {
+                        const nameFieldRef = referencedRecord.fields[nameField];
+                        if (nameFieldRef) {
+                            recordFields[relationshipName].displayValue =
+                                (_a = nameFieldRef.displayValue) !== null && _a !== void 0 ? _a : nameFieldRef.value;
+                        }
+                    }
+                }
+            }
+        }
+        return { ...record, fields: recordFields };
+    }
     function createLink$2(key) {
         return { __ref: key };
     }
+    function getReferenceInfoForKey(fieldName, field, luvio, objectInfo) {
+        const { dataType, relationshipName } = objectInfo.fields[fieldName];
+        const draftFieldValue = field.value;
+        if (dataType === 'Reference' && relationshipName !== null && draftFieldValue !== null) {
+            if (typeof draftFieldValue !== 'string') {
+                throw Error('reference field value is not a string');
+            }
+            const key = getRecordKeyForId(luvio, draftFieldValue);
+            return {
+                referenceFieldName: relationshipName,
+                field: {
+                    displayValue: null,
+                    value: createLink$2(key),
+                },
+            };
+        }
+        return undefined;
+    }
 
     async function getAdapterData(adapter, config) {
         const snapshot = await adapter(config);
@@ -55941,8 +56363,7 @@
          *
          * @param action The draft action related to this record
          * @param _queue The draft queue
-         * @returns The record with the updated draft queue applied. This record is resolved with references one-level
-         * deep to ensure that reference links are properly established during ingestion to it
+         * @returns The record with the updated draft queue applied. References are not included and must be applied at ingest.
          *
          * or
          *
@@ -55966,7 +56387,7 @@
                 if (recordWithDrafts === undefined) {
                     return undefined;
                 }
-                return resolveReferencesOneLevelDeep(recordWithDrafts, this.durableStore.getDenormalizedRecord.bind(this.durableStore));
+                return filterOutReferenceFieldsAndLinks(recordWithDrafts);
             }
             const record = await this.durableStore.getDenormalizedRecord(key);
             if (record === undefined) {
@@ -55977,7 +56398,7 @@
             if (recordWithDrafts === undefined) {
                 return recordWithDrafts;
             }
-            return resolveReferencesOneLevelDeep(recordWithDrafts, this.durableStore.getDenormalizedRecord.bind(this.durableStore));
+            return filterOutReferenceFieldsAndLinks(recordWithDrafts);
         }
         applyDraftsToIncomingData(key, data, draftMetadata, publishData) {
             if (isField(key)) {
@@ -56004,19 +56425,26 @@
                 }
             }
             const recordWithDrafts = replayDraftsOnRecord(partialRecord, draftMetadata);
+            const recordWithSpanningRefLinks = applyReferenceLinksToDraft(recordWithDrafts, draftMetadata);
             // publish the normalized fields
             const normalizedRecord = {
-                ...recordWithDrafts,
+                ...recordWithSpanningRefLinks,
                 ...data,
                 fields: { ...data.fields },
             };
-            for (const fieldName of recordFieldNames) {
+            for (const fieldName of keys$2$1(recordWithSpanningRefLinks.fields)) {
                 const fieldKey = buildRecordFieldStoreKey(key, fieldName);
                 if (this.collectedFields[fieldKey] !== undefined) {
-                    const fieldData = recordWithDrafts.fields[fieldName];
+                    const fieldData = recordWithSpanningRefLinks.fields[fieldName];
                     normalizedRecord.fields[fieldName] = { __ref: fieldKey };
                     publishData(fieldKey, fieldData);
                 }
+                else if (recordWithSpanningRefLinks.fields[fieldName] &&
+                    recordWithSpanningRefLinks.fields[fieldName].value &&
+                    recordWithSpanningRefLinks.fields[fieldName].value.__ref !== undefined) {
+                    normalizedRecord.fields[fieldName] = { __ref: fieldKey };
+                    publishData(fieldKey, recordWithSpanningRefLinks.fields[fieldName]);
+                }
             }
             // publish the normalized record
             publishData(key, normalizedRecord);
@@ -56214,6 +56642,15 @@
             links,
         };
     }
+    function getDenormalizedKey(originalKey, recordId, luvio) {
+        // this will likely need to be handled when moving to structured keys
+        // note record view entities dont have an associated keybuilder. They get ingested as records to a different key format
+        // see the override for how they are handled packages/lds-adapters-uiapi/src/raml-artifacts/types/RecordRepresentation/keyBuilderFromType.ts
+        if (originalKey.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX)) {
+            return RECORD_VIEW_ENTITY_ID_PREFIX + recordId;
+        }
+        return keyBuilder$1Q(luvio, { recordId });
+    }
     function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecords, getStoreMetadata) {
         const getEntries = function (entries, segment) {
             // this HOF only inspects records in the default segment
@@ -56228,14 +56665,24 @@
             const filteredEntryIds = [];
             // map of records to avoid requesting duplicate record keys when requesting both records and fields
             const recordEntries = {};
+            const recordViewEntries = {};
             for (let i = 0, len = entriesLength; i < len; i++) {
                 const id = entries[i];
                 const recordId = extractRecordIdFromStoreKey(id);
                 if (recordId !== undefined) {
-                    if (recordEntries[recordId] === undefined) {
-                        const key = keyBuilder$1Q(luvio, { recordId });
-                        recordEntries[recordId] = true;
-                        filteredEntryIds.push(key);
+                    if (id.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX)) {
+                        if (recordViewEntries[recordId] === undefined) {
+                            const key = getDenormalizedKey(id, recordId, luvio);
+                            recordViewEntries[recordId] = true;
+                            filteredEntryIds.push(key);
+                        }
+                    }
+                    else {
+                        if (recordEntries[recordId] === undefined) {
+                            const key = getDenormalizedKey(id, recordId, luvio);
+                            recordEntries[recordId] = true;
+                            filteredEntryIds.push(key);
+                        }
                     }
                 }
                 else {
@@ -56269,6 +56716,7 @@
             const putEntries = create$2$1(null);
             const keys$1 = keys$2$1(entries);
             const putRecords = {};
+            const putRecordViews = {};
             const storeRecords = getStoreRecords !== undefined ? getStoreRecords() : {};
             const storeMetadata = getStoreMetadata !== undefined ? getStoreMetadata() : {};
             for (let i = 0, len = keys$1.length; i < len; i++) {
@@ -56277,10 +56725,18 @@
                 const recordId = extractRecordIdFromStoreKey(key);
                 // do not put normalized field values
                 if (recordId !== undefined) {
-                    const recordKey = keyBuilder$1Q(luvio, { recordId });
-                    if (putRecords[recordId] === true) {
-                        continue;
+                    const isRecordView = key.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX);
+                    if (isRecordView) {
+                        if (putRecordViews[recordId] === true) {
+                            continue;
+                        }
+                    }
+                    else {
+                        if (putRecords[recordId] === true) {
+                            continue;
+                        }
                     }
+                    const recordKey = getDenormalizedKey(key, recordId, luvio);
                     const recordEntries = entries;
                     const entry = recordEntries[recordKey];
                     let record = entry && entry.data;
@@ -56292,7 +56748,12 @@
                             continue;
                         }
                     }
-                    putRecords[recordId] = true;
+                    if (isRecordView) {
+                        putRecordViews[recordId] = true;
+                    }
+                    else {
+                        putRecords[recordId] = true;
+                    }
                     if (isStoreRecordError(record)) {
                         putEntries[recordKey] = value;
                         continue;
@@ -56370,6 +56831,19 @@
         });
     }
 
+    /**
+     * This function takes an unknown error and normalizes it to an Error object
+     */
+    function normalizeError$1(error) {
+        if (typeof error === 'object' && error instanceof Error) {
+            return error;
+        }
+        else if (typeof error === 'string') {
+            return new Error(error);
+        }
+        return new Error(stringify$2(error));
+    }
+
     const PERFORM_QUICK_ACTION_ENDPOINT_REGEX = /^\/ui-api\/actions\/perform-quick-action\/.*$/;
     /**
      * Checks if a provided resource request is a POST operation on the record
@@ -56388,7 +56862,7 @@
                 return env.dispatchResourceRequest(request, context, eventObservers);
             }
             const { data } = await handler.enqueue(request).catch((err) => {
-                throw createDraftSynthesisErrorResponse(err.message);
+                throw createDraftSynthesisErrorResponse(normalizeError$1(err).message);
             });
             if (data === undefined) {
                 return Promise.reject(createDraftSynthesisErrorResponse());
@@ -56725,7 +57199,7 @@
         return `UiApi::GraphQLRepresentation:${Date.now() + Math.random().toFixed(5).split('.')[1]}`;
     }
     // Recursively replace draft ids with canonical ids
-    const replaceDraftIdsInVariables = (variables, draftFunctions, unmappedDraftIDs) => {
+    const replaceDraftIdsInVariables$1 = (variables, draftFunctions, unmappedDraftIDs) => {
         const replace = (object) => {
             if (typeof object === 'string') {
                 if (!draftFunctions.isDraftId(object)) {
@@ -56782,7 +57256,7 @@
                     unmappedDraftIDs,
                 } = await injectSyntheticFields(copy, objectInfoService, draftFunctions, config.variables));
                 if (config.variables) {
-                    config.variables = replaceDraftIdsInVariables(config.variables, draftFunctions, unmappedDraftIDs);
+                    config.variables = replaceDraftIdsInVariables$1(config.variables, draftFunctions, unmappedDraftIDs);
                 }
             }
             catch (throwable) {
@@ -56815,6 +57289,7 @@
                     query: injectedAST,
                 },
                 luvio,
+                gqlEval: true,
             }, buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy));
             if (isErrorSnapshotThatShouldGetReturnedToCaller(nonEvaluatedSnapshot)) {
                 return nonEvaluatedSnapshot;
@@ -57143,27 +57618,10 @@
             if (contentVersion === undefined) {
                 return undefined;
             }
-            // this lambda can be shared across the calls to resolveReferencesOneLevelDeep
-            const luvio = this.getLuvio();
-            const contentDocumentKey = getRecordKeyForId(luvio, contentDocumentId);
-            const contentDocumentLinkKey = getRecordKeyForId(luvio, contentDocumentLinkId);
-            const contentVersionKey = getRecordKeyForId(luvio, contentVersionId);
-            const getRecordFromKey = async (key) => {
-                if (key === contentDocumentKey) {
-                    return contentDocRecord;
-                }
-                if (key === contentDocumentLinkKey) {
-                    return contentDocLink;
-                }
-                if (key === contentVersionKey) {
-                    return contentVersion;
-                }
-                return this.durableStore.getDenormalizedRecord(key);
-            };
             // finally we resolve all references for each record
-            const contentDocResolved = await resolveReferencesOneLevelDeep(contentDocRecord, getRecordFromKey);
-            const contentDocLinkResolved = await resolveReferencesOneLevelDeep(contentDocLink, getRecordFromKey);
-            const contentVersionResolved = await resolveReferencesOneLevelDeep(contentVersion, getRecordFromKey);
+            const contentDocResolved = await filterOutReferenceFieldsAndLinks(contentDocRecord);
+            const contentDocLinkResolved = await filterOutReferenceFieldsAndLinks(contentDocLink);
+            const contentVersionResolved = await filterOutReferenceFieldsAndLinks(contentVersion);
             return {
                 contentDocument: contentDocResolved,
                 contentDocumentLinks: [contentDocLinkResolved],
@@ -57942,6 +58400,10 @@
     }
 
     const MAX_STRING_LENGTH_PER_CHUNK = 10000;
+    //Salesforce/Akamai cdn uri max size is 8898 bytes, short than normal. Per
+    //https://help.salesforce.com/s/articleView?id=sf.community_builder_cdn_considerations.htm&type=5
+    //Due to we don't know the domain ResourceRequest, here we give 8000
+    const MAX_URL_LENGTH = 8000;
     const PARSE_ERROR = 'PARSE_AGGREGATE_UI_RESPONSE_ERROR';
     function isErrorResponse(response) {
         return response.httpStatusCode >= 400;
@@ -58020,8 +58482,8 @@
         }
         return `${resourceRequest.baseUri}${resourceRequest.basePath}?${join$1.call(queryString, '&')}`;
     }
-    function shouldUseAggregateUiForFields(fieldsArray, optionalFieldsArray) {
-        return fieldsArray.length + optionalFieldsArray.length >= MAX_STRING_LENGTH_PER_CHUNK;
+    function shouldUseAggregateUiForFields(fieldsArray, optionalFieldsArray, maxLengthPerChunk) {
+        return fieldsArray.length + optionalFieldsArray.length >= maxLengthPerChunk;
     }
     function isSpanningRecord(fieldValue) {
         return fieldValue !== null && typeof fieldValue === 'object';
@@ -58084,14 +58546,15 @@
         if (fieldsArray.length === 0 && optionalFieldsArray.length === 0) {
             return undefined;
         }
+        const allowedMaxStringLengthPerChunk = getMaxLengthPerChunkAllowed(resourceRequest);
         const fieldsString = fieldsArray.join(',');
         const optionalFieldsString = optionalFieldsArray.join(',');
-        const shouldUseAggregate = shouldUseAggregateUiForFields(fieldsString, optionalFieldsString);
+        const shouldUseAggregate = shouldUseAggregateUiForFields(fieldsString, optionalFieldsString, allowedMaxStringLengthPerChunk);
         if (!shouldUseAggregate) {
             return undefined;
         }
-        const fieldCollection = ScopedFieldsCollection.fromQueryParameterValue(fieldsString).split(MAX_STRING_LENGTH_PER_CHUNK);
-        const optionalFieldCollection = ScopedFieldsCollection.fromQueryParameterValue(optionalFieldsString).split(MAX_STRING_LENGTH_PER_CHUNK);
+        const fieldCollection = ScopedFieldsCollection.fromQueryParameterValue(fieldsString).split(allowedMaxStringLengthPerChunk);
+        const optionalFieldCollection = ScopedFieldsCollection.fromQueryParameterValue(optionalFieldsString).split(allowedMaxStringLengthPerChunk);
         return {
             fieldCollection,
             optionalFieldCollection,
@@ -58164,6 +58627,25 @@
     function arrayOrEmpty(array) {
         return array !== undefined && isArray$7(array) ? array : [];
     }
+    /**
+     * Calculate the max lengh per chunk.
+     * If useShortUrlGate is open, allow max chunk size is MAX_URL_LENGTH - the url without fields and optional fields in url.
+     * Otherwise MAX_STRING_LENGTH_PER_CHUNK
+     * @param resourceRequest
+     * @returns
+     */
+    function getMaxLengthPerChunkAllowed(request) {
+        if (!ldsUseShortUrlGate.isOpen({ fallback: false })) {
+            return MAX_STRING_LENGTH_PER_CHUNK;
+        }
+        // Too much work to get exact length of the final url, so use stringified json to get the rough length.
+        const roughUrlLengthWithoutFieldsAndOptionFields = request.basePath.length +
+            request.baseUri.length +
+            (request.urlParams ? stringify$1$1(request.urlParams).length : 0) +
+            stringify$1$1({ ...request.queryParams, fields: {}, optionalFields: {} }).length;
+        // MAX_URL_LENGTH  - full lenght without fields, optionalFields
+        return MAX_URL_LENGTH - roughUrlLengthWithoutFieldsAndOptionFields;
+    }
 
     const RECORD_ENDPOINT_REGEX = /^\/ui-api\/records\/?(([a-zA-Z0-9]+))?$/;
     const referenceId$3 = 'LDS_Records_AggregateUi';
@@ -58368,7 +58850,7 @@
         }, networkAdapter);
     }
 
-    const { keys: keys$7, create: create$6, assign: assign$5, entries } = Object;
+    const { keys: keys$8, create: create$6, assign: assign$6, entries } = Object;
     const { stringify: stringify$6, parse: parse$6 } = JSON;
     const { push, join, slice } = Array.prototype;
 
@@ -58384,15 +58866,15 @@
         enqueue(handlerId, data) {
             const callProxyMethod = __nimbus.plugins.LdsDraftQueue.callProxyMethod;
             if (callProxyMethod === undefined) {
-                return Promise.reject('callProxyMethod not defined on the nimbus plugin');
+                return Promise.reject(new Error('callProxyMethod not defined on the nimbus plugin'));
             }
             const serializedAction = stringify$6([handlerId, data]);
             return new Promise((resolve, reject) => {
                 callProxyMethod('enqueue', serializedAction, (serializedActionResponse) => {
                     const response = parse$6(serializedActionResponse);
                     resolve(response);
-                }, (serializedError) => {
-                    reject(parse$6(serializedError));
+                }, (errorMessage) => {
+                    reject(new Error(errorMessage));
                 });
             });
         }
@@ -58402,18 +58884,18 @@
             return Promise.resolve;
         }
         processNextAction() {
-            return Promise.reject('Cannot call processNextAction from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call processNextAction from the NimbusDraftQueue'));
         }
         getQueueActions() {
             const callProxyMethod = __nimbus.plugins.LdsDraftQueue.callProxyMethod;
             if (callProxyMethod === undefined) {
-                return Promise.reject('callProxyMethod not defined on the nimbus plugin');
+                return Promise.reject(new Error('callProxyMethod not defined on the nimbus plugin'));
             }
             return new Promise((resolve, reject) => {
                 callProxyMethod('getQueueActions', stringify$6([]), (serializedQueue) => {
                     resolve(parse$6(serializedQueue));
-                }, (serializedError) => {
-                    reject(parse$6(serializedError));
+                }, (errorMessage) => {
+                    reject(new Error(errorMessage));
                 });
             });
         }
@@ -58441,32 +58923,32 @@
             throw new Error('Cannot call getQueueState from the NimbusDraftQueue');
         }
         removeDraftAction(_actionId) {
-            return Promise.reject('Cannot call removeDraftAction from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call removeDraftAction from the NimbusDraftQueue'));
         }
         startQueue() {
-            return Promise.reject('Cannot call startQueue from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call startQueue from the NimbusDraftQueue'));
         }
         stopQueue() {
-            return Promise.reject('Cannot call stopQueue from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call stopQueue from the NimbusDraftQueue'));
         }
         replaceAction(_actionId, _withActionId) {
-            return Promise.reject('Cannot call replaceAction from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call replaceAction from the NimbusDraftQueue'));
         }
         mergeActions(_targetActionId, _sourceActionId) {
-            return Promise.reject('Cannot call mergeActions from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call mergeActions from the NimbusDraftQueue'));
         }
         setMetadata(_actionId, _metadata) {
-            return Promise.reject('Cannot call setMetadata from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call setMetadata from the NimbusDraftQueue'));
         }
         addHandler(_handler) {
             // no-op -- all registration occurs against concrete draft queue
             return Promise.resolve();
         }
         addCustomHandler(_id, _executor) {
-            return Promise.reject('Cannot call setMetadata from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call setMetadata from the NimbusDraftQueue'));
         }
         removeHandler(_id) {
-            return Promise.reject('Cannot call setMetadata from the NimbusDraftQueue');
+            return Promise.reject(new Error('Cannot call setMetadata from the NimbusDraftQueue'));
         }
     }
 
@@ -58489,7 +58971,7 @@
      * @param err Unknown object to sanitize
      * @returns an instance of error
      */
-    function normalizeError$1(err) {
+    function normalizeError$2(err) {
         if (err instanceof Error) {
             return err;
         }
@@ -58501,13 +58983,13 @@
     const DRAFT_QUEUE_TOTAL_MERGE_ACTIONS_CALLS = 'draft-queue-total-mergeActions-calls';
     const DRAFT_AWARE_CREATE_CONTENT_DOCUMENT_AND_VERSION_ERROR = 'draft-aware-create-content-document-and-version-error';
     function reportGraphqlQueryParseError(err) {
-        normalizeError$1(err);
+        normalizeError$2(err);
     }
     function reportGraphqlSqlEvalPreconditionError(err) {
-        normalizeError$1(err);
+        normalizeError$2(err);
     }
     function reportGraphqlCreateSnapshotError(err) {
-        normalizeError$1(err);
+        normalizeError$2(err);
     }
     function reportGraphQlEvalDbReadDuration(duration) {
     }
@@ -58517,7 +58999,7 @@
             error = err.body;
         }
         else {
-            error = normalizeError$1(err);
+            error = normalizeError$2(err);
         }
         const errorCode = DRAFT_AWARE_CREATE_CONTENT_DOCUMENT_AND_VERSION_ERROR;
         const errorType = error.errorType;
@@ -58546,7 +59028,7 @@
         const { tags, metricName, logError } = config;
         return operation()
             .catch((err) => {
-            const error = normalizeError$1(err);
+            const error = normalizeError$2(err);
             tags['errorMessage'] = error.message;
             throw err;
         })
@@ -58928,7 +59410,7 @@
                 },
                 conflictColumns: this.conflictColumnNames,
                 columns: this.columnNames,
-                rows: keys$7(entries).reduce((rows, key) => {
+                rows: keys$8(entries).reduce((rows, key) => {
                     const entry = entries[key];
                     const { data, metadata } = entry;
                     const row = [key, stringify$6(data), metadata ? stringify$6(metadata) : null];
@@ -58989,7 +59471,7 @@
                 },
                 conflictColumns: this.conflictColumnNames,
                 columns: this.columnNames,
-                rows: keys$7(entries).reduce((rows, key) => {
+                rows: keys$8(entries).reduce((rows, key) => {
                     const entry = entries[key];
                     rows.push([key, stringify$6(entry.data)]);
                     return rows;
@@ -59074,7 +59556,7 @@
                 },
                 conflictColumns: this.conflictColumnNames,
                 columns: this.columnNames,
-                rows: keys$7(entries).reduce((rows, key) => {
+                rows: keys$8(entries).reduce((rows, key) => {
                     const entry = entries[key];
                     const { data, metadata } = entry;
                     const row = [key, stringify$6(data)];
@@ -59158,7 +59640,7 @@
         registerOnChangedListener(listener) {
             let unsubscribeId = undefined;
             this.plugin
-                .registerOnChangedListener((changes) => {
+                .registerOnChangedListener(async (changes) => {
                 const durableChanges = changes.map((c) => {
                     return {
                         type: c.type === 'upsert' ? 'setEntries' : 'evictEntries',
@@ -59167,7 +59649,7 @@
                         segment: c.context.segment,
                     };
                 });
-                listener(durableChanges);
+                await listener(durableChanges);
             })
                 .then((unsub) => {
                 unsubscribeId = unsub;
@@ -59273,8 +59755,17 @@
         }
     }
 
-    //TODO: [W-12734162] - rebuild non-evaluated snapshot when graph rebuild is triggered. The dependency work on luvio needs to be done.
+    function isUnfulfilledSnapshot(cachedSnapshotResult) {
+        if (cachedSnapshotResult === undefined) {
+            return false;
+        }
+        if ('then' in cachedSnapshotResult) {
+            return false;
+        }
+        return cachedSnapshotResult.state === 'Unfulfilled';
+    }
     function makeEnvironmentGraphqlAware(environment) {
+        //TODO: [W-12734162] - rebuild non-evaluated snapshot when graph rebuild is triggered. The dependency work on luvio needs to be done.
         const rebuildSnapshot = function (snapshot, onRebuild) {
             if (isStoreEvalSnapshot(snapshot)) {
                 snapshot.rebuildWithStoreEval(snapshot).then((rebuilt) => {
@@ -59290,8 +59781,72 @@
             }
             return environment.rebuildSnapshot(snapshot, onRebuild);
         };
+        const applyCachePolicy = function (luvio, adapterRequestContext, buildSnapshotContext, buildCachedSnapshot, buildNetworkSnapshot) {
+            // Early exit for non-evaluating adapters
+            let graphqlBuildSnapshotContext = buildSnapshotContext;
+            if (graphqlBuildSnapshotContext.gqlEval !== true) {
+                return environment.applyCachePolicy(luvio, adapterRequestContext, buildSnapshotContext, buildCachedSnapshot, buildNetworkSnapshot);
+            }
+            var localBuildCachedSnapshot = buildCachedSnapshot;
+            const hoistUnfulfilledToStale = (context, storeLookup, luvio) => {
+                const upstream = buildCachedSnapshot(context, storeLookup, luvio);
+                if (upstream === undefined)
+                    return upstream;
+                if (isUnfulfilledSnapshot(upstream)) {
+                    return {
+                        ...upstream,
+                        data: upstream.data || {},
+                        state: 'Stale',
+                    };
+                }
+                else if ('then' in upstream) {
+                    return upstream.then((snapshot) => {
+                        if (snapshot === undefined)
+                            return snapshot;
+                        if (isUnfulfilledSnapshot(snapshot)) {
+                            return {
+                                ...snapshot,
+                                data: snapshot.data || {},
+                                state: 'Stale',
+                            };
+                        }
+                        return snapshot;
+                    });
+                }
+                return upstream;
+            };
+            const { cachePolicy } = adapterRequestContext;
+            if (eagerEvalValidAt.isOpen({ fallback: false }) &&
+                cachePolicy &&
+                cachePolicy.type === 'valid-at' &&
+                cachePolicy.timestamp === 0 &&
+                cachePolicy.basePolicy &&
+                cachePolicy.basePolicy.type === 'stale-while-revalidate') {
+                localBuildCachedSnapshot = hoistUnfulfilledToStale;
+            }
+            if (eagerEvalStaleWhileRevalidate.isOpen({ fallback: false }) &&
+                cachePolicy &&
+                cachePolicy.type === 'stale-while-revalidate' &&
+                cachePolicy.staleDurationSeconds >= Number.MAX_SAFE_INTEGER) {
+                localBuildCachedSnapshot = hoistUnfulfilledToStale;
+            }
+            if (eagerEvalDefaultCachePolicy.isOpen({ fallback: false }) &&
+                (cachePolicy === undefined || cachePolicy === null)) {
+                localBuildCachedSnapshot = hoistUnfulfilledToStale;
+            }
+            return environment.applyCachePolicy(luvio, adapterRequestContext, buildSnapshotContext, localBuildCachedSnapshot, buildNetworkSnapshot);
+        };
         return create$6(environment, {
             rebuildSnapshot: { value: rebuildSnapshot },
+            applyCachePolicy: { value: applyCachePolicy },
+            defaultCachePolicy: {
+                get() {
+                    return environment.defaultCachePolicy;
+                },
+                set(value) {
+                    environment.defaultCachePolicy = value;
+                },
+            },
         });
     }
 
@@ -59940,8 +60495,17 @@
             lazyObjectInfoService = new ObjectInfoService(getObjectInfo, getObjectInfos, internalAdapterDurableStore);
             // set storeEval function for lds-adapters-graghql to use
             withRegistration('@salesforce/lds-adapters-graphql', (registration) => {
-                const { configuration: { setStoreEval }, } = registration;
-                setStoreEval(sqliteStoreEvalFactory(userId, lazyBaseDurableStore, lazyObjectInfoService));
+                const { configuration: { setStoreEval, setDraftFunctions }, } = registration;
+                const getCanonicalId = (id) => {
+                    var _a;
+                    return ((_a = extractRecordIdFromStoreKey(lazyLuvio.storeGetCanonicalKey(RECORD_ID_PREFIX + id))) !== null && _a !== void 0 ? _a : id);
+                };
+                const draftFuncs = {
+                    isDraftId: isGenerated,
+                    getCanonicalId,
+                };
+                setStoreEval(sqliteStoreEvalFactory(userId, lazyBaseDurableStore, lazyObjectInfoService, draftFuncs));
+                setDraftFunctions(draftFuncs);
             });
             // creates a durable store that denormalizes scalar fields for records
             let getIngestRecords;
@@ -60030,7 +60594,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$1,
     });
-    // version: 1.130.10-0fac4c295
+    // version: 1.131.0-dev11-b15472a13
 
     const { create: create$2, keys: keys$2 } = Object;
     const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -74338,7 +74902,7 @@
         configuration: { ...configurationForGraphQLAdapters },
         instrument,
     });
-    // version: 1.130.10-b649bb8d1
+    // version: 1.131.0-dev11-734408c01
 
     // On core the unstable adapters are re-exported with different names,
 
@@ -75729,10 +76293,14 @@
     }
 
     let storeEval = undefined;
+    let draftFunctions = undefined;
     const configuration = {
         setStoreEval: function (storeEvalArg) {
             storeEval = storeEvalArg;
         },
+        setDraftFunctions: function (draftFuncs) {
+            draftFunctions = draftFuncs;
+        },
     };
 
     const assignedToMe = {
@@ -75818,6 +76386,78 @@
     function injectFieldsGQL(ast) {
         return injectScopeFields(ast);
     }
+    function swapIdsOfDocumentNode(documentnode, draftFunctions) {
+        const recordNodes = findRecordSelections(documentnode);
+        recordNodes.forEach((recordConnection) => {
+            swapIdsOfFieldNode(recordConnection, draftFunctions);
+        });
+        return documentnode;
+    }
+    function swapIdsOfFieldNode(selectionNode, draftFunctions) {
+        if (isCustomFieldNode(selectionNode) &&
+            selectionNode.type === 'Connection' &&
+            selectionNode.arguments !== undefined &&
+            selectionNode.arguments.some((argment) => argment.name === 'where')) {
+            const swappedArguments = selectionNode.arguments.map((argument) => {
+                if (argument.name === 'where') {
+                    return {
+                        ...argument,
+                        value: swapIdsOfValueNode(argument.value, draftFunctions.isDraftId, draftFunctions.getCanonicalId),
+                    };
+                }
+                else {
+                    return argument;
+                }
+            });
+            selectionNode.arguments = swappedArguments;
+        }
+        if (selectionNode.luvioSelections !== undefined) {
+            for (const childSelectionNode of selectionNode.luvioSelections) {
+                if (isCustomFieldNode(childSelectionNode) ||
+                    isObjectFieldSelection(childSelectionNode)) {
+                    swapIdsOfFieldNode(childSelectionNode, draftFunctions);
+                }
+            }
+        }
+    }
+    function swapIdsOfValueNode(valueNode, isDraftId, idMapper) {
+        switch (valueNode.kind) {
+            case Kind.OBJECT: {
+                const swappedObjectValueNode = {};
+                for (const key of keys(valueNode.fields)) {
+                    swappedObjectValueNode[key] = swapIdsOfValueNode(valueNode.fields[key], isDraftId, idMapper);
+                }
+                return {
+                    kind: 'ObjectValue',
+                    fields: swappedObjectValueNode,
+                };
+            }
+            case Kind.LIST: {
+                const listValueNodes = [];
+                for (const child of valueNode.values) {
+                    listValueNodes.push(swapIdsOfValueNode(child, isDraftId, idMapper));
+                }
+                return {
+                    kind: 'ListValue',
+                    values: listValueNodes,
+                };
+            }
+            case Kind.STRING: {
+                if (!isDraftId(valueNode.value)) {
+                    return valueNode;
+                }
+                return {
+                    kind: 'StringValue',
+                    value: idMapper(valueNode.value),
+                    block: false,
+                };
+            }
+            default:
+                return {
+                    ...valueNode,
+                };
+        }
+    }
     function injectScopeFields(ast) {
         const modifiedDocumentNode = {
             kind: 'Document',
@@ -76398,6 +77038,34 @@
         }
         return buildNetworkSnapshot(luvio, config, fragment, dispatchOptions);
     }
+    const replaceDraftIdsInVariables = (variables, draftFunctions) => {
+        const replace = (object) => {
+            if (typeof object === 'string') {
+                if (!draftFunctions.isDraftId(object)) {
+                    return object;
+                }
+                return draftFunctions.getCanonicalId(object);
+            }
+            else if (isArray(object)) {
+                return object.map(replace);
+            }
+            else if (typeof object === 'object' && object !== null) {
+                let source = object;
+                return keys(source).reduce((acc, key) => {
+                    acc[key] = replace(source[key]);
+                    return acc;
+                }, {});
+            }
+            else {
+                return object;
+            }
+        };
+        let newVariables = keys(variables).reduce((acc, key) => {
+            acc[key] = replace(variables[key]);
+            return acc;
+        }, {});
+        return newVariables;
+    };
     const graphQLAdapterFactory = (luvio) => {
         const uiApiGraphQLAdapter = factory$1(luvio);
         function graphql(untrustedConfig, requestContext) {
@@ -76422,19 +77090,33 @@
                 const validatedConfigWithInjection = fieldInjectionRequired
                     ? graphqlConfigWithInjectedAST(validatedConfig)
                     : validatedConfig;
-                const fragment = createFragment(luvio, validatedConfigWithInjection.query, variables);
+                const sanitizedConfig = draftFunctions !== undefined
+                    ? sanitizeConfig(validatedConfigWithInjection, draftFunctions)
+                    : validatedConfigWithInjection;
+                if (sanitizedConfig.variables && draftFunctions !== undefined) {
+                    const variablesWithSwappedDraftIds = replaceDraftIdsInVariables(sanitizedConfig.variables, draftFunctions);
+                    sanitizedConfig.variables = variablesWithSwappedDraftIds;
+                    validatedConfig.variables = variablesWithSwappedDraftIds;
+                }
+                const fragment = createFragment(luvio, sanitizedConfig.query, sanitizedConfig.variables);
                 const context = {
-                    config: validatedConfigWithInjection,
+                    config: sanitizedConfig,
                     fragment,
                     luvio,
                 };
+                // NOTE: For evaluating environments, set a context property to let the
+                // environment detect that eval will happen and to check varous gates
+                // for eval behavior customizations.
+                if (storeEval !== undefined) {
+                    context.gqlEval = true;
+                }
                 const snapshotOrPromiseFromCachePolicy = luvio.applyCachePolicy(requestContext || {}, context, buildCachedSnapshot, buildNetworkSnapshotCachePolicy);
                 if (storeEval !== undefined) {
                     const observers = requestContext && requestContext.eventObservers
                         ? requestContext.eventObservers
                         : [];
-                    // uses the original ast to do the eval to avoid fields not needed by users
-                    return storeEval(validatedConfig, snapshotOrPromiseFromCachePolicy, observers);
+                    // uses the original ast to do the eval to avoid fields not needed by users. The draftID swapping happens when filters transform to predicates.
+                    return storeEval(validatedConfig, snapshotOrPromiseFromCachePolicy, observers, keyBuilder);
                 }
                 return snapshotOrPromiseFromCachePolicy;
             }
@@ -76450,6 +77132,15 @@
             query: modifiedAST,
         };
     }
+    function sanitizeConfig(graphqlConfig, draftFunctions) {
+        const { query } = graphqlConfig;
+        const astCopy = parse(stringify(query));
+        const modifiedAST = swapIdsOfDocumentNode(astCopy, draftFunctions);
+        return {
+            ...graphqlConfig,
+            query: modifiedAST,
+        };
+    }
     // make sure to register the configuration whenever this module loads
     register({ id: '@salesforce/lds-adapters-graphql', configuration });
 
@@ -76467,7 +77158,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.130.10-b649bb8d1
+    // version: 1.131.0-dev11-734408c01
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -76619,7 +77310,7 @@
             cachePolicy: buildCachePolicy(cachePolicy),
             priority,
         };
-        if (observabilityContext !== undefined) {
+        if (observabilityContext !== undefined && observabilityContext !== null) {
             requestContext.requestCorrelator = {
                 observabilityContext,
             };
@@ -77077,24 +77768,21 @@
      * to the instance of the lds-drafts' DraftQueue implementation
      */
     const nimbusDraftQueue = {
-        callProxyMethod(methodName, serializedArgsArray, resultCallback, errorCallback) {
+        callProxyMethod(methodName, serializedArgsArray, resultCallback, 
+        // NOTE: the other side of the proxy is expecting an error message string
+        // (not a JSON serialized Error object)
+        errorCallback) {
             const method = draftQueue[methodName];
             if (method === undefined) {
-                return errorCallback(stringify$1({
-                    message: 'Method does not exist on the draft queue',
-                }));
+                return errorCallback('Method does not exist on the draft queue');
             }
             if (allowList.includes(methodName) === false) {
-                return errorCallback(stringify$1({
-                    message: `Method ${methodName} is not available for proxy invocation`,
-                }));
+                return errorCallback(`Method ${methodName} is not available for proxy invocation`);
             }
             const parsedArgs = parse$1(serializedArgsArray);
             // TODO [W-9933226]: we should validate the argument list based on which method is being called
             if (isArray$1(parsedArgs) === false) {
-                return errorCallback(stringify$1({
-                    message: 'expected array argument list',
-                }));
+                return errorCallback('expected array argument list');
             }
             let methodResult = undefined;
             try {
@@ -77106,7 +77794,7 @@
                 }
             }
             catch (err) {
-                return errorCallback(stringify$1(err));
+                return errorCallback(normalizeError(err).message);
             }
             if (methodResult.then === undefined) {
                 return resultCallback(stringify$1(methodResult));
@@ -77116,7 +77804,7 @@
                 resultCallback(stringify$1(result));
             })
                 .catch((err) => {
-                errorCallback(stringify$1(err));
+                errorCallback(normalizeError(err).message);
             });
         },
     };
@@ -77176,4 +77864,4 @@
     Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-// version: 1.130.10-0fac4c295
+// version: 1.131.0-dev11-b15472a13