@salesforce/lds-runtime-mobile 1.130.9 → 1.131.0-dev10

package/dist/main.js

@@ -14,10 +14,12 @@
 import { withRegistration, register } from '@salesforce/lds-default-luvio';
 import { setupInstrumentation, instrumentAdapter as instrumentAdapter$1, instrumentLuvio, setLdsAdaptersUiapiInstrumentation, setLdsNetworkAdapterInstrumentation } from '@salesforce/lds-instrumentation';
 import { HttpStatusCode, StoreKeyMap, buildStaleWhileRevalidateImplementation, StoreKeySet, serializeStructuredKey, Reader, emitAdapterEvent, createCustomAdapterEventEmitter, isFileReference, Environment, Luvio, InMemoryStore } from '@luvio/engine';
+import excludeStaleRecordsGate from '@salesforce/gate/lds.graphqlEvalExcludeStaleRecords';
 import { parseAndVisit, Kind, visit, execute, buildSchema, isObjectType, defaultFieldResolver } from '@luvio/graphql-parser';
-import { getRecordId18, keyBuilderQuickActionExecutionRepresentation, ingestQuickActionExecutionRepresentation, keyBuilderContentDocumentCompositeRepresentation, getResponseCacheKeysContentDocumentCompositeRepresentation, keyBuilderFromTypeContentDocumentCompositeRepresentation, ingestContentDocumentCompositeRepresentation, keyBuilderRecord, getTypeCacheKeysRecord, keyBuilderFromTypeRecordRepresentation, ingestRecord, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getRecordAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationTTL, RecordRepresentationVersion } from '@salesforce/lds-adapters-uiapi';
+import { getRecordId18, serializeFieldArguments, keyBuilderQuickActionExecutionRepresentation, ingestQuickActionExecutionRepresentation, keyBuilderContentDocumentCompositeRepresentation, getResponseCacheKeysContentDocumentCompositeRepresentation, keyBuilderFromTypeContentDocumentCompositeRepresentation, ingestContentDocumentCompositeRepresentation, keyBuilderRecord, getTypeCacheKeysRecord, keyBuilderFromTypeRecordRepresentation, ingestRecord, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getRecordAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationTTL, RecordRepresentationVersion } from '@salesforce/lds-adapters-uiapi';
 import caseSensitiveUserId from '@salesforce/user/Id';
 import { idleDetector, getInstrumentation } from 'o11y/client';
+import ldsUseShortUrlGate from '@salesforce/gate/lds.useShortUrl';
 import { instrument as instrument$1 } from '@salesforce/lds-bindings';
 import LOCALE from '@salesforce/i18n/locale';
 import CURRENCY from '@salesforce/i18n/currency';
@@ -27,6 +29,9 @@ import shortTimeFormat from '@salesforce/i18n/dateTime.shortTimeFormat';
 import shortDateTimeFormat from '@salesforce/i18n/dateTime.shortDateTimeFormat';
 import { getDateTimeFormat, getDateTimeISO8601Parser, getNumberFormat } from 'lightning/i18nService';
 import formattingOptions from 'lightning/i18nCldrOptions';
+import eagerEvalValidAt from '@salesforce/gate/lds.eagerEvalValidAt';
+import eagerEvalStaleWhileRevalidate from '@salesforce/gate/lds.eagerEvalStaleWhileRevalidate';
+import eagerEvalDefaultCachePolicy from '@salesforce/gate/lds.eagerEvalDefaultCachePolicy';
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -37,7 +42,7 @@ import formattingOptions from 'lightning/i18nCldrOptions';
 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';
 
@@ -102,7 +107,7 @@ function isSpanningRecord$1(fieldValue) {
 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];
@@ -515,8 +520,9 @@ function isDeprecatedDurableStoreEntry(durableRecord) {
     return false;
 }
 const DefaultDurableSegment = 'DEFAULT';
+const RedirectDurableSegment = 'REDIRECT_KEYS';
 
-const { keys: keys$5, create: create$5, assign: assign$4, freeze: freeze$1 } = Object;
+const { keys: keys$6, create: create$5, assign: assign$5, freeze: freeze$1 } = Object;
 const { isArray: isArray$5 } = Array;
 
 //Durable store error instrumentation key
@@ -554,7 +560,7 @@ function deepFreeze(value) {
         }
     }
     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(value[keys$1[i]]);
         }
@@ -577,13 +583,13 @@ function isStoreEntryError(storeRecord) {
  * @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 };
@@ -615,7 +621,7 @@ function publishDurableStoreEntries(durableRecords, publish, publishMetadata) {
             // freeze errors on way into L1
             deepFreeze(data.error);
         }
