@salesforce/lds-worker-api 1.302.0 → 1.304.0

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

@@ -835,14 +835,7 @@ class StringKeyInMemoryStore {
         // of the function, in case the reference changes (because of an unsubscribe)
         const { snapshotSubscriptions } = this;
         // read metadata for each key, and mark as expired
-        const expirationTimestamp = Date.now();
-        for (let i = 0, len = keys.length; i < len; i++) {
-            const key = keys[i];
-            const metadata = this.readMetadata(key);
-            if (metadata !== undefined) {
-                this.publishMetadata(key, { ...metadata, expirationTimestamp });
-            }
-        }
+        this.expirePossibleStaleRecords(keys);
         // Process snapshot subscriptions
         const pendingPromises = [];
         for (let i = 0, len = snapshotSubscriptions.length; i < len; i++) {
@@ -937,6 +930,16 @@ class StringKeyInMemoryStore {
             this.metadata[canonicalKey] = storeMetadata;
         }
     }
+    expirePossibleStaleRecords(keys) {
+        const expirationTimestamp = Date.now();
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const metadata = this.readMetadata(key);
+            if (metadata !== undefined) {
+                this.publishMetadata(key, { ...metadata, expirationTimestamp });
+            }
+        }
+    }
     setTTLOverride(namespace, representationName, ttl) {
         this.ttlOverrides[getTTLOverrideKey(namespace, representationName)] = ttl;
     }
