@salesforce/lds-worker-api 1.377.0 → 1.377.1

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

@@ -4280,7 +4280,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.377.0-3c95caf11c
+    // version: 1.377.1-dadb6358f3
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -5324,7 +5324,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.377.0-3c95caf11c
+    // version: 1.377.1-dadb6358f3
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -34160,7 +34160,7 @@
         throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
         throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
     });
-    // version: 1.377.0-b0d5c49e07
+    // version: 1.377.1-db77d3f339
 
     function requestIdleDetectedCallback(_callback) { }
     function declareNotifierTaskSingle(_name) {
@@ -45665,6 +45665,15 @@
         },
     };
 
+    var graphqlPartialEmitParity = {
+        isOpen: function (e) {
+            return e.fallback;
+        },
+        hasError: function () {
+            return !0;
+        },
+    };
+
     var caseSensitiveUserId = '005B0000000GR4OIAW';
 
     var ldsAdapterO11yLoggingGate = {
@@ -45812,47 +45821,47 @@
     };
     const ok$4 = (value) => new Ok$4(value);
     const err$4 = (err2) => new Err$4(err2);
-    function resolvedPromiseLike$4(result) {
-      if (isPromiseLike$4(result)) {
+    function resolvedPromiseLike$5(result) {
+      if (isPromiseLike$5(result)) {
         return result.then((nextResult) => nextResult);
       }
       return {
         then: (onFulfilled, _onRejected) => {
           try {
-            return resolvedPromiseLike$4(onFulfilled(result));
+            return resolvedPromiseLike$5(onFulfilled(result));
           } catch (e) {
             if (onFulfilled === void 0) {
-              return resolvedPromiseLike$4(result);
+              return resolvedPromiseLike$5(result);
             }
-            return rejectedPromiseLike$4(e);
+            return rejectedPromiseLike$5(e);
           }
         }
       };
     }
-    function rejectedPromiseLike$4(reason) {
-      if (isPromiseLike$4(reason)) {
+    function rejectedPromiseLike$5(reason) {
+      if (isPromiseLike$5(reason)) {
         return reason.then((nextResult) => nextResult);
       }
       return {
         then: (_onFulfilled, onRejected) => {
           if (typeof onRejected === "function") {
             try {
-              return resolvedPromiseLike$4(onRejected(reason));
+              return resolvedPromiseLike$5(onRejected(reason));
             } catch (e) {
-              return rejectedPromiseLike$4(e);
+              return rejectedPromiseLike$5(e);
             }
           }
-          return rejectedPromiseLike$4(reason);
+          return rejectedPromiseLike$5(reason);
         }
       };
     }
-    function isPromiseLike$4(x) {
+    function isPromiseLike$5(x) {
       return typeof (x == null ? void 0 : x.then) === "function";
     }
     function racesync(values) {
       for (const value of values) {
         let settled = void 0;
-        if (isPromiseLike$4(value)) {
+        if (isPromiseLike$5(value)) {
           value.then(
             (_) => {
               settled = value;
@@ -45862,7 +45871,7 @@
             }
           );
         } else {
-          settled = resolvedPromiseLike$4(value);
+          settled = resolvedPromiseLike$5(value);
         }
         if (settled !== void 0) {
           return settled;
@@ -46011,7 +46020,7 @@
       );
     }
     function setServices(services) {
-      waitForServices = resolvedPromiseLike$4(services);
+      waitForServices = resolvedPromiseLike$5(services);
       servicesAvailable(services);
     }
 
@@ -61599,7 +61608,7 @@
     // Deep merge that works on GraphQL data. It:
     // - recursively merges any Object properties that are present in both
     // - recursively merges arrays by deepMerging each Object item in the array (by index).
-    function deepMerge$2(target, ...sources) {
+    function deepMerge$3(target, ...sources) {
         for (const source of sources) {
             for (const key in source) {
                 if (ObjectPrototypeHasOwnProperty$2.call(source, key)) {
@@ -61620,7 +61629,7 @@
                                 !Array.isArray(targetItem) &&
                                 sourceItem instanceof Object &&
                                 !Array.isArray(sourceItem)) {
-                                return deepMerge$2({}, targetItem, sourceItem);
+                                return deepMerge$3({}, targetItem, sourceItem);
                             }
                             else {
                                 return sourceItem;
@@ -61631,7 +61640,7 @@
                         !Array.isArray(targetValue) &&
                         sourceValue instanceof Object &&
                         !Array.isArray(sourceValue)) {
-                        deepMerge$2(targetValue, sourceValue);
+                        deepMerge$3(targetValue, sourceValue);
                     }
                     else {
                         target[key] = sourceValue;
@@ -79249,7 +79258,7 @@
         field.selectionSet?.selections.forEach((sel) => {
             const builtSelection = buildSelectionForNodeFn(source, reader, field, sel, variables, fragments, parentRecordId);
             if (builtSelection !== undefined) {
-                deepMerge$2(sink, builtSelection);
+                deepMerge$3(sink, builtSelection);
             }
         });
         return sink;
@@ -81995,6 +82004,7 @@
             possibleStaleRecordMap: new Map(),
             draftFunctions,
             mappedCursors,
+            missingFieldsMap: new Map(),
         };
     }
 
@@ -85596,8 +85606,17 @@
                                 field.resolve = connectionResolver;
                             }
                             else {
-                                field.resolve = function recordFieldResolver({ recordRepresentation: record, }) {
-                                    return record.fields[field.name] || null;
+                                field.resolve = function recordFieldResolver({ recordRepresentation: record }, _args, { missingFieldsMap }) {
+                                    const { id, fields } = record;
+                                    const recordField = fields[field.name];
+                                    // If the field is not present, add it to the missing fields map
+                                    if (!recordField) {
+                                        let missingFieldsSet = missingFieldsMap.get(id) ?? new Set();
+                                        missingFieldsSet.add(field.name);
+                                        missingFieldsMap.set(id, missingFieldsSet);
+                                        return null;
+                                    }
+                                    return recordField;
                                 };
                             }
                         }
@@ -86188,6 +86207,7 @@
                 result,
                 seenRecordIds,
                 possibleStaleRecordMap: contextValue.possibleStaleRecordMap,
+                missingFieldsMap: contextValue.missingFieldsMap,
             };
         }
         finally {
@@ -87015,9 +87035,9 @@
                             }
                             // spanning field needs to have the directive with 'parentRelationship'
                             const directives = isSpanning && !isInlineFragment ? [parentRelationshipDirective] : [];
-                            let idField = isSpanning && !isPolymorphicField ? [createFieldNode('Id')] : [];
+                            let idField = isSpanning && !isPolymorphicField ? [createFieldNode$1('Id')] : [];
                             // This variable change to InlineFragment if 'isInlineFragment' is true
-                            let sel = createFieldNode(fieldName);
+                            let sel = createFieldNode$1(fieldName);
                             // Check if fields is valid
                             if (apiNames.length === 1 && !isInlineFragment) {
                                 const objectInfo = objectInfos[apiNames[0]];
@@ -87063,7 +87083,7 @@
                                     idField = [];
                                 }
                                 if (isInlineFragment && !isTypeNameExisting) {
-                                    idField.push(createFieldNode('__typename'));
+                                    idField.push(createFieldNode$1('__typename'));
                                 }
                                 //Inject Conditions: 1. Same field does not exist 2. Same fields has different children. 3. Filter spanning field does not have Id. 4. InLineFragment does not have the '__typename' field
                                 if (!existingFields ||
@@ -87130,7 +87150,7 @@
                                         .filter(isFieldNode)
                                         .filter((subNode) => subNode.name.value === relationField);
                                 if (!existingRelationFields || existingRelationFields.length === 0) {
-                                    injectedSelections.push(createFieldNode(relationField, FieldValueNodeSelectionSet));
+                                    injectedSelections.push(createFieldNode$1(relationField, FieldValueNodeSelectionSet));
                                 }
                             }
                         }
@@ -87221,7 +87241,7 @@
                 .filter(isFieldNode)
                 .filter((subNode) => subNode.name.value === 'value');
         return !existingValueFields || existingValueFields.length === 0
-            ? [createFieldNode('value')]
+            ? [createFieldNode$1('value')]
             : [];
     }
     function updateIDInfo(fieldNode, idState, draftFunctions) {
@@ -87302,20 +87322,20 @@
                         .filter(isFieldNode)
                         .filter((subNode) => subNode.name.value === relationshipId);
                     if (existingRelationFields.length === 0) {
-                        parentInjectedNodes.push(createFieldNode(relationshipId, FieldValueNodeSelectionSet));
+                        parentInjectedNodes.push(createFieldNode$1(relationshipId, FieldValueNodeSelectionSet));
                     }
                 }
                 // For polymorphic fields, the Id field is excluded.
                 const excludeId = isPolymorphicFieldPath(curPath, pathToObjectApiNamesMap, objectInfos);
                 const idSelection = [];
                 if (!excludeId && hasIdNode === false) {
-                    idSelection.push(createFieldNode('Id'));
+                    idSelection.push(createFieldNode$1('Id'));
                 }
                 // Inject '__typename' for InlineFragment. '__typename' field acts as a reference to concrete type of a polymorphic field or a standard field in the returned GQL response, which equals to
                 // `typedCondition` of the InlineFragment in the query AST. It is used to match JSON response with AST node. For more detail, please reference 'removeSyntheticFields'.
                 if (isInlineFragmentNode(selection) &&
                     !selection.selectionSet.selections.find((selection) => isFieldNode(selection) && selection.name.value === '__typename')) {
-                    idSelection.push(createFieldNode('__typename'));
+                    idSelection.push(createFieldNode$1('__typename'));
                 }
                 // 'ServiceAppointment' --> 'Contact' --> 'Id', Inject 'Contact' with Id. 'Id' field is at the sub level.
                 if (idSelection.length > 0 || subInjectedSelections.length > 0) {
@@ -87359,7 +87379,7 @@
                 objectInfo.nameFields !== undefined &&
                 objectInfo.nameFields.length > 0) {
                 displayValueNameFields = objectInfo.nameFields.map((fieldName) => {
-                    return createFieldNode(fieldName, FieldValueNodeSelectionSet);
+                    return createFieldNode$1(fieldName, FieldValueNodeSelectionSet);
                 });
             }
         }
@@ -87390,7 +87410,7 @@
             if (parentNode.name.value === 'node') {
                 const idNode = findIdFieldNode(parentNode);
                 if (idNode === false) {
-                    rootQueryIdField.push(createFieldNode('Id'));
+                    rootQueryIdField.push(createFieldNode$1('Id'));
                 }
             }
             // example { node { Id } }. The operation happens at the 'edges' -> 'node'  level of the 'childRelationship' field
@@ -87418,7 +87438,7 @@
                                 .filter(isFieldNode)
                                 .some((sibling) => sibling.name.value === injectedParentFieldName)) {
                                 // example: TimeSheetId { value }
-                                relatedIdForChildRelationship.push(createFieldNode(injectedParentFieldName, FieldValueNodeSelectionSet));
+                                relatedIdForChildRelationship.push(createFieldNode$1(injectedParentFieldName, FieldValueNodeSelectionSet));
                             }
                             displayValueNameFields.push(...injectFieldsForDisplayValue(parentNode, targetRelationship.childObjectApiName, objectInfos));
                         }
@@ -87870,7 +87890,7 @@
      * @param selectionSet
      * @returns
      */
-    function createFieldNode(nameValue, selectionSet) {
+    function createFieldNode$1(nameValue, selectionSet) {
         return {
             kind: Kind$3.FIELD,
             name: {
@@ -88354,11 +88374,13 @@
             let gqlResult;
             let seenRecordIds;
             let possibleStaleRecordMap;
+            let missingFieldsMap;
             try {
                 ({
                     result: gqlResult,
                     seenRecordIds,
                     possibleStaleRecordMap,
+                    missingFieldsMap,
                 } = await evaluate({
                     ...config,
                     //need to create another copy of the ast for future writes
@@ -88388,13 +88410,23 @@
             const seenRecords = createSeenRecords(seenRecordIds, nonEvaluatedSnapshot);
             const recordId = generateUniqueRecordId();
             const rebuildWithLocalEval = async (originalSnapshot) => {
-                let { result: rebuildResult, seenRecordIds, possibleStaleRecordMap, } = await evaluate({
+                let { result: rebuildResult, seenRecordIds, possibleStaleRecordMap, missingFieldsMap: rebuildMissingFieldsMap, } = await evaluate({
                     ...config,
                     query: injectedAST,
                 }, observers, { userId }, objectInfoNeeded, store, originalSnapshot, graphqlSchemaCache, draftFunctions, mappedCursors);
                 if (!rebuildResult.errors) {
                     rebuildResult = removeSyntheticFields(rebuildResult, config.query);
                 }
+                // If the query includes any missing fields, we return an ErrorSnapshot
+                // with a message that contains the missing fields for each record.
+                if (graphqlPartialEmitParity.isOpen({ fallback: false }) &&
+                    rebuildMissingFieldsMap.size > 0) {
+                    const missingFieldsErrorSnapshot = createMissingFieldsErrorSnapshot(originalSnapshot, rebuildMissingFieldsMap);
+                    return {
+                        ...missingFieldsErrorSnapshot,
+                        rebuildWithLocalEval,
+                    };
+                }
                 let snapshotState = 'Fulfilled';
                 if (possibleStaleRecordMap.size > 0) {
                     initiateStaleRecordRefresh(luvio, possibleStaleRecordMap);
@@ -88429,6 +88461,10 @@
                     },
                 };
             }
+            // If the query includes any missing fields, we return an ErrorSnapshot
+            if (graphqlPartialEmitParity.isOpen({ fallback: false }) && missingFieldsMap.size > 0) {
+                return createMissingFieldsErrorSnapshot(nonEvaluatedSnapshot, missingFieldsMap);
+            }
             // if the non-eval'ed snapshot was an error then we return a synthetic
             // Fulfilled snapshot (this only happens in this code path if
             // the error is network error or 504), otherwise we spread over
@@ -88485,6 +88521,30 @@
             records,
         };
     }
+    /**
+     * Creates an ErrorSnapshot with a message that contains the missing fields for each record.
+     * @param originalSnapshot The original snapshot that is being rebuilt.
+     * @param missingFieldsMap A map of record ids to the fields that are missing.
+     * @returns An ErrorSnapshot with a message that contains the missing fields for each record.
+     */
+    function createMissingFieldsErrorSnapshot(originalSnapshot, missingFieldsMap) {
+        const message = Array.from(missingFieldsMap)
+            .map(([id, fields]) => `Missing fields for record ${id}: ${Array.from(fields).join(', ')}`)
+            .join('; ');
+        return {
+            ...originalSnapshot,
+            data: undefined,
+            state: 'Error',
+            error: {
+                errorType: 'adapterError',
+                error: [
+                    {
+                        message,
+                    },
+                ],
+            },
+        };
+    }
 
     function environmentAwareGraphQLBatchAdapterFactory(objectInfoService, luvio, isDraftId, buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy) {
         return async function environmentAwareGraphQLBatchAdapter(config, requestContext = {}) {
@@ -93884,13 +93944,13 @@
       }
       return new Error(typeof x === "string" ? x : JSON.stringify(x));
     }
-    class InternalError extends Error {
+    let InternalError$1 = class InternalError extends Error {
       constructor(data) {
         super();
         this.data = data;
         this.type = "internal";
       }
-    }
+    };
     class UserVisibleError extends Error {
       constructor(data) {
         super();
@@ -93962,7 +94022,7 @@
       async afterRequestHooks(_options) {
       }
     };
-    function buildServiceDescriptor$g() {
+    function buildServiceDescriptor$h() {
       return {
         type: "networkCommandBaseClass",
         version: "1.0",
@@ -94064,7 +94124,7 @@
         return resolvedPromiseLike$3(err$1$1(toError("Aura/Fetch network services not found")));
       }
     }
-    function buildServiceDescriptor$f() {
+    function buildServiceDescriptor$g() {
       return {
         type: "auraNetworkCommandBaseClass",
         version: "1.0",
@@ -94564,7 +94624,7 @@
         return resolvedPromiseLike$3(void 0);
       }
     }
-    function buildServiceDescriptor$e() {
+    function buildServiceDescriptor$f() {
       return {
         type: "auraNormalizedCacheControlCommand",
         version: "1.0",
@@ -94710,7 +94770,7 @@
         return `{"endpoint":${this.endpoint},"params":${stableJSONStringify$2(this.auraParams)}}`;
       }
     }
-    function buildServiceDescriptor$d() {
+    function buildServiceDescriptor$e() {
       return {
         type: "auraResourceCacheControlCommand",
         version: "1.0",
@@ -94817,7 +94877,7 @@
         );
       }
     }
-    function buildServiceDescriptor$c() {
+    function buildServiceDescriptor$d() {
       return {
         type: "fetchNetworkCommandBaseClass",
         version: "1.0",
@@ -94906,7 +94966,7 @@
         return resolvedPromiseLike$3(void 0);
       }
     }
-    function buildServiceDescriptor$b() {
+    function buildServiceDescriptor$c() {
       return {
         type: "httpNormalizedCacheControlCommand",
         version: "1.0",
@@ -95159,7 +95219,7 @@
         return new FixedTimeWritableCache$1(this, generatedTime);
       }
     };
-    function buildServiceDescriptor$a() {
+    function buildServiceDescriptor$b() {
       return {
         type: "cache",
         version: "1.0",
@@ -95327,7 +95387,7 @@
         yield* this.services.cacheInclusionPolicy.findAndModify(query, cacheUpdate);
       }
     }
-    function buildServiceDescriptor$9(cache, cacheInclusionPolicy) {
+    function buildServiceDescriptor$a(cache, cacheInclusionPolicy) {
       return {
         type: "cacheController",
         version: "1.0",
@@ -95373,7 +95433,7 @@
         };
       };
     }
-    function buildServiceDescriptor$8(instrumentation) {
+    function buildServiceDescriptor$9(instrumentation) {
       return {
         type: "instrumentCommand",
         version: "1.0",
@@ -95643,7 +95703,7 @@
         this.metrics = new O11yOTelMetricsAPI(this.services);
       }
     }
-    function buildServiceDescriptor$7(logger) {
+    function buildServiceDescriptor$8(logger) {
       return {
         type: "instrumentation",
         version: "1.0",
@@ -95753,7 +95813,7 @@
         return matchingSubscriptions;
       }
     }
-    function buildServiceDescriptor$6() {
+    function buildServiceDescriptor$7() {
       return {
         type: "pubSub",
         version: "1.0",
@@ -95777,7 +95837,7 @@
         return this.flags.get(flagName) || defaultValue;
       }
     }
-    function buildServiceDescriptor$5() {
+    function buildServiceDescriptor$6() {
       return {
         version: "1.0",
         service: new FeatureFlagsService(),
@@ -95818,7 +95878,7 @@
      * };
      * ```
      */
-    function buildServiceDescriptor$4(luvio) {
+    function buildServiceDescriptor$5(luvio) {
         return {
             type: 'luvio',
             version: '1.0',
@@ -95827,7 +95887,33 @@
             },
         };
     }
-    // version: 1.377.0-b0d5c49e07
+    // version: 1.377.1-db77d3f339
+
+    /**
+     * Copyright (c) 2022, Salesforce, Inc.,
+     * All rights reserved.
+     * For full license text, see the LICENSE.txt file
+     */
+
+    /*
+     *  ATTENTION!
+     *  THIS IS A GENERATED FILE FROM https://github.com/salesforce-experience-platform-emu/lds-lightning-platform
+     *  If you would like to contribute to LDS, please follow the steps outlined in the git repo.
+     *  Any changes made to this file in p4 will be automatically overwritten.
+     *  *******************************************************************************************
+     */
+    /* proxy-compat-disable */
+    function buildServiceDescriptor$4(notifyRecordUpdateAvailable, getNormalizedLuvioRecord) {
+        return {
+            type: 'luvioUiapiRecords',
+            version: '1.0',
+            service: {
+                notifyRecordUpdateAvailable,
+                getNormalizedLuvioRecord,
+            },
+        };
+    }
+    // version: 1.377.1-db77d3f339
 
     /*!
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -96694,7 +96780,7 @@
       }
       return err$1$1(new Error("Multiple operations found in query, and no operation name provided"));
     }
-    function buildGraphQLInputExtension(input) {
+    function buildGraphQLInputExtension$1(input) {
       const operationResult = findExecutableOperation$1(input);
       if (operationResult.isErr()) {
         return err$1$1(operationResult.error);
@@ -96737,7 +96823,7 @@
         return this.documentRootType;
       }
       buildQuery() {
-        const extensionResult = buildGraphQLInputExtension(this.config);
+        const extensionResult = buildGraphQLInputExtension$1(this.config);
         if (extensionResult.isErr()) {
           throw extensionResult.error;
         }
@@ -96846,12 +96932,12 @@
         return augmentedQueryResult.value;
       }
       buildWriteInput(data) {
-        const extensionResult = buildGraphQLInputExtension({
+        const extensionResult = buildGraphQLInputExtension$1({
           ...this.config,
           query: this.buildRequestQuery()
         });
         if (extensionResult.isErr()) {
-          throw new InternalError(extensionResult.error);
+          throw new InternalError$1(extensionResult.error);
         }
         return { data: data.data, ...extensionResult.value };
       }
@@ -96896,7 +96982,7 @@
         return this.documentRootType;
       }
       buildQuery() {
-        const extensionResult = buildGraphQLInputExtension(this.config);
+        const extensionResult = buildGraphQLInputExtension$1(this.config);
         if (extensionResult.isErr()) {
           throw extensionResult.error;
         }
@@ -96940,12 +97026,12 @@
         return augmentedQueryResult.value;
       }
       buildWriteInput(data) {
-        const extensionResult = buildGraphQLInputExtension({
+        const extensionResult = buildGraphQLInputExtension$1({
           ...this.config,
           query: this.buildRequestQuery()
         });
         if (extensionResult.isErr()) {
-          throw new InternalError(extensionResult.error);
+          throw new InternalError$1(extensionResult.error);
         }
         return { data: data.data, ...extensionResult.value };
       }
@@ -97188,41 +97274,41 @@
       }
       return differenceSet;
     }
-    function resolvedPromiseLike(result) {
-      if (isPromiseLike(result)) {
+    function resolvedPromiseLike$4(result) {
+      if (isPromiseLike$4(result)) {
         return result.then((nextResult) => nextResult);
       }
       return {
         then: (onFulfilled, _onRejected) => {
           try {
-            return resolvedPromiseLike(onFulfilled(result));
+            return resolvedPromiseLike$4(onFulfilled(result));
           } catch (e) {
             if (onFulfilled === void 0) {
-              return resolvedPromiseLike(result);
+              return resolvedPromiseLike$4(result);
             }
-            return rejectedPromiseLike(e);
+            return rejectedPromiseLike$4(e);
           }
         }
       };
     }
-    function rejectedPromiseLike(reason) {
-      if (isPromiseLike(reason)) {
+    function rejectedPromiseLike$4(reason) {
+      if (isPromiseLike$4(reason)) {
         return reason.then((nextResult) => nextResult);
       }
       return {
         then: (_onFulfilled, onRejected) => {
           if (typeof onRejected === "function") {
             try {
-              return resolvedPromiseLike(onRejected(reason));
+              return resolvedPromiseLike$4(onRejected(reason));
             } catch (e) {
-              return rejectedPromiseLike(e);
+              return rejectedPromiseLike$4(e);
             }
           }
-          return rejectedPromiseLike(reason);
+          return rejectedPromiseLike$4(reason);
         }
       };
     }
-    function isPromiseLike(x) {
+    function isPromiseLike$4(x) {
       return typeof (x == null ? void 0 : x.then) === "function";
     }
     /*!
@@ -97511,7 +97597,7 @@
           tempL1.keysUpdated.forEach((key) => keysToReviveRecordableCache.get(key));
           tempL1.missingKeysRead.forEach((key) => keysToReviveRecordableCache.get(key));
           const missingKeys = keysToReviveRecordableCache.missingKeysRead;
-          const revivePromiseLike = missingKeys.size > 0 ? this.revive(missingKeys, l1).then(() => void 0) : resolvedPromiseLike(void 0);
+          const revivePromiseLike = missingKeys.size > 0 ? this.revive(missingKeys, l1).then(() => void 0) : resolvedPromiseLike$4(void 0);
           return revivePromiseLike.then(() => {
             const recordableCache = l1.record();
             return writeToL1(recordableCache).then((result) => {
@@ -97704,10 +97790,10 @@
             globalThis.performance = { now: () => Date.now() };
         }
         const loggerService = new ConsoleLogger('ERROR');
-        const cacheServiceDescriptor = buildServiceDescriptor$a();
-        const instrumentationServiceDescriptor = buildServiceDescriptor$7(loggerService);
+        const cacheServiceDescriptor = buildServiceDescriptor$b();
+        const instrumentationServiceDescriptor = buildServiceDescriptor$8(loggerService);
         const nimbusSqliteOneStoreCacheServiceDescriptor = buildNimbusDurableCacheInclusionPolicyService(cacheServiceDescriptor.service, new NimbusSqliteOneStoreCache(sqliteStore));
-        const featureFlagsServiceDescriptor = buildServiceDescriptor$5();
+        const featureFlagsServiceDescriptor = buildServiceDescriptor$6();
         const featureFlagsService = featureFlagsServiceDescriptor.service;
         // This disables the OneStore GraphQL in this runtime
         // We made the decision to continue using the Luvio based version in Mobile
@@ -97717,21 +97803,22 @@
         const services = [
             instrumentationServiceDescriptor,
             buildNimbusFetchServiceDescriptor(),
-            buildServiceDescriptor$8(instrumentationServiceDescriptor.service),
+            buildServiceDescriptor$9(instrumentationServiceDescriptor.service),
             // NOTE: These do not directly depend on Aura, and are necessary for HTTP fallback support.
+            buildServiceDescriptor$g(),
             buildServiceDescriptor$f(),
             buildServiceDescriptor$e(),
+            buildServiceDescriptor$a(cacheServiceDescriptor.service, nimbusSqliteOneStoreCacheServiceDescriptor.service),
             buildServiceDescriptor$d(),
-            buildServiceDescriptor$9(cacheServiceDescriptor.service, nimbusSqliteOneStoreCacheServiceDescriptor.service),
+            buildServiceDescriptor$h(),
             buildServiceDescriptor$c(),
-            buildServiceDescriptor$g(),
-            buildServiceDescriptor$b(),
-            buildServiceDescriptor$6(),
+            buildServiceDescriptor$7(),
             buildServiceDescriptor$3(),
             buildServiceDescriptor$2(),
             featureFlagsServiceDescriptor,
             // Luvio service won't be used since we set the useOneStoreGraphQL flag to false
-            buildServiceDescriptor$4({}),
+            buildServiceDescriptor$5({}),
+            buildServiceDescriptor$4({}, {}),
             // TODO[@W-18753648]: See note above.
             // buildStreamingCommandServiceDescriptor(),
             // buildNdJsonServiceDescriptor(),
@@ -97942,7 +98029,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$2,
     });
-    // version: 1.377.0-3c95caf11c
+    // version: 1.377.1-dadb6358f3
 
     const { create: create$3, keys: keys$3 } = Object;
     const { stringify: stringify$1, parse } = JSON;
@@ -98832,7 +98919,7 @@
         new Error(`Expected ${expectedTypeString}, but got ${actualType}: ${JSON.stringify(value)}`)
       );
     }
-    function deepMerge$1(target, ...sources) {
+    function deepMerge$2(target, ...sources) {
       for (const source of sources) {
         for (const key in source) {
           if (hasOwnProperty$2.call(source, key)) {
@@ -98848,13 +98935,13 @@
                 } else if (sourceItem === void 0) {
                   return targetItem;
                 } else if (targetItem instanceof Object && !Array.isArray(targetItem) && sourceItem instanceof Object && !Array.isArray(sourceItem)) {
-                  return deepMerge$1({}, targetItem, sourceItem);
+                  return deepMerge$2({}, targetItem, sourceItem);
                 } else {
                   return sourceItem;
                 }
               });
             } else if (targetValue instanceof Object && !Array.isArray(targetValue) && sourceValue instanceof Object && !Array.isArray(sourceValue)) {
-              deepMerge$1(
+              deepMerge$2(
                 targetValue,
                 sourceValue
               );
@@ -98888,6 +98975,32 @@
       }
       return err$4(new Error("Multiple operations found in query, and no operation name provided"));
     }
+    function buildGraphQLInputExtension(input) {
+      const operationResult = findExecutableOperation(input);
+      if (operationResult.isErr()) {
+        return err$4(operationResult.error);
+      }
+      const operation = operationResult.value;
+      const selections = operation.selectionSet.selections;
+      const variableDefinitions = operation.variableDefinitions;
+      const variables = (variableDefinitions == null ? void 0 : variableDefinitions.reduce((prev, def) => {
+        var _a;
+        prev[def.variable.name.value] = {
+          definition: def,
+          value: (_a = input.variables) == null ? void 0 : _a[def.variable.name.value]
+        };
+        return prev;
+      }, {})) || {};
+      const fragments = input.query.definitions.filter((def) => def.kind === "FragmentDefinition").reduce((prev, fragment) => {
+        prev[fragment.name.value] = fragment;
+        return prev;
+      }, {});
+      return ok$4({
+        selections,
+        request: { definitions: { variables, fragments } },
+        parentFieldSelection: void 0
+      });
+    }
     function buildUniqueAugmentedFieldSelection(newSelection, selections, fragments) {
       var _a;
       const baseAlias = ((_a = newSelection.alias) == null ? void 0 : _a.value) || newSelection.name.value;
@@ -99114,7 +99227,7 @@
         const errors = [];
         for (const selection of input.selections) {
           if (selection.kind === Kind.FIELD) {
-            deepMerge$1(
+            deepMerge$2(
               normalized,
               this.normalizeFieldSelection(cache, input, selection, errors)
             );
@@ -99135,7 +99248,7 @@
                 ]
               };
             }
-            deepMerge$1(normalized, this.normalizeFragment(cache, input, fragment, errors));
+            deepMerge$2(normalized, this.normalizeFragment(cache, input, fragment, errors));
           }
         }
         return buildReadWriteResult(normalized, errors);
@@ -99229,7 +99342,7 @@
         const denormalized = {};
         for (const selection of input.selections) {
           if (selection.kind === Kind.FIELD) {
-            deepMerge$1(
+            deepMerge$2(
               denormalized,
               this.denormalizeFieldSelection(cache, input, selection, errors)
             );
@@ -99250,7 +99363,7 @@
                 ]
               };
             }
-            deepMerge$1(denormalized, this.denormalizeFragment(cache, input, fragment, errors));
+            deepMerge$2(denormalized, this.denormalizeFragment(cache, input, fragment, errors));
           }
         }
         return buildReadWriteResult(denormalized, errors);
@@ -99466,7 +99579,7 @@
           return normalizeDataResult;
         }
         return ok$4(
-          deepMerge$1(
+          deepMerge$2(
             {},
             (existingNormalizedData == null ? void 0 : existingNormalizedData.value) || {},
             normalizeDataResult.value
@@ -100371,7 +100484,7 @@
       };
       return { invoke, subscribe };
     }
-    // version: 1.377.0-b0d5c49e07
+    // version: 1.377.1-db77d3f339
 
     class Analytics__AnalyticsBrowseRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
@@ -103055,6 +103168,50 @@
     }
     const ok = (value) => new Ok(value);
     const err = (err2) => new Err(err2);
+    function resolvedPromiseLike(result) {
+      if (isPromiseLike(result)) {
+        return result.then((nextResult) => nextResult);
+      }
+      return {
+        then: (onFulfilled, _onRejected) => {
+          try {
+            return resolvedPromiseLike(onFulfilled(result));
+          } catch (e) {
+            if (onFulfilled === void 0) {
+              return resolvedPromiseLike(result);
+            }
+            return rejectedPromiseLike(e);
+          }
+        }
+      };
+    }
+    function rejectedPromiseLike(reason) {
+      if (isPromiseLike(reason)) {
+        return reason.then((nextResult) => nextResult);
+      }
+      return {
+        then: (_onFulfilled, onRejected) => {
+          if (typeof onRejected === "function") {
+            try {
+              return resolvedPromiseLike(onRejected(reason));
+            } catch (e) {
+              return rejectedPromiseLike(e);
+            }
+          }
+          return rejectedPromiseLike(reason);
+        }
+      };
+    }
+    function isPromiseLike(x) {
+      return typeof (x == null ? void 0 : x.then) === "function";
+    }
+    class InternalError extends Error {
+      constructor(data) {
+        super();
+        this.data = data;
+        this.type = "internal";
+      }
+    }
 
     function buildGenericTypeFieldDef(selection, fields, staticFieldNames, typename) {
         // If the field is not a category field, return the base field def for the field
@@ -103172,12 +103329,25 @@
         }
         write(cache, input) {
             const result = super.write(cache, input);
-            input.data.Id;
+            const recordId = input.data.Id;
+            const luvioRecord = input.getNormalizedLuvioRecord(recordId, input.reader);
+            if (luvioRecord?.weakEtag &&
+                input.data?.WeakEtag &&
+                luvioRecord.weakEtag !== input.data.WeakEtag) {
+                input.luvioRecordIdsToInvalidate.push(recordId);
+            }
             return result;
         }
         read(cache, input) {
             const result = super.read(cache, input);
-            // TODO: read luvio record to track subscription
+            const idData = super.read(cache, {
+                ...input,
+                selections: [{ kind: 'Field', name: { kind: 'Name', value: 'Id' } }],
+            });
+            if (idData.isOk()) {
+                // Read the record to track subscription
+                input.getNormalizedLuvioRecord(idData.value.Id, input.reader);
+            }
             return result;
         }
     }
@@ -103459,6 +103629,155 @@
     }
 
     const CONFIG_SCHEMA = GraphQLQueryJsonSchema;
+
+    // Fields with arguments need to be aliased to avoid a potential conflict.
+    const ALIASED_FIELDS = {
+        ldsRecordTypeId: {
+            kind: Kind$1.FIELD,
+            name: {
+                kind: Kind$1.NAME,
+                value: 'RecordTypeId',
+            },
+            arguments: [
+                {
+                    kind: Kind$1.ARGUMENT,
+                    name: {
+                        kind: Kind$1.NAME,
+                        value: 'fallback',
+                    },
+                    value: {
+                        kind: Kind$1.BOOLEAN,
+                        value: true,
+                    },
+                },
+            ],
+            alias: {
+                kind: Kind$1.NAME,
+                value: 'ldsRecordTypeId',
+            },
+        },
+    };
+    // TODO: export graphql's deepMerge from @luvio/graphql-normalization? Promote to @luvio/utils?
+    function deepMerge$1(target, source) {
+        if (source === null || source === undefined)
+            return target;
+        if (target === null || target === undefined)
+            return source;
+        if (typeof source !== 'object' || typeof target !== 'object') {
+            return source;
+        }
+        if (Array.isArray(source)) {
+            return source;
+        }
+        const result = { ...target };
+        for (const key of Object.keys(source)) {
+            if (key === 'extensions') {
+                // Skip extensions key from final result
+                continue;
+            }
+            if (source[key] !== null &&
+                typeof source[key] === 'object' &&
+                !Array.isArray(source[key])) {
+                result[key] = deepMerge$1(result[key], source[key]);
+            }
+            else {
+                result[key] = source[key];
+            }
+        }
+        return result;
+    }
+    function createFieldNode(name, data) {
+        if (name === '__genericTypename') {
+            return undefined;
+        }
+        const baseField = ALIASED_FIELDS[name] ?? {
+            kind: Kind$1.FIELD,
+            name: {
+                kind: Kind$1.NAME,
+                value: name,
+            },
+        };
+        if (typeof data === 'object' && data !== null && data !== undefined) {
+            if (Array.isArray(data)) {
+                // For arrays, we need to merge the structure from all non-null elements
+                // to capture the full schema, not just the first element
+                let mergedStructure = {};
+                for (const item of data) {
+                    if (item !== null && typeof item === 'object' && !Array.isArray(item)) {
+                        mergedStructure = deepMerge$1(mergedStructure, item);
+                    }
+                }
+                if (Object.keys(mergedStructure).length > 0) {
+                    baseField.selectionSet = {
+                        kind: Kind$1.SELECTION_SET,
+                        selections: Object.entries(mergedStructure)
+                            .map(([key, value]) => createFieldNode(key, value))
+                            .filter((node) => node !== undefined),
+                    };
+                }
+            }
+            else {
+                baseField.selectionSet = {
+                    kind: Kind$1.SELECTION_SET,
+                    selections: Object.entries(data)
+                        .map(([key, value]) => createFieldNode(key, value))
+                        .filter((node) => node !== undefined),
+                };
+            }
+        }
+        return baseField;
+    }
+    function createASTFromExtensions(extensions) {
+        const fieldNodes = Object.entries(extensions)
+            .map(([field, value]) => createFieldNode(field, value))
+            .filter((node) => node !== undefined);
+        return {
+            kind: Kind$1.SELECTION_SET,
+            selections: fieldNodes,
+        };
+    }
+    function mergeASTs(query, extensionsAST) {
+        return {
+            ...query,
+            definitions: query.definitions.map((def) => {
+                if (def.kind === Kind$1.OPERATION_DEFINITION) {
+                    return {
+                        ...def,
+                        selectionSet: {
+                            kind: Kind$1.SELECTION_SET,
+                            selections: [...def.selectionSet.selections, ...extensionsAST.selections],
+                        },
+                    };
+                }
+                return def;
+            }),
+        };
+    }
+    /**
+     * Augments a query with the extensions from a response. The general algorithm is:
+     * 1. Create an AST from just the extensions.
+     * 2. Deep merge the extensions AST into the query AST.
+     * 3. Deep merge the extensions into the response data.
+     * 4. Return the augmented query and response.
+     * @param query - The query to augment.
+     * @param response - The response to augment the query with.
+     * @returns The augmented query and response.
+     */
+    function augmentQueryByResponse(query, response) {
+        const extensions = response.extensions?.lds || {};
+        const extensionsAST = createASTFromExtensions(extensions);
+        const augmentedQuery = mergeASTs(query, extensionsAST);
+        // Deep merge extensions into data, removing extensions key from result
+        const mergedData = deepMerge$1(response.data, extensions);
+        return {
+            query: augmentedQuery,
+            response: {
+                data: mergedData,
+                ...(response.errors && { errors: response.errors }),
+            },
+        };
+    }
+
     function buildCommandClass(baseClass) {
         return class extends baseClass {
             constructor(config, documentRootType, services) {
@@ -103466,21 +103785,169 @@
                 this.config = config;
                 this.documentRootType = documentRootType;
                 this.services = services;
-                this.endpoint = "RecordUiController.executeGraphQL";
-                this.operationType = "graphql";
+                this.endpoint = 'RecordUiController.executeGraphQL';
+            }
+            get url() {
+                return '/graphql';
             }
             get cacheControlStrategyConfig() {
                 return {
-                    type: "max-age",
+                    type: 'max-age',
                     requestMaxAge: 60,
                     now: Date.now() / 1000,
                 };
             }
-            get url() {
-                return "/graphql";
-            }
             get auraBodyWrapperName() {
-                return "queryInput";
+                return 'queryInput';
+            }
+            get auraParams() {
+                const params = super.auraParams;
+                const body = params[this.auraBodyWrapperName];
+                return {
+                    ...params,
+                    [this.auraBodyWrapperName]: {
+                        ...body,
+                        extensions: {
+                            ldsRequiredFields: true,
+                        },
+                    },
+                };
+            }
+            get fetchParams() {
+                const [url, params] = super.fetchParams;
+                const body = JSON.parse(params.body);
+                const modifiedBody = {
+                    ...body,
+                    extensions: {
+                        ldsRequiredFields: true,
+                    },
+                };
+                return [
+                    url,
+                    {
+                        ...params,
+                        body: JSON.stringify(modifiedBody),
+                    },
+                ];
+            }
+            buildWriteInput(data) {
+                this.latestLuvioRecordIdsToInvalidate = [];
+                const baseQuery = this.buildRequestQuery();
+                const { query: augmentedQuery, response: augmentedData } = augmentQueryByResponse(baseQuery, data);
+                const extensionResult = buildGraphQLInputExtension({
+                    ...this.config,
+                    query: augmentedQuery,
+                });
+                if (extensionResult.isErr()) {
+                    throw new InternalError(extensionResult.error);
+                }
+                return {
+                    data: augmentedData.data,
+                    ...extensionResult.value,
+                    luvioRecordIdsToInvalidate: this.latestLuvioRecordIdsToInvalidate,
+                };
+            }
+            readFromCache(cache) {
+                let readFromCacheResult = undefined;
+                try {
+                    const luvioService = this.services.luvio;
+                    const luvioInstance = luvioService.luvio;
+                    // Create a Luvio reader and get the latest snapshot
+                    this.latestLuvioSnapshot = luvioInstance.storeLookup({
+                        recordId: 'onestore-graphql',
+                        node: {
+                            kind: 'Fragment',
+                            reader: true,
+                            synthetic: true,
+                            read: (reader) => {
+                                readFromCacheResult = this.buildResultType().query(cache, {
+                                    ...this.buildQuery(),
+                                    reader,
+                                    getNormalizedLuvioRecord: this.services.luvioUiapiRecords.getNormalizedLuvioRecord,
+                                });
+                                return readFromCacheResult;
+                            },
+                        },
+                        variables: {},
+                    });
+                }
+                catch (error) {
+                    return resolvedPromiseLike(err(error));
+                }
+                const readResult = readFromCacheResult;
+                if (readResult === undefined) {
+                    return resolvedPromiseLike(err(new Error('No result from query')));
+                }
+                // Convert ReadResult to Result<any, Error>
+                if (readResult.isErr()) {
+                    return resolvedPromiseLike(err(new Error('Failed to find data in cache')));
+                }
+                return resolvedPromiseLike(ok(readResult.value));
+            }
+            writeToCache(cache, networkResult) {
+                try {
+                    const luvioService = this.services.luvio;
+                    const luvioInstance = luvioService.luvio;
+                    // Create a Luvio reader to allow the record representation type to lookup records in luvio
+                    // and mark them as needing invalidation when necessary
+                    luvioInstance.storeLookup({
+                        recordId: 'onestore-graphql',
+                        node: {
+                            kind: 'Fragment',
+                            reader: true,
+                            synthetic: true,
+                            read: (reader) => {
+                                if (networkResult.isOk()) {
+                                    const x = this.buildResultType().write(cache.buildFixedTimeWritableCache(Date.now() / 1000), {
+                                        ...this.buildWriteInput(networkResult.value),
+                                        reader,
+                                        getNormalizedLuvioRecord: this.services.luvioUiapiRecords
+                                            .getNormalizedLuvioRecord,
+                                    });
+                                }
+                            },
+                        },
+                        variables: {},
+                    });
+                }
+                catch (error) {
+                    // swallow error
+                    console.error(error);
+                }
+                return resolvedPromiseLike(undefined);
+            }
+            execute() {
+                // Clear snapshot and unsubscribe from any existing subscriptions at the beginning of execute calls
+                this.latestLuvioSnapshot = undefined;
+                this.latestLuvioRecordIdsToInvalidate = undefined;
+                if (this.unsubscribeFromLuvioSnapshot) {
+                    this.unsubscribeFromLuvioSnapshot();
+                    this.unsubscribeFromLuvioSnapshot = undefined;
+                }
+                const result = super.execute();
+                result.then((_) => {
+                    if (this.latestLuvioRecordIdsToInvalidate &&
+                        this.latestLuvioRecordIdsToInvalidate.length > 0) {
+                        return this.services.luvioUiapiRecords.notifyRecordUpdateAvailable(this.latestLuvioRecordIdsToInvalidate.map((recordId) => ({ recordId })));
+                    }
+                });
+                return result;
+            }
+            subscribeToKeysUsed() {
+                super.subscribeToKeysUsed();
+                // Subscribe to luvio cache changes using the stored snapshot
+                if (this.latestLuvioSnapshot) {
+                    try {
+                        const luvioService = this.services.luvio;
+                        const luvioInstance = luvioService.luvio;
+                        // Subscribe to changes using the stored snapshot
+                        this.unsubscribeFromLuvioSnapshot = luvioInstance.storeSubscribe(this.latestLuvioSnapshot, (_) => {
+                            // If any records used change at the top level, refresh all the data
+                            this.refresh();
+                        });
+                    }
+                    catch (error) { }
+                }
             }
         };
     }
@@ -103524,6 +103991,10 @@
             version: '1.0',
             optional: true,
         },
+        luvioUiapiRecords: {
+            type: 'luvioUiapiRecords',
+            version: '1.0',
+        },
     };
     let provisionedCallback;
     getServices(serviceRequirements).then((services) => {
@@ -103559,7 +104030,7 @@
             cb(graphql$1, graphql_imperative$1, useOneStoreGraphQL);
         }
     }
-    // version: 1.377.0-b0d5c49e07
+    // version: 1.377.1-db77d3f339
 
     function createFragmentMap(documentNode) {
         const fragments = {};
@@ -130054,7 +130525,7 @@
         }
         return refresh$3(data, 'refreshUiApi');
     }
-    // version: 1.377.0-b0d5c49e07
+    // version: 1.377.1-db77d3f339
 
     // On core the unstable adapters are re-exported with different names,
     // we want to match them here.
@@ -130206,7 +130677,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.377.0-b0d5c49e07
+    // version: 1.377.1-db77d3f339
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -131005,7 +131476,7 @@
     function register(r) {
         callbacks$1.forEach((callback) => callback(r));
     }
-    // version: 1.377.0-3c95caf11c
+    // version: 1.377.1-dadb6358f3
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -132342,4 +132813,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.377.0-3c95caf11c
+// version: 1.377.1-dadb6358f3