-        publish(key, data);
+        put(key, data);
         revivedKeys.add(key);
     }
     return { revivedKeys, hadUnexpectedShape };
@@ -655,7 +661,7 @@ unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics =
         // 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) {
@@ -757,7 +763,7 @@ class DurableTTLStore {
                     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];
@@ -788,14 +794,14 @@ function copy(source) {
     }
     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];
@@ -817,9 +823,9 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
             };
         }
     }
-    const durableStoreOperations = [];
+    const durableStoreOperations = additionalDurableStoreOperations;
     // publishes
-    const recordKeys = keys$5(durableRecords);
+    const recordKeys = keys$6(durableRecords);
     if (recordKeys.length > 0) {
         durableStoreOperations.push({
             type: 'setEntries',
@@ -827,8 +833,20 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
             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',
@@ -872,6 +890,19 @@ function buildIngestStagingStore(environment) {
     return environment.storeBuildIngestionStagingStore();
 }
 
+async function reviveRedirects(durableStore, env) {
+    const entries = await durableStore.getAllEntries(RedirectDurableSegment);
+    if (entries) {
+        for (const durableEntry of Object.keys(entries)) {
+            const entry = entries[durableEntry];
+            const { data: { key, redirect }, } = entry;
+            if (entry) {
+                env.storeRedirect(key, redirect);
+            }
+        }
+    }
+}
+
 const AdapterContextSegment = 'ADAPTER-CONTEXT';
 const ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
 async function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded) {
@@ -909,7 +940,7 @@ async function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorH
     }
     return contextReturn();
 }
-function isUnfulfilledSnapshot(cachedSnapshotResult) {
+function isUnfulfilledSnapshot$1(cachedSnapshotResult) {
     if (cachedSnapshotResult === undefined) {
         return false;
     }
@@ -934,13 +965,18 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     // 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);
@@ -953,6 +989,8 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     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
@@ -963,6 +1001,20 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             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 = [];
@@ -982,7 +1034,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             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];
@@ -999,10 +1051,6 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         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
@@ -1010,6 +1058,9 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                 // 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);
         }
     });
@@ -1060,12 +1111,13 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         // 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;
     };
@@ -1147,6 +1199,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     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
@@ -1192,7 +1245,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             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) => {
@@ -1799,6 +1852,12 @@ function getRelationshipInfo(apiName, fieldName, infoMap) {
 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 };
 }
