@salesforce/lds-worker-api 1.377.0 → 1.377.1

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

@@ -4274,7 +4274,7 @@ function withDefaultLuvio(callback) {
     }
     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) {
@@ -5318,7 +5318,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     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.,
@@ -34154,7 +34154,7 @@ withDefaultLuvio((luvio) => {
     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) {
@@ -45659,6 +45659,15 @@ var graphqQueryFieldLimit = {
     },
 };
 
+var graphqlPartialEmitParity = {
+    isOpen: function (e) {
+        return e.fallback;
+    },
+    hasError: function () {
+        return !0;
+    },
+};
+
 var caseSensitiveUserId = '005B0000000GR4OIAW';
 
 var ldsAdapterO11yLoggingGate = {
@@ -45806,47 +45815,47 @@ let Err$4 = class Err {
 };
 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;
@@ -45856,7 +45865,7 @@ function racesync(values) {
         }
       );
     } else {
-      settled = resolvedPromiseLike$4(value);
+      settled = resolvedPromiseLike$5(value);
     }
     if (settled !== void 0) {
       return settled;
@@ -46005,7 +46014,7 @@ function getServices(request, timeout = 3e4) {
   );
 }
 function setServices(services) {
-  waitForServices = resolvedPromiseLike$4(services);
+  waitForServices = resolvedPromiseLike$5(services);
   servicesAvailable(services);
 }
 
@@ -61593,7 +61602,7 @@ const { hasOwnProperty: ObjectPrototypeHasOwnProperty$2 } = Object.prototype;
 // 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)) {
@@ -61614,7 +61623,7 @@ function deepMerge$2(target, ...sources) {
                             !Array.isArray(targetItem) &&
                             sourceItem instanceof Object &&
                             !Array.isArray(sourceItem)) {
-                            return deepMerge$2({}, targetItem, sourceItem);
+                            return deepMerge$3({}, targetItem, sourceItem);
                         }
                         else {
                             return sourceItem;
@@ -61625,7 +61634,7 @@ function deepMerge$2(target, ...sources) {
                     !Array.isArray(targetValue) &&
                     sourceValue instanceof Object &&
                     !Array.isArray(sourceValue)) {
-                    deepMerge$2(targetValue, sourceValue);
+                    deepMerge$3(targetValue, sourceValue);
                 }
                 else {
                     target[key] = sourceValue;
@@ -79243,7 +79252,7 @@ function selectCalculateSink$1(sink, field, buildSelectionForNodeFn, source, rea
     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;
@@ -81989,6 +81998,7 @@ function createContext(store, objectInfos, eventEmitter, settings, snapshot, map
         possibleStaleRecordMap: new Map(),
         draftFunctions,
         mappedCursors,
+        missingFieldsMap: new Map(),
     };
 }
 
@@ -85590,8 +85600,17 @@ function addResolversToSchema(schema, polyFields) {
                             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;
                             };
                         }
                     }
@@ -86182,6 +86201,7 @@ async function evaluate(config, observers, settings, objectInfos, store, snapsho
             result,
             seenRecordIds,
             possibleStaleRecordMap: contextValue.possibleStaleRecordMap,
+            missingFieldsMap: contextValue.missingFieldsMap,
         };
     }
     finally {
@@ -87009,9 +87029,9 @@ function injectFilter(filterNode, idState, parentPath, isParentPolymorphic, obje
                         }
                         // 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]];
@@ -87057,7 +87077,7 @@ function injectFilter(filterNode, idState, parentPath, isParentPolymorphic, obje
                                 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 ||
@@ -87124,7 +87144,7 @@ function injectFilter(filterNode, idState, parentPath, isParentPolymorphic, obje
                                     .filter(isFieldNode)
                                     .filter((subNode) => subNode.name.value === relationField);
                             if (!existingRelationFields || existingRelationFields.length === 0) {
-                                injectedSelections.push(createFieldNode(relationField, FieldValueNodeSelectionSet));
+                                injectedSelections.push(createFieldNode$1(relationField, FieldValueNodeSelectionSet));
                             }
                         }
                     }
@@ -87215,7 +87235,7 @@ function produceValueFieldLeaves(queryNode) {
             .filter(isFieldNode)
             .filter((subNode) => subNode.name.value === 'value');
     return !existingValueFields || existingValueFields.length === 0
-        ? [createFieldNode('value')]
+        ? [createFieldNode$1('value')]
         : [];
 }
 function updateIDInfo(fieldNode, idState, draftFunctions) {
@@ -87296,20 +87316,20 @@ function injectParentRelationships(selections, parentNode, parentPath, ancestors
                     .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) {
@@ -87353,7 +87373,7 @@ function injectFieldsForDisplayValue(topNode, apiName, objectInfos) {
             objectInfo.nameFields !== undefined &&
             objectInfo.nameFields.length > 0) {
             displayValueNameFields = objectInfo.nameFields.map((fieldName) => {
-                return createFieldNode(fieldName, FieldValueNodeSelectionSet);
+                return createFieldNode$1(fieldName, FieldValueNodeSelectionSet);
             });
         }
     }
@@ -87384,7 +87404,7 @@ function injectFields(selections, parentNode, parentPath, ancestors, objectInfos
         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
@@ -87412,7 +87432,7 @@ function injectFields(selections, parentNode, parentPath, ancestors, objectInfos
                             .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));
                     }
@@ -87864,7 +87884,7 @@ function referenceIdFieldForRelationship(relationshipName) {
  * @param selectionSet
  * @returns
  */
-function createFieldNode(nameValue, selectionSet) {
+function createFieldNode$1(nameValue, selectionSet) {
     return {
         kind: Kind$3.FIELD,
         name: {
@@ -88348,11 +88368,13 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
         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
@@ -88382,13 +88404,23 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
         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);
@@ -88423,6 +88455,10 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
                 },
             };
         }
+        // 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
@@ -88479,6 +88515,30 @@ function makeGetRecordsConfig(keyMap) {
         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 = {}) {
@@ -93878,13 +93938,13 @@ function toError(x) {
   }
   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();
@@ -93956,7 +94016,7 @@ let NetworkCommand$1 = class NetworkCommand extends BaseCommand {
   async afterRequestHooks(_options) {
   }
 };
-function buildServiceDescriptor$g() {
+function buildServiceDescriptor$h() {
   return {
     type: "networkCommandBaseClass",
     version: "1.0",
@@ -94058,7 +94118,7 @@ class AuraNetworkCommand extends NetworkCommand$1 {
     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",
@@ -94558,7 +94618,7 @@ class AuraNormalizedCacheControlCommand extends AuraCacheControlCommand$1 {
     return resolvedPromiseLike$3(void 0);
   }
 }
-function buildServiceDescriptor$e() {
+function buildServiceDescriptor$f() {
   return {
     type: "auraNormalizedCacheControlCommand",
     version: "1.0",
@@ -94704,7 +94764,7 @@ class AuraResourceCacheControlCommand extends AuraCacheControlCommand {
     return `{"endpoint":${this.endpoint},"params":${stableJSONStringify$2(this.auraParams)}}`;
   }
 }
-function buildServiceDescriptor$d() {
+function buildServiceDescriptor$e() {
   return {
     type: "auraResourceCacheControlCommand",
     version: "1.0",
@@ -94811,7 +94871,7 @@ class FetchNetworkCommand extends NetworkCommand {
     );
   }
 }
-function buildServiceDescriptor$c() {
+function buildServiceDescriptor$d() {
   return {
     type: "fetchNetworkCommandBaseClass",
     version: "1.0",
@@ -94900,7 +94960,7 @@ class HttpNormalizedCacheControlCommand extends HttpCacheControlCommand {
     return resolvedPromiseLike$3(void 0);
   }
 }
-function buildServiceDescriptor$b() {
+function buildServiceDescriptor$c() {
   return {
     type: "httpNormalizedCacheControlCommand",
     version: "1.0",
@@ -95153,7 +95213,7 @@ let DefaultCache$1 = class DefaultCache {
     return new FixedTimeWritableCache$1(this, generatedTime);
   }
 };
-function buildServiceDescriptor$a() {
+function buildServiceDescriptor$b() {
   return {
     type: "cache",
     version: "1.0",
@@ -95321,7 +95381,7 @@ class CacheController {
     yield* this.services.cacheInclusionPolicy.findAndModify(query, cacheUpdate);
   }
 }
-function buildServiceDescriptor$9(cache, cacheInclusionPolicy) {
+function buildServiceDescriptor$a(cache, cacheInclusionPolicy) {
   return {
     type: "cacheController",
     version: "1.0",
@@ -95367,7 +95427,7 @@ function buildInstrumentCommand(services) {
     };
   };
 }
-function buildServiceDescriptor$8(instrumentation) {
+function buildServiceDescriptor$9(instrumentation) {
   return {
     type: "instrumentCommand",
     version: "1.0",
@@ -95637,7 +95697,7 @@ class O11yInstrumentation {
     this.metrics = new O11yOTelMetricsAPI(this.services);
   }
 }
-function buildServiceDescriptor$7(logger) {
+function buildServiceDescriptor$8(logger) {
   return {
     type: "instrumentation",
     version: "1.0",
@@ -95747,7 +95807,7 @@ class DefaultPubSubService {
     return matchingSubscriptions;
   }
 }
-function buildServiceDescriptor$6() {
+function buildServiceDescriptor$7() {
   return {
     type: "pubSub",
     version: "1.0",
@@ -95771,7 +95831,7 @@ class FeatureFlagsService {
     return this.flags.get(flagName) || defaultValue;
   }
 }
-function buildServiceDescriptor$5() {
+function buildServiceDescriptor$6() {
   return {
     version: "1.0",
     service: new FeatureFlagsService(),
@@ -95812,7 +95872,7 @@ function buildServiceDescriptor$5() {
  * };
  * ```
  */
-function buildServiceDescriptor$4(luvio) {
+function buildServiceDescriptor$5(luvio) {
     return {
         type: 'luvio',
         version: '1.0',
@@ -95821,7 +95881,33 @@ function buildServiceDescriptor$4(luvio) {
         },
     };
 }
-// 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.,
@@ -96688,7 +96774,7 @@ function findExecutableOperation$1(input) {
   }
   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);
@@ -96731,7 +96817,7 @@ class AuraGraphQLNormalizedCacheControlCommand extends AuraNormalizedCacheContro
     return this.documentRootType;
   }
   buildQuery() {
-    const extensionResult = buildGraphQLInputExtension(this.config);
+    const extensionResult = buildGraphQLInputExtension$1(this.config);
     if (extensionResult.isErr()) {
       throw extensionResult.error;
     }
@@ -96840,12 +96926,12 @@ class AuraGraphQLNormalizedCacheControlCommand extends AuraNormalizedCacheContro
     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 };
   }
@@ -96890,7 +96976,7 @@ class HttpGraphQLNormalizedCacheControlCommand extends HttpNormalizedCacheContro
     return this.documentRootType;
   }
   buildQuery() {
-    const extensionResult = buildGraphQLInputExtension(this.config);
+    const extensionResult = buildGraphQLInputExtension$1(this.config);
     if (extensionResult.isErr()) {
       throw extensionResult.error;
     }
@@ -96934,12 +97020,12 @@ class HttpGraphQLNormalizedCacheControlCommand extends HttpNormalizedCacheContro
     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 };
   }
@@ -97182,41 +97268,41 @@ function setDifference(setA, setB) {
   }
   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";
 }
 /*!
@@ -97505,7 +97591,7 @@ class DurableCacheInclusionPolicy extends CacheInclusionPolicyService {
       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) => {
@@ -97698,10 +97784,10 @@ function initializeOneStore(sqliteStore) {
         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
@@ -97711,21 +97797,22 @@ function initializeOneStore(sqliteStore) {
     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(),
@@ -97936,7 +98023,7 @@ register$1({
     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;
@@ -98826,7 +98913,7 @@ function validateExpectedType(value, expectedType) {
     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)) {
@@ -98842,13 +98929,13 @@ function deepMerge$1(target, ...sources) {
             } 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
           );
@@ -98882,6 +98969,32 @@ function findExecutableOperation(input) {
   }
   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;
@@ -99108,7 +99221,7 @@ class BaseGraphQLTypeRepository {
     const errors = [];
     for (const selection of input.selections) {
       if (selection.kind === Kind.FIELD) {
-        deepMerge$1(
+        deepMerge$2(
           normalized,
           this.normalizeFieldSelection(cache, input, selection, errors)
         );
@@ -99129,7 +99242,7 @@ class BaseGraphQLTypeRepository {
             ]
           };
         }
-        deepMerge$1(normalized, this.normalizeFragment(cache, input, fragment, errors));
+        deepMerge$2(normalized, this.normalizeFragment(cache, input, fragment, errors));
       }
     }
     return buildReadWriteResult(normalized, errors);
@@ -99223,7 +99336,7 @@ class BaseGraphQLTypeRepository {
     const denormalized = {};
     for (const selection of input.selections) {
       if (selection.kind === Kind.FIELD) {
-        deepMerge$1(
+        deepMerge$2(
           denormalized,
           this.denormalizeFieldSelection(cache, input, selection, errors)
         );
@@ -99244,7 +99357,7 @@ class BaseGraphQLTypeRepository {
             ]
           };
         }
-        deepMerge$1(denormalized, this.denormalizeFragment(cache, input, fragment, errors));
+        deepMerge$2(denormalized, this.denormalizeFragment(cache, input, fragment, errors));
       }
     }
     return buildReadWriteResult(denormalized, errors);
@@ -99460,7 +99573,7 @@ class IdentifiableGraphQLTypeRepository extends IdentifiableTypeRepository {
       return normalizeDataResult;
     }
     return ok$4(
-      deepMerge$1(
+      deepMerge$2(
         {},
         (existingNormalizedData == null ? void 0 : existingNormalizedData.value) || {},
         normalizeDataResult.value
@@ -100365,7 +100478,7 @@ function buildAsyncGraphQLImperativeLegacyInvoker(getCommand) {
   };
   return { invoke, subscribe };
 }
-// version: 1.377.0-b0d5c49e07
+// version: 1.377.1-db77d3f339
 
 class Analytics__AnalyticsBrowseRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
@@ -103049,6 +103162,50 @@ class Err {
 }
 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
@@ -103166,12 +103323,25 @@ class RecordRepresentationRepository extends RecordRepresentationRepository$1 {
     }
     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;
     }
 }
@@ -103453,6 +103623,155 @@ class CustomGraphQLTypeRegistry extends GraphQLTypeRegistry {
 }
 
 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) {
@@ -103460,21 +103779,169 @@ function buildCommandClass(baseClass) {
             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) { }
+            }
         }
     };
 }
@@ -103518,6 +103985,10 @@ const serviceRequirements = {
         version: '1.0',
         optional: true,
     },
+    luvioUiapiRecords: {
+        type: 'luvioUiapiRecords',
+        version: '1.0',
+    },
 };
 let provisionedCallback;
 getServices(serviceRequirements).then((services) => {
@@ -103553,7 +104024,7 @@ function registerCallback(cb) {
         cb(graphql$1, graphql_imperative$1, useOneStoreGraphQL);
     }
 }
-// version: 1.377.0-b0d5c49e07
+// version: 1.377.1-db77d3f339
 
 function createFragmentMap(documentNode) {
     const fragments = {};
@@ -130048,7 +130519,7 @@ function refreshGraphQL(data) {
     }
     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.
@@ -130200,7 +130671,7 @@ withDefaultLuvio((luvio) => {
     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,
@@ -130999,7 +131470,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.377.0-3c95caf11c
+// version: 1.377.1-dadb6358f3
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -132315,4 +132786,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, evictCacheRecordsByIds, evictExpiredCacheEntries, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, importLuvioAdapterModule, importOneStoreAdapterModule, invokeAdapter, invokeAdapterWithDraftToMerge, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, stopEviction, subscribeToAdapter };
-// version: 1.377.0-3c95caf11c
+// version: 1.377.1-dadb6358f3