@@ -1531,14 +1534,7 @@ class InMemoryStore {
         // of the function, in case the reference changes (because of an unsubscribe)
         const { snapshotSubscriptions } = this;
         // read metadata for each key, and mark as expired
-        const expirationTimestamp = Date.now();
-        for (let i = 0, len = keys.length; i < len; i++) {
-            const key = keys[i];
-            const metadata = this.readMetadata(key);
-            if (metadata !== undefined) {
-                this.publishMetadata(key, { ...metadata, expirationTimestamp });
-            }
-        }
+        this.expirePossibleStaleRecords(keys);
         // Process snapshot subscriptions
         const pendingPromises = [];
         for (let i = 0, len = snapshotSubscriptions.length; i < len; i++) {
@@ -1661,6 +1657,19 @@ class InMemoryStore {
             this.metadataMap.set(canonicalKey, storeMetadata);
         }
     }
+    expirePossibleStaleRecords(keys) {
+        if (keys.length > 0 && typeof keys[0] === 'string') {
+            return this.fallbackStringKeyInMemoryStore.expirePossibleStaleRecords(keys);
+        }
+        const expirationTimestamp = Date.now();
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const metadata = this.readMetadata(key);
+            if (metadata !== undefined) {
+                this.publishMetadata(key, { ...metadata, expirationTimestamp });
+            }
+        }
+    }
     setTTLOverride(namespace, representationName, ttl) {
         // Set the TTLs in both the stores
         this.fallbackStringKeyInMemoryStore.setTTLOverride(namespace, representationName, ttl);
@@ -2250,6 +2259,20 @@ class GraphNode {
         const value = this.data[propertyName];
         return typeof value !== 'object' || value === null;
     }
+    isMissing(propertyName) {
+        const value = this.data[propertyName];
+        if (value && typeof value.__state === 'object' && value.__state !== null) {
+            return !!value.__state.isMissing;
+        }
+        return false;
+    }
+    isPending(propertyName) {
+        const value = this.data[propertyName];
+        if (value && typeof value.__state === 'object' && value.__state !== null) {
+            return !!value.__state.pending;
+        }
+        return false;
+    }
     write(propertyName, value) {
         this.data[propertyName] = value;
         const canonicalKey = this.store.getCanonicalRecordId(this.storeKey);
@@ -3633,6 +3656,30 @@ class Environment {
     buildStructuredKey(namespace, representationName, idValues) {
         return this.store.buildStructuredKey(namespace, representationName, idValues);
     }
+    /**
+     * Take a list of keys and marks them as stale to be refreshed.
+     * Then will be refreshed with the provided refresh function.
+     * If no refresh and makeConfig functions are provided it will refresh
+     * time that record is trying to be fetched
+     *
+     * Example: one record from graphql needs to be refreshed and not
+     * the entire graphql query
+     *
+     * @param keys
+     * @param makeConfig
+     * @param refresh
+     * @returns
+     */
+    expirePossibleStaleRecords(keys, config, refresh) {
+        this.store.expirePossibleStaleRecords(keys);
+        if (refresh !== undefined && config !== undefined) {
+            return this.refreshPossibleStaleRecords(config, refresh);
+        }
+        return Promise.resolve();
+    }
+    refreshPossibleStaleRecords(config, refresh) {
+        return Promise.resolve(refresh(config, { cachePolicy: { type: 'no-cache' } })).then(() => { });
+    }
 }
 
 class Luvio {
@@ -3699,6 +3746,9 @@ class Luvio {
     storeCleanup() {
         this.environment.storeCleanup();
     }
+    storeExpirePossibleStaleRecords(keys, config, refresh) {
+        return this.environment.expirePossibleStaleRecords(keys, config, refresh);
+    }
     createSnapshot(selector, refresh) {
         return this.environment.createSnapshot(selector, refresh);
     }
@@ -4087,7 +4137,7 @@ function createResourceParamsImpl(config, configMetadata) {
     }
     return resourceParams;
 }
-// engine version: 0.155.1-284dbf66
+// engine version: 0.156.3-04c1a80e
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -4215,7 +4265,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.302.0-e45992a1f4
+// version: 1.304.0-aa3e5f9550
 
 // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
 function instrumentAdapter$1(createFunction, _metadata) {
@@ -15714,7 +15764,7 @@ function gql(literals, ...subs) {
     }
     return superResult;
 }
-// version: 1.302.0-e45992a1f4
+// version: 1.304.0-aa3e5f9550
 
 function unwrap(data) {
     // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16643,7 +16693,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     const { apiFamily, name } = metadata;
     return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
 }
-// version: 1.302.0-e45992a1f4
+// version: 1.304.0-aa3e5f9550
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -16742,7 +16792,7 @@ var TypeCheckShapes;
     TypeCheckShapes[TypeCheckShapes["Integer"] = 3] = "Integer";
     TypeCheckShapes[TypeCheckShapes["Unsupported"] = 4] = "Unsupported";
 })(TypeCheckShapes || (TypeCheckShapes = {}));
-// engine version: 0.155.1-284dbf66
+// engine version: 0.156.3-04c1a80e
 
 const { keys: ObjectKeys$3, create: ObjectCreate$3 } = Object;
 
@@ -18217,7 +18267,7 @@ const CHILD_RELATIONSHIP_SELECTION = {
 // be applied to a RecordRepresentation in environments configured with
 // drafts when the record has draft changes applied to it
 // TODO [W-8237087]: explore if this selection can only be added in environments where drafts are enabled
-const DRAFTS_SELECTION = {
+const DRAFTS_SELECTION$1 = {
     kind: 'Object',
     opaque: true,
     name: 'drafts',
@@ -18231,7 +18281,7 @@ function createRecordSelection(fieldDefinition) {
         childRelationships: CHILD_RELATIONSHIP_SELECTION,
         fields: createPathSelection('fields', fieldDefinition),
     });
-    return [...sel.selections, DRAFTS_SELECTION];
+    return [...sel.selections, DRAFTS_SELECTION$1];
 }
 /**
  * Convert a list of fields and optional fields into RecordRepresentation its equivalent
@@ -18248,7 +18298,7 @@ function buildSelectionFromRecord(record) {
         childRelationships: CHILD_RELATIONSHIP_SELECTION,
         fields: createPathSelectionFromValue(record.fields),
     });
-    return [...sel.selections, DRAFTS_SELECTION];
+    return [...sel.selections, DRAFTS_SELECTION$1];
 }
 
 const MAX_RECORD_DEPTH = 5;
@@ -20472,6 +20522,12 @@ function readFieldStateFromValueNode(fieldNode) {
     }
     return fieldNode.__state.fields;
 }
+function writeFieldStateNodeValue(fieldNode, propertyName, value) {
+    const node = fieldNode;
+    const state = node.__state || {};
+    state[propertyName] = value;
+    node.write('__state', state);
+}
 
 const CUSTOM_API_NAME_SUFFIX = '__c';
 const DMO_API_NAME_SUFFIX = '__dlm';
@@ -20520,7 +20576,7 @@ function extractTrackedFieldsToTrie(recordId, node, root) {
                 name: key,
                 children: {},
             };
-            if (isMissing(fieldRep)) {
+            if (fields.isMissing(key)) {
                 current.children[key] = next;
                 continue;
             }
@@ -20579,14 +20635,6 @@ function convertTrieToFieldsRecursively(root) {
     }
     return reduce$2.call(childKeys, (acc, cur) => concat$2.call(acc, convertTrieToFieldsRecursively(root.children[cur]).map((i) => `${root.name}.${i}`)), []);
 }
-function isMissing(node) {
-    // TODO [W-15867870]: JHORST add support for isMissing on graphnode object
-    return node.data && node.data.__state && node.data.__state.isMissing === true;
-}
-function isPending(node) {
-    // TODO [W-15867870]: JHORST add support for pending on graphnode object
-    return node.data && node.data.__state && node.data.__state.pending === true;
-}
 const BLANK_RECORD_FIELDS_TRIE = freeze$4({
     name: '',
     children: {},
@@ -20678,8 +20726,9 @@ function markNulledOutPath(record, path) {
         !isFrozen$2(resolved.data)) {
         const stateFields = readFieldStateFromValueNode(resolved.data);
         const fields = stateFields === undefined ? [] : stateFields;
-        // TODO [W-15838292]: JHORST add support for node state on graphnode object
-        resolved.write('__state', { fields: dedupe$2([...fields, path.join('.')]) });
+        // Note that GraphNodes are frozen when NODE_ENV != production.
+        // Use with care.
+        writeFieldStateNodeValue(resolved, 'fields', dedupe$2([...fields, path.join('.')]));
     }
 }
 function markNulledOutRequiredFields(record, fields) {
@@ -20706,7 +20755,7 @@ function _markMissingPath(record, path) {
         return;
     }
     const fieldValueValue = fieldValueRepresentation.object(fieldName);
-    if (isPending(fieldValueValue)) {
+    if (fieldValueRepresentation.isPending(fieldName)) {
         writeMissingFieldToStore(fieldValueRepresentation, fieldName);
         return;
     }
@@ -20736,7 +20785,8 @@ function _markMissingPath(record, path) {
 function writeMissingFieldToStore(field, fieldName) {
     // TODO [W-6900046]: remove cast, make RecordRepresentationNormalized['fields'] accept
     // an undefined/non-present __ref if isMissing is present
-    // TODO [W-15867870]: JHORST add support for isMissing on graphnode object
+    // Note that GraphNodes are frozen when NODE_ENV != production.
+    // Use with care.
     field.write(fieldName, {
         __state: {
             isMissing: true,
@@ -26503,6 +26553,12 @@ function keyBuilderFromType$r(luvio, object) {
 function normalize$A(input, existing, path, luvio, store, timestamp) {
     return input;
 }
+const DRAFTS_SELECTION = {
+    kind: 'Object',
+    opaque: true,
+    name: 'drafts',
+    required: false,
+};
 const select$1A = function QuickActionExecutionRepresentationSelect() {
     return {
         kind: 'Fragment',
@@ -26534,7 +26590,7 @@ const select$1A = function QuickActionExecutionRepresentationSelect() {
             {
                 name: 'successMessage',
                 kind: 'Scalar'
-            }
+            }, DRAFTS_SELECTION,
         ]
     };
 };
@@ -44130,7 +44186,7 @@ withDefaultLuvio((luvio) => {
     throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
     throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
 });
-// version: 1.302.0-5fb014108f
+// version: 1.304.0-d87b57badb
 
 var ldsIdempotencyWriteDisabled = {
     isOpen: function (e) {
@@ -45814,6 +45870,32 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
         }, revivingStore).finally(() => {
         });
     };
+    const expirePossibleStaleRecords = async function (keys$1, config, refresh) {
+        validateNotDisposed();
+        const metadataKeys = keys$1.map(serializeStructuredKey);
+        const now = Date.now();
+        const entries = await durableStore.getMetadata(metadataKeys, DefaultDurableSegment);
+        if (entries === undefined || keys$8(entries).length === 0) {
+            return environment.expirePossibleStaleRecords(keys$1);
+        }
+        let metaDataChanged = false;
+        const metadataEntries = metadataKeys.reduce((accu, key) => {
+            const metadataEntry = entries[key];
+            if (metadataEntry.metadata !== undefined) {
+                const metadata = { ...metadataEntry.metadata, expirationTimestamp: now };
+                accu[key] = { metadata };
+                metaDataChanged = true;
+            }
+            return accu;
+        }, {});
+        if (metaDataChanged) {
+            await durableStore.setMetadata(metadataEntries, DefaultDurableSegment);
+        }
+        if (config !== undefined && refresh !== undefined) {
+            return environment.refreshPossibleStaleRecords(config, refresh);
+        }
+        return Promise.resolve();
+    };
     // set the default cache policy of the base environment
     environment.setDefaultCachePolicy({
         type: 'stale-while-revalidate',
@@ -45846,6 +45928,7 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
         handleErrorResponse: { value: handleErrorResponse },
         getNotifyChangeStoreEntries: { value: getNotifyChangeStoreEntries },
         notifyStoreUpdateAvailable: { value: notifyStoreUpdateAvailable },
+        expirePossibleStaleRecords: { value: expirePossibleStaleRecords },
     });
 }
 
@@ -49892,7 +49975,7 @@ class DurableDraftQueue {
         if (status === DraftActionStatus.Error) {
             this.state = DraftQueueState.Error;
             this.processingAction = undefined;
-            this.notifyChangedListeners({
+            await this.notifyChangedListeners({
                 type: DraftQueueEventType.ActionFailed,
                 action: action,
             });
@@ -49908,7 +49991,7 @@ class DurableDraftQueue {
         if (this.state === DraftQueueState.Waiting) {
             this.state = DraftQueueState.Started;
         }
-        this.notifyChangedListeners({
+        await this.notifyChangedListeners({
             type: DraftQueueEventType.ActionUploading,
             action: { ...action, status: DraftActionStatus.Uploading },
         });
@@ -49985,6 +50068,31 @@ class DurableDraftQueue {
             await this.startQueue();
         }
     }
+    async updateDraftAction(action) {
+        // stop queue manually
+        this.stopQueueManually();
+        const actionStatus = await this.statusOfAction(action.id);
+        if (actionStatus === DraftActionStatus.Uploading) {
+            return Promise.reject('cannot update an uploading action');
+        }
+        // save the action into the draft store
+        await this.draftStore.writeAction(action);
+        // make the handler replay these drafts on the record
+        const handler = this.getHandler(action.handler);
+        const queue = await this.getQueueActions();
+        await handler.handleActionEnqueued(action, queue);
+        // start queue safely
+        return this.startQueueSafe();
+    }
+    async statusOfAction(actionId) {
+        const queue = await this.getQueueActions();
+        const actions = queue.filter((action) => action.id === actionId);
+        if (actions.length === 0) {
+            return Promise.reject('cannot update non-existent action');
+        }
+        const action = actions[0];
+        return action.status;
+    }
     replaceAction(targetActionId, sourceActionId) {
         return this.replaceOrMergeActions(targetActionId, sourceActionId, false);
     }
@@ -50015,17 +50123,21 @@ class DurableDraftQueue {
         });
         return action;
     }
-    scheduleRetryWithSpecifiedDelay(retryDelayInMs) {
+    async scheduleRetryWithSpecifiedDelay(retryDelayInMs) {
+        await this.notifyChangedListeners({
+            type: DraftQueueEventType.QueueStateChanged,
+            state: DraftQueueState.Waiting,
+        });
         this.timeoutHandler = setTimeout(() => {
             if (this.state !== DraftQueueState.Stopped) {
                 this.processNextAction();
             }
         }, retryDelayInMs);
     }
-    scheduleRetry() {
+    async scheduleRetry() {
         const newInterval = this.retryIntervalMilliseconds * 2;
         this.retryIntervalMilliseconds = Math.min(Math.max(newInterval, this.minimumRetryInterval), this.maximumRetryInterval);
-        this.scheduleRetryWithSpecifiedDelay(this.retryIntervalMilliseconds);
+        return this.scheduleRetryWithSpecifiedDelay(this.retryIntervalMilliseconds);
     }
     async getActionsForReplaceOrMerge(targetActionId, sourceActionId) {
         const actions = await this.getQueueActions();
@@ -50151,7 +50263,8 @@ class DurableDraftStore {
             const actionArray = [];
             for (let i = 0, len = keys$1.length; i < len; i++) {
                 const key = keys$1[i];
-                actionArray.push(draftStore[key]);
+                // clone draft so we don't expose the internal draft store
+                actionArray.push(clone$1(draftStore[key]));
             }
             return actionArray;
         });
@@ -50786,6 +50899,7 @@ var DraftQueueOperationType;
     DraftQueueOperationType["ItemUpdated"] = "updated";
     DraftQueueOperationType["QueueStarted"] = "started";
     DraftQueueOperationType["QueueStopped"] = "stopped";
+    DraftQueueOperationType["QueueWaiting"] = "waiting";
 })(DraftQueueOperationType || (DraftQueueOperationType = {}));
 /**
  * Converts the internal DraftAction's ResourceRequest into
@@ -50828,6 +50942,16 @@ function toQueueState(queue) {
     };
 }
 class DraftManager {
+    shouldEmitEvent(event) {
+        // Waiting events cannot be emitted prior to 252 native clients
+        // TODO [W-16102411]: we can safely remove this backwards compatible code in 256
+        if (isDraftQueueStateChangeEvent(event) &&
+            event.state === DraftQueueState.Waiting &&
+            this.listenerVersion === undefined) {
+            return false;
+        }
+        return this.draftEventsShouldBeEmitted.includes(event.type);
+    }
     constructor(draftQueue) {
         this.listeners = [];
         this.draftEventsShouldBeEmitted = [
@@ -50841,7 +50965,7 @@ class DraftManager {
         ];
         this.draftQueue = draftQueue;
         draftQueue.registerOnChangedListener((event) => {
-            if (this.draftEventsShouldBeEmitted.includes(event.type)) {
+            if (this.shouldEmitEvent(event)) {
                 return this.callListeners(event);
             }
             return Promise.resolve();
@@ -50871,6 +50995,8 @@ class DraftManager {
                 return DraftQueueOperationType.QueueStarted;
             case DraftQueueState.Stopped:
                 return DraftQueueOperationType.QueueStopped;
+            case DraftQueueState.Waiting:
+                return DraftQueueOperationType.QueueWaiting;
             default:
                 throw Error('Unsupported event type');
         }
@@ -50928,7 +51054,8 @@ class DraftManager {
      *
      * @param listener The listener closure to subscribe to changes
      */
-    registerDraftQueueChangedListener(listener) {
+    registerDraftQueueChangedListener(listener, version = undefined) {
+        this.listenerVersion = version;
         this.listeners.push(listener);
         return () => {
             this.listeners = this.listeners.filter((l) => {
@@ -50955,6 +51082,60 @@ class DraftManager {
             };
         });
     }
+    async mergePerformQuickAction(actionId, fields) {
+        if (!this.isValidFieldMap(fields)) {
+            return Promise.reject('fields is not valid');
+        }
+        const queue = await this.draftQueue.getQueueActions();
+        const actions = queue.filter((action) => action.id === actionId);
+        if (actions.length === 0) {
+            return Promise.reject('cannot edit non-existent action');
+        }
+        const action = actions[0];
+        if (!this.isPerformQuickActionDraft(action, 'post')) {
+            return Promise.reject('cannot edit incompatible action type or uploading actions');
+        }
+        action.data.body.fields = { ...action.data.body.fields, ...fields };
+        await this.draftQueue.updateDraftAction(action);
+        return this.buildDraftQueueItem(action);
+    }
+    isValidFieldMap(fields) {
+        const keys$1 = keys$6(fields);
+        const validTypes = ['string', 'number', 'null', 'boolean'];
+        for (let i = 0; i < keys$1.length; i++) {
+            const key = keys$1[i];
+            const value = fields[key];
+            if (!validTypes.includes(typeof value)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    isPerformQuickActionDraft(action, method) {
+        const data = action.data;
+        const isPerformQuickAction = data.basePath.startsWith('/ui-api/actions/perform-quick-action/');
+        const methodMatches = data.method === method;
+        const notUploading = action.status !== DraftActionStatus.Uploading;
+        return isPerformQuickAction && methodMatches && notUploading;
+    }
+    async mergePerformUpdateRecordQuickAction(actionId, fields) {
+        if (!this.isValidFieldMap(fields)) {
+            return Promise.reject('fields is not valid');
+        }
+        const queue = await this.draftQueue.getQueueActions();
+        const actions = queue.filter((action) => action.id === actionId);
+        if (actions.length === 0) {
+            return Promise.reject('cannot edit non-existent action');
+        }
+        const action = actions[0];
+        if (!this.isPerformQuickActionDraft(action, 'patch')) {
+            return Promise.reject('cannot edit incompatible action type or uploading actions');
+        }
+        const data = action.data;
+        data.body.fields = { ...data.body.fields, ...fields };
+        await this.draftQueue.updateDraftAction(action);
+        return this.buildDraftQueueItem(action);
+    }
     buildDraftQueueItem(action) {
         const operationType = getOperationTypeFrom(action);
         const { id, status, timestamp, targetId, metadata } = action;
@@ -51262,6 +51443,12 @@ function getDenormalizedRecord(recordKey, durableStore) {
 function isStoreRecordError(storeRecord) {
     return storeRecord.__type === 'error';
 }
+function isDraftFieldPending(field) {
+    return !!(field.__state && field.__state.pending === true);
+}
+function isDraftFieldMissing(field) {
+    return !!(field.__state && field.__state.isMissing === true);
+}
 
 /**
  * Checks if a resource request is a GET method on the record endpoint
@@ -51953,12 +52140,9 @@ function applyReferenceLinksToDraft(record, draftMetadata) {
         }
         const { dataType, relationshipName, referenceToInfos } = fieldInfo;
         const draftFieldNode = record.fields[draftField];
-        // JHORST: revisit this logic
         // do not try to apply drafts on nodes that are pending or missing
-        if (draftFieldNode.__state !== undefined) {
-            if (draftFieldNode.__state.pending === true ||
-                draftFieldNode.__state.isMissing === true)
-                continue;
+        if (isDraftFieldPending(draftFieldNode) || isDraftFieldMissing(draftFieldNode)) {
+            continue;
         }
         const draftFieldValue = draftFieldNode.value;
         if (dataType === 'Reference' && relationshipName !== null) {
@@ -52753,6 +52937,7 @@ class QuickActionExecutionRepresentationHandler extends AbstractResourceRequestA
             isCreated: true,
             isSuccess: true,
             successMessage: `record created.`,
+            drafts: { draftActionId: action.id },
         });
     }
     getDraftMetadata(_key) {
@@ -52870,6 +53055,7 @@ class UpdateRecordQuickActionExecutionRepresentationHandler extends AbstractReso
             isCreated: false,
             isSuccess: true,
             successMessage: `record updated.`,
+            drafts: { draftActionId: action.id },
         });
     }
     async getDraftMetadata(key) {
@@ -52947,7 +53133,29 @@ function isCreateContentDocumentAndVersionDraftAdapterEvent(customEvent) {
     return customEvent.namespace === CONTENT_DOCUMENT_AND_VERSION_NAMESPACE;
 }
 
+// so eslint doesn't complain about nimbus
+/* global __nimbus */
 const ContentDocumentCompositeKeyPrefix = 'UiApi::ContentDocumentCompositeRepresentation:';
+function chunkToBase64(chunk) {
+    let binary = '';
+    const chunkSize = 32 * 1024;
+    for (let i = 0; i < chunk.length; i += chunkSize) {
+        binary += String.fromCharCode.apply(null, chunk.subarray(i, i + chunkSize));
+    }
+    return btoa(binary);
+}
+async function streamBufferToBinaryStore(binaryStore, buffer, mimeType) {
+    const uri = await binaryStore.createStream(mimeType);
+    const bufferSize = 64 * 1024; // 64k buffer size
+    const uint8Array = new Uint8Array(buffer);
+    for (let offset = 0; offset < uint8Array.length; offset += bufferSize) {
+        const chunk = uint8Array.subarray(offset, Math.min(offset + bufferSize, uint8Array.length));
+        const base64Chunk = chunkToBase64(chunk);
+        await binaryStore.writeToStream(uri, base64Chunk);
+    }
+    await binaryStore.closeStream(uri);
+    return uri;
+}
 function createContentDocumentAndVersionDraftAdapterFactory(luvio, binaryStore, actionHandler) {
     const overriddenLuvio = buildLuvioOverrideForDraftAdapters(luvio, actionHandler, (key) => {
         // if the key is for our top-level response shape
@@ -52970,7 +53178,14 @@ function createContentDocumentAndVersionDraftAdapterFactory(luvio, binaryStore,
             const { fileData } = config;
             const { name, size, type } = fileData;
             const buffer = await fileData.arrayBuffer();
-            const uri = await binaryStore.store(new Uint8Array(buffer), type, size);
+            var uri;
+            // see if new chunking-api exists, if it doesnt fall back to memory-intensive mobile api
+            if (!__nimbus.plugins.LdsBinaryStorePlugin.createStream) {
+                uri = await binaryStore.store(new Uint8Array(buffer), type, size);
+            }
+            else {
+                uri = await streamBufferToBinaryStore(binaryStore, buffer, type);
+            }
             config.fileData = {
                 isFileReference: true,
                 handle: uri,
@@ -53809,7 +54024,7 @@ function recordLoaderFactory(query) {
     return new DataLoader(batchRecordQuery);
 }
 
-function createContext(store, objectInfos, eventEmitter, settings, snapshot, draftFunctions) {
+function createContext(store, objectInfos, eventEmitter, settings, snapshot, mappedCursors = new Map(), draftFunctions) {
     store.query.bind(store);
     const query = (sql, params) => {
         const now = Date.now();
@@ -53836,7 +54051,9 @@ function createContext(store, objectInfos, eventEmitter, settings, snapshot, dra
         Record,
         snapshot,
         seenRecordIds: new Set(),
+        possibleStaleRecordMap: new Map(),
         draftFunctions,
+        mappedCursors,
     };
 }
 
@@ -54447,7 +54664,6 @@ function isTodayStartOfWeek() {
 
 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) {
@@ -54988,14 +55204,10 @@ function buildQuery(config) {
     const predicates = buildPredicates(config);
     const orderBy = buildOrderBy(config);
     const sql = `
-        SELECT "${config.alias}".data
+        SELECT "${config.alias}".data, "${config.alias}".metadata
         FROM lds_data "${config.alias}" ${joins.sql}
         WHERE "${config.alias}".key like 'UiApi::RecordRepresentation:%'
           AND json_extract("${config.alias}".data, '${JSON_EXTRACT_PATH_INGESTION_APINAME}') = '${config.alias}'
-          AND (
-            json_extract("${config.alias}".metadata, '${JSON_EXTRACT_PATH_INGESTION_TIMESTAMP}') >= ?
-            OR json_extract("${config.alias}".data, '${JSON_EXTRACT_PATH_DRAFTS}') IS NOT NULL
-          )
           ${predicates.sql}
           ${orderBy.sql}
         LIMIT ?
@@ -55007,7 +55219,6 @@ function buildQuery(config) {
     const bindings = [
         // bindings from predicates on joins
         ...joins.bindings,
-        config.ingestionTimestamp,
         // where clause and parent scope bindings
         ...predicates.bindings,
         // limit binding
@@ -55034,29 +55245,19 @@ 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 = ` 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}${timestampAdded ? '' : joinMetadataTimestamp}`;
+                joined_sql = ` AND ${sql}`;
                 bindings.push(...binding);
-                if (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}${timestampAdded ? '' : joinMetadataTimestamp}`;
-                if (timestampAdded === false) {
-                    bindings.push(config.ingestionTimestamp);
-                    timestampAdded = true;
-                }
+                joined_sql = `${left} = ${right}`;
             }
             conditionAccumulator += joined_sql;
             return conditionAccumulator;
@@ -55725,11 +55926,15 @@ async function readIngestionTimestampForKey(key, query) {
     }
     return ingestionTimestamp;
 }
-async function readPaginationMetadataForKey(key, query) {
-    const sql = `SELECT data FROM lds_data WHERE key=?`;
-    const results = await query(sql, [key + '__pagination']);
-    const [paginationMetadata] = results.rows.map((row) => parse$3(row[0]));
-    return paginationMetadata || {};
+function isObjectDefinitionNode(node) {
+    const { kind } = node;
+    return typeof kind === 'string' && kind === 'OperationDefinition';
+}
+function operationNodeAncestor(ancestors) {
+    let operationNode = ancestors.find((a) => {
+        return !(a instanceof Array) && isObjectDefinitionNode(a);
+    });
+    return operationNode;
 }
 
 function findSpanningField(name) {
@@ -55930,44 +56135,87 @@ function atobPolyfill(data) {
 const base64encode = typeof btoa === 'function' ? btoa : btoaPolyfill;
 const base64decode = typeof atob === 'function' ? atob : atobPolyfill;
 
+// this truthy value is used to indicate a premature end of results
+const EARLY_END = 1;
 function cursorResolver(source) {
-    return encodeV1Cursor(source.index);
+    let cursor = {
+        i: source.index,
+    };
+    if (source.earlyEnd) {
+        cursor.e = EARLY_END;
+    }
+    return encodeV1Cursor(cursor);
 }
 function pageInfoResolver(source) {
     if (source.records.length === 0) {
+        // we may have found no records, but if more exist we need to
+        // return a valid cursor that can be passed as the next `after`
+        if (source.earlyEnd) {
+            return {
+                startCursor: null,
+                endCursor: encodeV1Cursor({
+                    i: source.offset,
+                    e: EARLY_END,
+                }),
+                hasNextPage: source.hasNextPage,
+            };
+        }
         return {
             startCursor: null,
             endCursor: null,
-            hasNextPage: false,
+            hasNextPage: source.hasNextPage,
         };
     }
     let startIndex = source.records[0].index;
+    let startCursor = {
+        i: startIndex,
+    };
     let endIndex = source.records[source.records.length - 1].index;
+    let endCursor = {
+        i: endIndex,
+    };
+    if (source.earlyEnd) {
+        startCursor.e = EARLY_END;
+        endCursor.e = EARLY_END;
+    }
     return {
-        startCursor: encodeV1Cursor(startIndex),
-        endCursor: encodeV1Cursor(endIndex),
+        startCursor: encodeV1Cursor(startCursor),
+        endCursor: encodeV1Cursor(endCursor),
         hasNextPage: source.hasNextPage,
     };
 }
 function pageResultCountResolver(source) {
     return source.records.length;
 }
-function encodeV1Cursor(index) {
-    return base64encode(`v1:${index}`);
+function isLocalCursor(maybeCursor) {
+    return (!!maybeCursor &&
+        typeof maybeCursor === 'object' &&
+        'i' in maybeCursor &&
+        typeof maybeCursor.i === 'number');
 }
-const cursorRegex = /^v1:(?<index>\d+)$/;
+function encodeV1Cursor(cursor) {
+    return base64encode(stringify$3(cursor));
+}
+const CURSOR_PARSE_ERROR = 'Unable to parse cursor';
 function decodeV1Cursor(base64cursor) {
-    const cursor = base64decode(base64cursor);
-    if (!cursor) {
+    let maybeCursor;
+    try {
+        const cursorString = base64decode(base64cursor);
+        maybeCursor = parse$3(cursorString);
+    }
+    catch (error) {
+        let message = CURSOR_PARSE_ERROR;
+        if (error instanceof Error) {
+            message += ': ' + error.message;
+        }
         // eslint-disable-next-line @salesforce/lds/no-error-in-production
-        throw new Error('Unable to parse cursor');
+        throw new Error(message);
     }
-    const found = cursor.match(cursorRegex);
-    if (!found || !found.groups) {
+    if (!isLocalCursor(maybeCursor)) {
         // eslint-disable-next-line @salesforce/lds/no-error-in-production
-        throw new Error('Unable to parse cursor');
+        throw new Error(CURSOR_PARSE_ERROR);
     }
-    return Number(found.groups.index);
+    return maybeCursor;
 }
 /**
  * Check the selections for any selection matching `pageInfo { hasNextPage }`
@@ -56005,6 +56253,164 @@ function selectionIncludesHasNextPage(selections, fragments) {
     return false;
 }
 
+const END_CURSOR = '__END__';
+// find the closest matching cursor in the server pagination metadata
+function mapCursorValue(originalValue, paginationMetadata) {
+    let mappedValue = null;
+    if (!originalValue) {
+        return mappedValue;
+    }
+    // flip the pagination metadata into an array by index.
+    let cursors = [];
+    for (const [cursor, index] of Object.entries(paginationMetadata)) {
+        if (index === undefined)
+            continue;
+        cursors[index] = cursor;
+    }
+    let cursor = decodeV1Cursor(originalValue);
+    // cursors containe 1-based indexes, adjust back to 0-based
+    let index = cursor.i - 1;
+    if (
+    // cursor.e being truthy means we had premature end of results and
+    // should pin to the last known server cursor
+    !cursor.e &&
+        // check that the index we have is within the bounds of known cursors
+        index >= 0 &&
+        index < cursors.length &&
+        // and make sure the cursor is not the server end marker
+        cursors[index] !== END_CURSOR) {
+        mappedValue = cursors[index];
+    }
+    else {
+        // in this case, either our local cursor is beyond the max server cursor, or
+        // the local cursor precedes the max server cursor and we ran out of locally
+        // cached results. either way, find the last known server cursor and map to that.
+        for (let i = cursors.length; i > 0; --i) {
+            let cursor = cursors[i - 1];
+            if (cursor !== END_CURSOR) {
+                mappedValue = cursor;
+                break;
+            }
+        }
+    }
+    return mappedValue;
+}
+// map all pagination cursors in the document
+async function mapPaginationCursors(originalAST, variables, store) {
+    // first pass, identify record query cache keys for reading pagination metadata
+    let requiredPaginationMetadataKeys = [];
+    visit$1(originalAST, {
+        Field(node, _key, _parent, _path, ancestors) {
+            // is it a record query?
+            if (!isRecordQuery(node)) {
+                return;
+            }
+            // does it have a defined `after` argument?
+            let after = node.arguments &&
+                node.arguments.find((a) => {
+                    return a.name.value === 'after';
+                });
+            if (after && (after.value.kind === 'StringValue' || after.value.kind === 'Variable')) {
+                let operationNode = operationNodeAncestor(ancestors);
+                if (!operationNode) {
+                    return false;
+                }
+                let key = buildKeyStringForRecordQuery(operationNode, variables, node.arguments || [], node.name.value);
+                requiredPaginationMetadataKeys.push(key);
+            }
+            // don't need to descend into this node
+            return false;
+        },
+    });
+    // read pagination metadata for identified record queries
+    let paginationMetadataMap = await readPaginationMetadataForKeys(requiredPaginationMetadataKeys, store.query.bind(store));
+    // holds the original cursor values that were mapped back to server cursors
+    let mappedCursors = new Map();
+    // rewrite nodes/variables with mapped cursors now that we read the pagination metadata
+    let ast = visit$1(originalAST, {
+        Field(node, _key, _parent, _path, ancestors) {
+            // is it a record query?
+            if (!isRecordQuery(node)) {
+                // not returning false, we might be in the parent of a record query
+                return;
+            }
+            // does it have a defined `after` argument?
+            if (!node.arguments)
+                return false;
+            let after = node.arguments.find((a) => {
+                return a.name.value === 'after';
+            });
+            if (!after)
+                return false;
+            if (after.value.kind === 'StringValue' || after.value.kind === 'Variable') {
+                let operationNode = operationNodeAncestor(ancestors);
+                if (!operationNode) {
+                    return false;
+                }
+                let key = buildKeyStringForRecordQuery(operationNode, variables, node.arguments || [], node.name.value);
+                // pagination metadata may be missing, e.g. due to being offline
+                let paginationMetadata = paginationMetadataMap.get(key) || {};
+                if (after.value.kind === 'StringValue') {
+                    let originalValue = after.value.value;
+                    mappedCursors.set(key, originalValue);
+                    let mappedValue = mapCursorValue(originalValue, paginationMetadata);
+                    if (!mappedValue) {
+                        // there were no results from the server, remove after argument
+                        return {
+                            ...node,
+                            arguments: node.arguments.filter((a) => a !== after),
+                        };
+                    }
+                    // return a new replacement node
+                    return {
+                        ...node,
+                        arguments: node.arguments.map((a) => {
+                            if (a !== after)
+                                return a;
+                            return {
+                                ...a,
+                                value: {
+                                    kind: 'StringValue',
+                                    value: mappedValue,
+                                },
+                            };
+                        }),
+                    };
+                }
+                else if (after.value.kind === 'Variable') {
+                    // rewrite the variable
+                    let variableName = after.value.name.value;
+                    let variableValue = variables[variableName];
+                    mappedCursors.set(key, variableValue);
+                    let mappedValue = mapCursorValue(variableValue, paginationMetadata);
+                    variables[variableName] = mappedValue;
+                }
+                // don't need to descend into this node
+                return false;
+            }
+        },
+    });
+    return {
+        ast,
+        mappedCursors,
+    };
+}
+async function readPaginationMetadataForKeys(keys, query) {
+    let metadataMap = new Map();
+    if (keys.length === 0)
+        return metadataMap;
+    const sql = `SELECT key, data FROM lds_data WHERE key in (${Array(keys.length)
+        .fill('?')
+        .join(',')})`;
+    const results = await query(sql, keys.map((k) => k + '__pagination'));
+    for (let row of results.rows) {
+        let key = row[0].replace(/__pagination$/, '');
+        let metadata = parse$3(row[1]);
+        metadataMap.set(key, metadata);
+    }
+    return metadataMap;
+}
+
 /*
 resolves connections...
 */
@@ -56026,8 +56432,14 @@ async function connectionResolver(obj, args, context, info) {
         const childRelationship = parentObjectInfo &&
             parentObjectInfo.childRelationships.find((rel) => rel.relationshipName === info.fieldName);
         // or emit/throw if we want to report it
-        if (!childRelationship)
-            return { records: [], hasNextPage: false };
+        if (!childRelationship) {
+            return {
+                records: [],
+                hasNextPage: false,
+                earlyEnd: false,
+                offset: 0,
+            };
+        }
         alias = childRelationship.childObjectApiName;
         childRelationshipFieldName = childRelationship.fieldName;
     }
@@ -56046,7 +56458,12 @@ async function connectionResolver(obj, args, context, info) {
     }
     let offset = 0;
     if (args.after) {
-        offset = decodeV1Cursor(args.after) + 1;
+        let originalCursor = context.mappedCursors.get(queryCacheKey);
+        if (!originalCursor) {
+            // eslint-disable-next-line @salesforce/lds/no-error-in-production
+            throw new Error('Internal Error: unable to determine `after` cursor value');
+        }
+        offset = decodeV1Cursor(originalCursor).i;
     }
     // if the query wants to know `hasNextPage` then we need to request 1 additional record
     let selections = info.fieldNodes
@@ -56055,7 +56472,7 @@ async function connectionResolver(obj, args, context, info) {
     let wantsHasNextPage = selectionIncludesHasNextPage(selections, info.fragments);
     let paginationMetadata = undefined;
     if (wantsHasNextPage) {
-        paginationMetadata = await readPaginationMetadataForKey(queryCacheKey, query);
+        paginationMetadata = await readPaginationMetadataForKeys([queryCacheKey], query);
     }
     let internalLimit = limit + (wantsHasNextPage ? 1 : 0);
     // Alias starts as entity's ApiName
@@ -56066,36 +56483,60 @@ async function connectionResolver(obj, args, context, info) {
         orderBy: orderByToPredicate(args.orderBy, alias, alias, context.objectInfos),
         limit: internalLimit,
         offset,
-        ingestionTimestamp,
     };
     const { sql, bindings } = buildQuery(queryConfig);
     const results = await query(sql, bindings);
     let hasNextPage = false;
+    let earlyEnd = false;
     if (wantsHasNextPage) {
         if (results.rows.length > limit) {
             // more records exist in the cache
             hasNextPage = true;
             results.rows.pop();
         }
-        else if (!paginationMetadata || paginationMetadata.__END__ === undefined) {
+        else if (!paginationMetadata ||
+            !paginationMetadata.has(queryCacheKey) ||
+            paginationMetadata.get(queryCacheKey).__END__ === undefined) {
             // more records may exist on the server
             hasNextPage = true;
+            // we hit the end of our local records, so we need to know that we
+            // should start at the end of known server cursors
+            if (results.rows.length < limit) {
+                earlyEnd = true;
+            }
         }
     }
     //map each sql result with the ingestion timestamp to pass it down a level
-    let records = results.rows
-        .map((row) => parse$3(row[0]))
-        .map((recordRepresentation, index) => {
+    let records = results.rows.map((row, index) => {
+        const recordMetadataResult = {
+            recordRepresentation: parse$3(row[0]),
+            metadata: parse$3(row[1]),
+        };
+        const { recordRepresentation, metadata } = recordMetadataResult;
         context.seenRecordIds.add(recordRepresentation.id);
+        if (metadata.ingestionTimestamp < ingestionTimestamp &&
+            recordRepresentation.drafts === undefined) {
+            if (context.possibleStaleRecordMap.has(recordRepresentation.apiName) === false) {
+                context.possibleStaleRecordMap.set(recordRepresentation.apiName, []);
+            }
+            const ids = context.possibleStaleRecordMap.get(recordRepresentation.apiName);
+            if (ids !== undefined) {
+                ids.push(recordRepresentation.id);
+                context.possibleStaleRecordMap.set(recordRepresentation.apiName, ids);
+            }
+        }
         return {
             recordRepresentation,
             ingestionTimestamp,
-            index: index + offset,
+            index: index + offset + 1,
+            earlyEnd,
         };
     });
     return {
         records,
         hasNextPage,
+        earlyEnd,
+        offset,
     };
 }
 /**
@@ -56893,7 +57334,7 @@ function getTextAreaType(field) {
     return 'TextAreaValue';
 }
 
-async function evaluate(config, observers, settings, objectInfos, store, snapshot, cache, draftFunctions) {
+async function evaluate(config, observers, settings, objectInfos, store, snapshot, cache, draftFunctions, mappedCursors) {
     const eventEmitter = createCustomAdapterEventEmitter(GRAPHQL_EVAL_NAMESPACE, observers);
     // this is only wrapped in a try to execute the event after the result was returned
     try {
@@ -56952,7 +57393,7 @@ async function evaluate(config, observers, settings, objectInfos, store, snapsho
         eventEmitter({ type: 'graphql-preconditions-met' });
         // create the resolver request context, runtime values and functions for
         // resolvers to do their job.
-        const contextValue = createContext(store, objectInfos, eventEmitter, settings, snapshot, draftFunctions);
+        const contextValue = createContext(store, objectInfos, eventEmitter, settings, snapshot, mappedCursors, draftFunctions);
         // We're building this from scratch from each request.  If this becomes a
         // hotspot we can pull it up and memoize it later
         const schema = createSchemaWithCache(objectInfos, cache);
@@ -56977,7 +57418,11 @@ async function evaluate(config, observers, settings, objectInfos, store, snapsho
                 seenRecordIds.push(queryString);
             });
         }
-        return { result, seenRecordIds };
+        return {
+            result,
+            seenRecordIds,
+            possibleStaleRecordMap: contextValue.possibleStaleRecordMap,
+        };
     }
     finally {
         eventEmitter({ type: 'graphql-eval-end' });
@@ -58701,7 +59146,11 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
     return async function draftAwareGraphQLAdapter(config, buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy, requestContext = {}) {
         //create a copy to not accidentally modify the AST in the astResolver map of luvio
         const copy = parse$3(stringify$3(config.query));
+        // the injected ast has extra fields needed for eval in it
         let injectedAST;
+        // the cursor mapped ast is passed upstream so it won't reject on our local cursors
+        let cursorMappedAST;
+        let mappedCursors = new Map();
         let objectInfoNeeded = {};
         let unmappedDraftIDs;
         let internalRequestContext = {
@@ -58717,6 +59166,7 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
                 objectInfos: objectInfoNeeded,
                 unmappedDraftIDs,
             } = await injectSyntheticFields(copy, objectInfoService, draftFunctions, config.variables));
+            ({ ast: cursorMappedAST, mappedCursors } = await mapPaginationCursors(injectedAST, config.variables || {}, store));
             if (config.variables) {
                 config.variables = replaceDraftIdsInVariables$1(config.variables, draftFunctions, unmappedDraftIDs);
             }
@@ -58748,7 +59198,7 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
         const nonEvaluatedSnapshot = (await luvio.applyCachePolicy(internalRequestContext, {
             config: {
                 ...config,
-                query: injectedAST,
+                query: cursorMappedAST,
             },
             luvio,
             gqlEval: true,
@@ -58761,12 +59211,17 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
             : [];
         let gqlResult;
         let seenRecordIds;
+        let possibleStaleRecordMap;
         try {
-            ({ result: gqlResult, seenRecordIds } = await evaluate({
+            ({
+                result: gqlResult,
+                seenRecordIds,
+                possibleStaleRecordMap,
+            } = await evaluate({
                 ...config,
                 //need to create another copy of the ast for future writes
                 query: parse$3(stringify$3(injectedAST)),
-            }, observers, { userId }, objectInfoNeeded, store, nonEvaluatedSnapshot, graphqlSchemaCache));
+            }, observers, { userId }, objectInfoNeeded, store, nonEvaluatedSnapshot, graphqlSchemaCache, draftFunctions, mappedCursors));
         }
         catch (throwable) {
             const error = throwable;
@@ -58792,13 +59247,18 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
         const seenRecords = createSeenRecords(seenRecordIds, nonEvaluatedSnapshot);
         const recordId = generateUniqueRecordId();
         const rebuildWithLocalEval = async (originalSnapshot) => {
-            let { result: rebuildResult, seenRecordIds } = await evaluate({
+            let { result: rebuildResult, seenRecordIds, possibleStaleRecordMap, } = await evaluate({
                 ...config,
                 query: injectedAST,
-            }, observers, { userId }, objectInfoNeeded, store, originalSnapshot, graphqlSchemaCache, draftFunctions);
+            }, observers, { userId }, objectInfoNeeded, store, originalSnapshot, graphqlSchemaCache, draftFunctions, mappedCursors);
             if (!rebuildResult.errors) {
                 rebuildResult = removeSyntheticFields(rebuildResult, config.query);
             }
+            let snapshotState = 'Fulfilled';
+            if (possibleStaleRecordMap.size > 0) {
+                initiateStaleRecordRefresh(luvio, possibleStaleRecordMap);
+                snapshotState = 'Stale';
+            }
             if (objectsDeepEqual(rebuildResult, originalSnapshot.data)) {
                 return originalSnapshot;
             }
@@ -58807,6 +59267,7 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
                 ...originalSnapshot,
                 data: rebuildResult,
                 recordId,
+                state: snapshotState,
                 seenRecords: createSeenRecords(seenRecordIds, nonEvaluatedSnapshot),
                 rebuildWithLocalEval,
             };
@@ -58844,9 +59305,31 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
                 },
             };
         }
+        if (possibleStaleRecordMap.size > 0) {
+            initiateStaleRecordRefresh(luvio, possibleStaleRecordMap);
+            resultSnapshot.state = 'Stale';
+        }
         return resultSnapshot;
     };
 }
+function initiateStaleRecordRefresh(luvio, keyMap) {
+    const staleRecordKeys = from$1(keyMap.values())
+        .flat()
+        .map((id) => `UiApi::RecordRepresentation:${id}`);
+    luvio.storeExpirePossibleStaleRecords(staleRecordKeys, makeGetRecordsConfig(keyMap), getRecordsAdapterFactory(luvio));
+}
+function makeGetRecordsConfig(keyMap) {
+    const records = [];
+    keyMap.forEach((recordIds, apiName) => {
+        records.push({
+            recordIds,
+            fields: [`${apiName}.Id`],
+        });
+    });
+    return {
+        records,
+    };
+}
 
 function environmentAwareGraphQLBatchAdapterFactory(objectInfoService, luvio, isDraftId) {
     return async function environmentAwareGraphQLBatchAdapter(config, buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy, requestContext = {}) {
@@ -59992,6 +60475,9 @@ class NimbusDraftQueue {
     removeHandler(_id) {
         return Promise.reject(new Error('Cannot call setMetadata from the NimbusDraftQueue'));
     }
+    updateDraftAction(_action) {
+        return Promise.reject(new Error('Cannot call updateDraftAction from the NimbusDraftQueue'));
+    }
 }
 
 function attachObserversToAdapterRequestContext(observers, adapterRequestContext) {
@@ -61105,6 +61591,21 @@ const NimbusBinaryStore = {
             __nimbus.plugins.LdsBinaryStorePlugin.setCanonicalUrl(uri, canonicalUrl, ttlSeconds, resolve, (err) => reject(errorMessageToError(err)));
         });
     },
+    createStream: function (type) {
+        return new Promise((resolve, reject) => {
+            __nimbus.plugins.LdsBinaryStorePlugin.createStream(type, resolve, (err) => reject(errorMessageToError(err)));
+        });
+    },
+    writeToStream: function (uri, chunk) {
+        return new Promise((resolve, reject) => {
+            __nimbus.plugins.LdsBinaryStorePlugin.writeToStream(uri, chunk, resolve, (err) => reject(errorMessageToError(err)));
+        });
+    },
+    closeStream: function (uri) {
+        return new Promise((resolve, reject) => {
+            __nimbus.plugins.LdsBinaryStorePlugin.closeStream(uri, resolve, (err) => reject(errorMessageToError(err)));
+        });
+    },
 };
 
 /**
@@ -62432,7 +62933,6 @@ let lazyDurableStore;
 let lazyNetworkAdapter;
 let lazyObjectInfoService;
 let lazyGetRecords;
-// TODO [W-123]: JHORST hoist, optimize and test this function
 const shouldFlush = (key, value) => {
     if (!isStoreKeyRecordId$1(key)) {
         return { flushValue: true };
@@ -62603,7 +63103,7 @@ register$1({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$2,
 });
-// version: 1.302.0-e45992a1f4
+// version: 1.304.0-aa3e5f9550
 
 const { create: create$3, keys: keys$3 } = Object;
 const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -82639,7 +83139,7 @@ register$1({
     configuration: { ...configurationForGraphQLAdapters$1 },
     instrument: instrument$1,
 });
-// version: 1.302.0-5fb014108f
+// version: 1.304.0-d87b57badb
 
 // On core the unstable adapters are re-exported with different names,
 // we want to match them here.
@@ -84895,7 +85395,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.302.0-5fb014108f
+// version: 1.304.0-d87b57badb
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -85630,7 +86130,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.302.0-e45992a1f4
+// version: 1.304.0-aa3e5f9550
 
 /**
  * Returns true if the value acts like a Promise, i.e. has a "then" function,
@@ -90592,4 +91092,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, evictCacheRecordsByIds, evictExpiredCacheEntries, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, invokeAdapter, invokeAdapterWithDraftToMerge, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, stopEviction, subscribeToAdapter };
-// version: 1.302.0-e45992a1f4
+// version: 1.304.0-aa3e5f9550