@salesforce/lds-worker-api 1.302.0 → 1.304.0

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

@@ -841,14 +841,7 @@
             // 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++) {
@@ -943,6 +936,16 @@
                 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;
         }
@@ -1537,14 +1540,7 @@
             // 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++) {
@@ -1667,6 +1663,19 @@
                 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);
@@ -2256,6 +2265,20 @@
             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);
@@ -3639,6 +3662,30 @@
         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 {
@@ -3705,6 +3752,9 @@
         storeCleanup() {
             this.environment.storeCleanup();
         }
+        storeExpirePossibleStaleRecords(keys, config, refresh) {
+            return this.environment.expirePossibleStaleRecords(keys, config, refresh);
+        }
         createSnapshot(selector, refresh) {
             return this.environment.createSnapshot(selector, refresh);
         }
@@ -4093,7 +4143,7 @@
         }
         return resourceParams;
     }
-    // engine version: 0.155.1-284dbf66
+    // engine version: 0.156.3-04c1a80e
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -4221,7 +4271,7 @@
         }
         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) {
@@ -15720,7 +15770,7 @@
         }
         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".
@@ -16649,7 +16699,7 @@
         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.,
@@ -16748,7 +16798,7 @@
         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;
 
@@ -18223,7 +18273,7 @@
     // 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',
@@ -18237,7 +18287,7 @@
             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
@@ -18254,7 +18304,7 @@
             childRelationships: CHILD_RELATIONSHIP_SELECTION,
             fields: createPathSelectionFromValue(record.fields),
         });
-        return [...sel.selections, DRAFTS_SELECTION];
+        return [...sel.selections, DRAFTS_SELECTION$1];
     }
 
     const MAX_RECORD_DEPTH = 5;
@@ -20478,6 +20528,12 @@
         }
         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';
@@ -20526,7 +20582,7 @@
                     name: key,
                     children: {},
                 };
-                if (isMissing(fieldRep)) {
+                if (fields.isMissing(key)) {
                     current.children[key] = next;
                     continue;
                 }
@@ -20585,14 +20641,6 @@
         }
         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: {},
@@ -20684,8 +20732,9 @@
             !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) {
@@ -20712,7 +20761,7 @@
             return;
         }
         const fieldValueValue = fieldValueRepresentation.object(fieldName);
-        if (isPending(fieldValueValue)) {
+        if (fieldValueRepresentation.isPending(fieldName)) {
             writeMissingFieldToStore(fieldValueRepresentation, fieldName);
             return;
         }
@@ -20742,7 +20791,8 @@
     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,
@@ -26509,6 +26559,12 @@
     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',
@@ -26540,7 +26596,7 @@
                 {
                     name: 'successMessage',
                     kind: 'Scalar'
-                }
+                }, DRAFTS_SELECTION,
             ]
         };
     };
@@ -44136,7 +44192,7 @@
         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) {
@@ -45820,6 +45876,32 @@
             }, 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',
@@ -45852,6 +45934,7 @@
             handleErrorResponse: { value: handleErrorResponse },
             getNotifyChangeStoreEntries: { value: getNotifyChangeStoreEntries },
             notifyStoreUpdateAvailable: { value: notifyStoreUpdateAvailable },
+            expirePossibleStaleRecords: { value: expirePossibleStaleRecords },
         });
     }
 
@@ -49898,7 +49981,7 @@
             if (status === DraftActionStatus.Error) {
                 this.state = DraftQueueState.Error;
                 this.processingAction = undefined;
-                this.notifyChangedListeners({
+                await this.notifyChangedListeners({
                     type: DraftQueueEventType.ActionFailed,
                     action: action,
                 });
@@ -49914,7 +49997,7 @@
             if (this.state === DraftQueueState.Waiting) {
                 this.state = DraftQueueState.Started;
             }
-            this.notifyChangedListeners({
+            await this.notifyChangedListeners({
                 type: DraftQueueEventType.ActionUploading,
                 action: { ...action, status: DraftActionStatus.Uploading },
             });
@@ -49991,6 +50074,31 @@
                 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);
         }
@@ -50021,17 +50129,21 @@
             });
             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();
@@ -50157,7 +50269,8 @@
                 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;
             });
@@ -50792,6 +50905,7 @@
         DraftQueueOperationType["ItemUpdated"] = "updated";
         DraftQueueOperationType["QueueStarted"] = "started";
         DraftQueueOperationType["QueueStopped"] = "stopped";