@@ -2058,7 +2117,7 @@ function comparisonOperatorToSql(operator) {
         case ComparisonOperator.eq:
             return '=';
         case ComparisonOperator.ne:
-            return '!=';
+            return 'IS NOT';
         case ComparisonOperator.gt:
             return '>';
         case ComparisonOperator.gte:
@@ -2098,9 +2157,13 @@ const recordSuffix = 'edges';
 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) => {
@@ -2377,6 +2440,14 @@ function expressionToSql(expression, targetDataType, operator) {
             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.
@@ -2569,6 +2640,9 @@ function compoundOperatorToSql(operator) {
     }
 }
 
+const { isArray: isArray$4 } = Array;
+const { keys: keys$5 } = Object;
+
 function isListValueNode(node) {
     return node.kind === 'ListValue';
 }
@@ -2621,13 +2695,13 @@ function isScalarDataType(type) {
 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(errors), []);
@@ -2649,22 +2723,22 @@ function fieldsToFilters(fieldValues, joinAlias, apiName, input, compoundOperato
     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) => {
@@ -2682,10 +2756,10 @@ function filter(name, value, tableAlias, apiName, input, joins) {
     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.
@@ -2696,7 +2770,7 @@ function compoundPredicate(operator, list, joinAlias, apiName, input, joins) {
  * @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}`;
@@ -2715,7 +2789,7 @@ function spanningFilter(fieldInfo, fieldNode, alias, input, joins) {
     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;
     }
@@ -2727,7 +2801,11 @@ function spanningFilter(fieldInfo, fieldNode, alias, input, joins) {
     });
     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]);
@@ -2737,8 +2815,9 @@ function fieldFilter(fieldName, fieldNode, alias, apiName, input, joins) {
         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,
@@ -2826,7 +2905,29 @@ function fieldFilter(fieldName, fieldNode, alias, apiName, input, joins) {
                 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 = {
@@ -3033,7 +3134,11 @@ function operatorWithValue(operator, valueNode, objectInfoDataType) {
     }
     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,
@@ -3922,7 +4027,7 @@ function recordQuery(selection, apiName, alias, predicates, input) {
     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 = [];
@@ -3970,6 +4075,33 @@ function recordQuery(selection, apiName, alias, predicates, input) {
     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]));
@@ -4018,6 +4150,20 @@ function rootRecordQuery(selection, input) {
     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) {
@@ -4084,27 +4230,19 @@ function generateVariableGQLQuery(document, variables) {
             ? 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)
@@ -4114,6 +4252,51 @@ function generateVariableGQLQuery(document, variables) {
         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.
@@ -4132,14 +4315,43 @@ function swapVariableArguments(document, variables) {
             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(document) {
     return document.definitions
@@ -4174,12 +4386,24 @@ class StoreEvalPreconditioner {
      * 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(ast).map((selection) => selection.name);
+        const recordSelections = findRecordSelections(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
@@ -4219,8 +4443,12 @@ class StoreEvalPreconditioner {
             };
             // 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) {
@@ -4258,8 +4486,6 @@ class StoreEvalPreconditioner {
     }
 }
 
-const { isArray: isArray$4 } = Array;
-
 /**
  * Checks a GraphQL-shaped network response for errors, returning true if it does
  * and false otherwise
@@ -4297,15 +4523,15 @@ async function evaluateSqlite(query, eventEmitter, store) {
     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;
@@ -4313,7 +4539,7 @@ function sqliteStoreEvalFactory(userId, sqliteStore, objectInfoService) {
     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;
@@ -4332,8 +4558,8 @@ function isErrorSnapshotThatShouldGetReturnedToCaller$1(snapshot) {
 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
@@ -4362,7 +4588,7 @@ function makeStoreEval(preconditioner, objectInfoService, userId, contextProvide
             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({
@@ -4393,7 +4619,7 @@ function makeStoreEval(preconditioner, objectInfoService, userId, contextProvide
         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
@@ -4692,7 +4918,7 @@ function createDraftSynthesisErrorResponse(message = 'failed to synthesize draft
     return new DraftErrorFetchResponse(HttpStatusCode.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;
 
@@ -4739,7 +4965,6 @@ function buildLuvioOverrideForDraftAdapters(luvio, handler, extractTargetIdFromC
 }
 
 const DraftIdMappingKeyPrefix240 = 'DraftIdMapping::';
-const DraftKeyMappingKeyPrefix = 'DraftKeyMapping::V2::';
 const DRAFT_ID_MAPPINGS_SEGMENT = 'DRAFT_ID_MAPPINGS';
 function isLegacyDraftIdMapping(key, data) {
     return key.startsWith(DraftIdMappingKeyPrefix240);
@@ -4749,9 +4974,6 @@ function isLegacyDraftIdMapping(key, data) {
 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
@@ -4785,6 +5007,15 @@ async function getDraftIdMappings(durableStore, mappingIds) {
     }
     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
@@ -4875,9 +5106,6 @@ function customActionHandler(executor, id, draftQueue) {
         });
         return queueOperations;
     };
-    const getRedirectMappings = (_action) => {
-        return undefined;
-    };
     return {
         handlerId: id,
         enqueue: (data) => {
@@ -4889,7 +5117,6 @@ function customActionHandler(executor, id, draftQueue) {
         handleReplaceAction: () => {
             throw Error('replaceAction not supported for custom actions');
         },
-        getRedirectMappings,
         handleActionRemoved: () => Promise.resolve(),
         handleActionCompleted: () => Promise.resolve(),
         handleActionEnqueued: () => Promise.resolve(),
@@ -5064,17 +5291,11 @@ class DurableDraftQueue {
                 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,
@@ -5393,7 +5614,7 @@ class DurableDraftStore {
         };
         return this.enqueueAction(deleteAction);
     }
-    completeAction(queueOperations, mappings) {
+    completeAction(queueOperations) {
         const action = () => {
             const durableStoreOperations = [];
             const { draftStore } = this;
@@ -5426,18 +5647,6 @@ class DurableDraftStore {
                     });
                 }
             }
-            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);
@@ -5716,7 +5925,7 @@ class AbstractResourceRequestActionHandler {
             },
         ];
     }
-    async handleActionCompleted(action, queueOperations, _queue, allHandlers) {
+    async handleActionCompleted(action, queueOperations, allHandlers) {
         const { data: request, tag } = action;
         const { method } = request;
         if (method === 'delete') {
@@ -5793,6 +6002,8 @@ class AbstractResourceRequestActionHandler {
         };
         // 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) {
@@ -5828,11 +6039,18 @@ class AbstractResourceRequestActionHandler {
     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
@@ -6160,6 +6378,8 @@ class DraftManager {
 
 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);
@@ -6167,23 +6387,9 @@ function makeEnvironmentDraftAware(luvio, env, durableStore, handlers, draftQueu
             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) {
@@ -6251,16 +6457,23 @@ function makeEnvironmentDraftAware(luvio, env, durableStore, handlers, draftQueu
 
 const API_NAMESPACE = 'UiApi';
 const RECORD_REPRESENTATION_NAME = 'RecordRepresentation';
+const RECORD_VIEW_ENTITY_REPRESENTATION_NAME = 'RecordViewEntityRepresentation';
 const RECORD_ID_PREFIX = `${API_NAMESPACE}::${RECORD_REPRESENTATION_NAME}:`;
+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(':');
@@ -6275,7 +6488,8 @@ function isStoreRecordError(storeRecord) {
 }
 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);
 }
 
 /**
@@ -6411,7 +6625,7 @@ function isArrayLike(x) {
         (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;
 
@@ -6850,6 +7064,10 @@ function dateTimeRange(input, op, field, alias) {
     };
 }
 
+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)
@@ -6911,7 +7129,7 @@ function filterToPredicates(where, recordType, alias, objectInfoMap, joins, draf
                     return [
                         {
                             alias: childAlias,
-                            leftPath: '$.apiName',
+                            leftPath: JSON_EXTRACT_PATH_INGESTION_APINAME,
                             operator: '=',
                             value: entityName,
                             dataType: 'String',
@@ -7211,15 +7429,10 @@ function singlePredicateToSql(predicate, defaultAlias, isChildNotPredicate = fal
             // 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);
             }
         }
@@ -7367,11 +7580,18 @@ function buildQuery(config) {
     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 ?
@@ -7384,6 +7604,7 @@ function buildQuery(config) {
         ...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
@@ -7409,19 +7630,33 @@ function buildJoins(config) {
     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;
@@ -8100,7 +8335,7 @@ function orderByToPredicate(orderBy, recordType, alias, objectInfoMap, joins) {
 function pathForKey(key) {
     switch (key) {
         case 'ApiName':
-            return '$.apiName';
+            return JSON_EXTRACT_PATH_INGESTION_APINAME;
         case 'WeakEtag':
             return '$.weakEtag';
         case 'Id':
@@ -8122,7 +8357,7 @@ function scopeToJoins(scope = '', settings) {
                 {
                     type: PredicateType.single,
                     alias: 'ServiceAppointment_AssignedResource',
-                    leftPath: '$.apiName',
+                    leftPath: JSON_EXTRACT_PATH_INGESTION_APINAME,
                     operator: '=',
                     value: 'AssignedResource',
                     dataType: 'String',
@@ -8143,7 +8378,7 @@ function scopeToJoins(scope = '', settings) {
                 {
                     type: PredicateType.single,
                     alias: 'ServiceAppointment_AssignedResource_ServiceResource',
-                    leftPath: '$.apiName',
+                    leftPath: JSON_EXTRACT_PATH_INGESTION_APINAME,
                     operator: '=',
                     value: 'ServiceResource',
                     dataType: 'String',
@@ -8248,14 +8483,21 @@ function addResolversToSchema(schema, polyFields) {
             // 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,
                     };
                 };
             }
@@ -8301,10 +8543,11 @@ function addResolversToSchema(schema, polyFields) {
             // }
             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 };
                     };
                 }
             }
@@ -8327,40 +8570,40 @@ function addResolversToSchema(schema, polyFields) {
             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;
@@ -8372,7 +8615,17 @@ function addResolversToSchema(schema, polyFields) {
                                 .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;
@@ -8382,26 +8635,28 @@ function addResolversToSchema(schema, polyFields) {
                                 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;
                             };
                         }
@@ -8413,7 +8668,7 @@ function addResolversToSchema(schema, polyFields) {
     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;
         };
@@ -8421,7 +8676,7 @@ function addResolversToSchema(schema, polyFields) {
     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;
@@ -8452,10 +8707,19 @@ async function connectionEdgeResolver(obj, _args, context) {
         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
@@ -8481,6 +8745,53 @@ function isRecordType(type) {
     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(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 {
@@ -11782,6 +12093,15 @@ function buildDurableRecordRepresentation(normalizedRecord, records, pendingEntr
         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 keyBuilderRecord(luvio, { recordId });
+}
 function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecords, getStoreMetadata) {
     const getEntries = function (entries, segment) {
         // this HOF only inspects records in the default segment
@@ -11796,14 +12116,24 @@ function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecord
         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 = keyBuilderRecord(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 {
@@ -11837,6 +12167,7 @@ function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecord
         const putEntries = create$2(null);
         const keys$1 = keys$2(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++) {
@@ -11845,10 +12176,18 @@ function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecord
             const recordId = extractRecordIdFromStoreKey(key);
             // do not put normalized field values
             if (recordId !== undefined) {
-                const recordKey = keyBuilderRecord(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;
@@ -11860,7 +12199,12 @@ function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecord
                         continue;
                     }
                 }
-                putRecords[recordId] = true;
+                if (isRecordView) {
+                    putRecordViews[recordId] = true;
+                }
+                else {
+                    putRecords[recordId] = true;
+                }
                 if (isStoreRecordError(record)) {
                     putEntries[recordKey] = value;
                     continue;
@@ -11938,6 +12282,19 @@ function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecord
     });
 }
 
+/**
+ * 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
@@ -11956,7 +12313,7 @@ function performQuickActionDraftEnvironment(luvio, env, handler) {
             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());
@@ -12383,6 +12740,7 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
                 query: injectedAST,
             },
             luvio,
+            gqlEval: true,
         }, buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy));
         if (isErrorSnapshotThatShouldGetReturnedToCaller(nonEvaluatedSnapshot)) {
             return nonEvaluatedSnapshot;
@@ -13511,6 +13869,10 @@ class ScopedFieldsCollection {
 }
 
 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;
@@ -13589,8 +13951,8 @@ function buildAggregateUiUrl(params, resourceRequest) {
     }
     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';
@@ -13653,14 +14015,15 @@ function createAggregateBatchRequestInfo(resourceRequest, endpoint) {
     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,
@@ -13733,6 +14096,25 @@ function isGetRequestForEndpoint(endpoint, request) {
 function arrayOrEmpty(array) {
     return array !== undefined && isArray(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(request.urlParams).length : 0) +
+        stringify$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';
@@ -13953,15 +14335,15 @@ class NimbusDraftQueue {
     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([handlerId, data]);
         return new Promise((resolve, reject) => {
             callProxyMethod('enqueue', serializedAction, (serializedActionResponse) => {
                 const response = parse(serializedActionResponse);
                 resolve(response);
-            }, (serializedError) => {
-                reject(parse(serializedError));
+            }, (errorMessage) => {
+                reject(new Error(errorMessage));
             });
         });
     }
@@ -13971,18 +14353,18 @@ class NimbusDraftQueue {
         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([]), (serializedQueue) => {
                 resolve(parse(serializedQueue));
-            }, (serializedError) => {
-                reject(parse(serializedError));
+            }, (errorMessage) => {
+                reject(new Error(errorMessage));
             });
         });
     }
@@ -14010,32 +14392,32 @@ class NimbusDraftQueue {
         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'));
     }
 }
 
@@ -14547,6 +14929,7 @@ function instrumentAdapter(adapter, metadata) {
     return instrumentAdapter$1(instrumentedMobileAdapter, metadata, {
         trackL1Hits: true,
         trackL2Hits: true,
+        trackCacheMisses: true,
         reportObserver: (report) => {
             for (const observer of reportObservers) {
                 observer(report);
@@ -14849,7 +15232,7 @@ class NimbusSqliteStore {
     registerOnChangedListener(listener) {
         let unsubscribeId = undefined;
         this.plugin
-            .registerOnChangedListener((changes) => {
+            .registerOnChangedListener(async (changes) => {
             const durableChanges = changes.map((c) => {
                 return {
                     type: c.type === 'upsert' ? 'setEntries' : 'evictEntries',
@@ -14858,7 +15241,7 @@ class NimbusSqliteStore {
                     segment: c.context.segment,
                 };
             });
-            listener(durableChanges);
+            await listener(durableChanges);
         })
             .then((unsub) => {
             unsubscribeId = unsub;
@@ -14964,8 +15347,17 @@ function formatDisplayValue(value, datatype) {
     }
 }
 
-//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) => {
@@ -14981,8 +15373,72 @@ function makeEnvironmentGraphqlAware(environment) {
         }
         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(environment, {
         rebuildSnapshot: { value: rebuildSnapshot },
+        applyCachePolicy: { value: applyCachePolicy },
+        defaultCachePolicy: {
+            get() {
+                return environment.defaultCachePolicy;
+            },
+            set(value) {
+                environment.defaultCachePolicy = value;
+            },
+        },
     });
 }
 
@@ -15633,8 +16089,17 @@ function getRuntime() {
         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;
@@ -15726,4 +16191,4 @@ register({
 });
 
 export { getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.130.9-2d38b9869
+// version: 1.131.0-dev10-b950ecbb3