+        DraftQueueOperationType["QueueWaiting"] = "waiting";
     })(DraftQueueOperationType || (DraftQueueOperationType = {}));
     /**
      * Converts the internal DraftAction's ResourceRequest into
@@ -50834,6 +50948,16 @@
         };
     }
     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 = [
@@ -50847,7 +50971,7 @@
             ];
             this.draftQueue = draftQueue;
             draftQueue.registerOnChangedListener((event) => {
-                if (this.draftEventsShouldBeEmitted.includes(event.type)) {
+                if (this.shouldEmitEvent(event)) {
                     return this.callListeners(event);
                 }
                 return Promise.resolve();
@@ -50877,6 +51001,8 @@
                     return DraftQueueOperationType.QueueStarted;
                 case DraftQueueState.Stopped:
                     return DraftQueueOperationType.QueueStopped;
+                case DraftQueueState.Waiting:
+                    return DraftQueueOperationType.QueueWaiting;
                 default:
                     throw Error('Unsupported event type');
             }
@@ -50934,7 +51060,8 @@
          *
          * @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) => {
@@ -50961,6 +51088,60 @@
                 };
             });
         }
+        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;
@@ -51268,6 +51449,12 @@
     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
@@ -51959,12 +52146,9 @@
             }
             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) {
@@ -52759,6 +52943,7 @@
                 isCreated: true,
                 isSuccess: true,
                 successMessage: `record created.`,
+                drafts: { draftActionId: action.id },
             });
         }
         getDraftMetadata(_key) {
@@ -52876,6 +53061,7 @@
                 isCreated: false,
                 isSuccess: true,
                 successMessage: `record updated.`,
+                drafts: { draftActionId: action.id },
             });
         }
         async getDraftMetadata(key) {
@@ -52953,7 +53139,29 @@
         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
@@ -52976,7 +53184,14 @@
                 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,
@@ -53815,7 +54030,7 @@
         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();
@@ -53842,7 +54057,9 @@
             Record,
             snapshot,
             seenRecordIds: new Set(),
+            possibleStaleRecordMap: new Map(),
             draftFunctions,
+            mappedCursors,
         };
     }
 
@@ -54453,7 +54670,6 @@
 
     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) {
@@ -54994,14 +55210,10 @@
         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 ?
@@ -55013,7 +55225,6 @@
         const bindings = [
             // bindings from predicates on joins
             ...joins.bindings,
-            config.ingestionTimestamp,
             // where clause and parent scope bindings
             ...predicates.bindings,
             // limit binding
@@ -55040,29 +55251,19 @@
         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;
@@ -55731,11 +55932,15 @@
         }
         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) {
@@ -55936,44 +56141,87 @@
     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 }`
@@ -56011,6 +56259,164 @@
         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...
     */
@@ -56032,8 +56438,14 @@
             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;
         }
@@ -56052,7 +56464,12 @@
         }
         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
@@ -56061,7 +56478,7 @@
         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
@@ -56072,36 +56489,60 @@
             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,
         };
     }
     /**
@@ -56899,7 +57340,7 @@
         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 {
@@ -56958,7 +57399,7 @@
             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);
@@ -56983,7 +57424,11 @@
                     seenRecordIds.push(queryString);
                 });
             }
-            return { result, seenRecordIds };
+            return {
+                result,
+                seenRecordIds,
+                possibleStaleRecordMap: contextValue.possibleStaleRecordMap,
+            };
         }
         finally {
             eventEmitter({ type: 'graphql-eval-end' });
@@ -58707,7 +59152,11 @@
         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 = {
@@ -58723,6 +59172,7 @@
                     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);
                 }
@@ -58754,7 +59204,7 @@
             const nonEvaluatedSnapshot = (await luvio.applyCachePolicy(internalRequestContext, {
                 config: {
                     ...config,
-                    query: injectedAST,
+                    query: cursorMappedAST,
                 },
                 luvio,
                 gqlEval: true,
@@ -58767,12 +59217,17 @@
                 : [];
             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;
@@ -58798,13 +59253,18 @@
             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;
                 }
@@ -58813,6 +59273,7 @@
                     ...originalSnapshot,
                     data: rebuildResult,
                     recordId,
+                    state: snapshotState,
                     seenRecords: createSeenRecords(seenRecordIds, nonEvaluatedSnapshot),
                     rebuildWithLocalEval,
                 };
@@ -58850,9 +59311,31 @@
                     },
                 };
             }
+            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 = {}) {
@@ -59998,6 +60481,9 @@
         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) {
@@ -61111,6 +61597,21 @@
                 __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)));
+            });
+        },
     };
 
     /**
@@ -62438,7 +62939,6 @@
     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 };
@@ -62609,7 +63109,7 @@
         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;
@@ -82645,7 +83145,7 @@
         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.
@@ -84901,7 +85401,7 @@
         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,
@@ -85636,7 +86136,7 @@
     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,
@@ -90617,4 +91117,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.302.0-e45992a1f4
+// version: 1.304.0-aa3e5f9550