@salesforce/lds-worker-api 1.377.0 → 1.378.0

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

@@ -4280,7 +4280,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.377.0-3c95caf11c
+    // version: 1.378.0-0ab3d40d29
 
     // 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.378.0-0ab3d40d29
 
     /**
      * 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.378.0-63d7c07562
 
     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 {
@@ -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.378.0-63d7c07562
+
+    /**
+     * 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.378.0-63d7c07562
 
     /*!
      * 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.378.0-0ab3d40d29
 
     const { create: create$3, keys: keys$3 } = Object;
     const { stringify: stringify$1, parse } = JSON;
@@ -98806,11 +98893,7 @@
       if (variable.definition.defaultValue) {
         return extractValue(variable.definition.defaultValue, variableDefinitions);
       }
-      return err$4(
-        new Error(
-          `Variable '${variableName}' was defined but no value was provided and no default value exists`
-        )
-      );
+      return ok$4(void 0);
     }
     function validateExpectedType(value, expectedType) {
       if (!expectedType) {
@@ -98832,7 +98915,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 +98931,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 +98971,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;
@@ -98994,6 +99103,243 @@
       }
       return ok$4(false);
     }
+    class BaseScalarFieldDef {
+      constructor(nullable) {
+        this.nullable = nullable;
+      }
+      write(_cache, input) {
+        if (input.data === void 0) {
+          return ok$4({ type: "missing" });
+        }
+        if (input.data === null) {
+          if (!this.nullable) {
+            return err$4([
+              {
+                type: "unknown",
+                error: new Error(
+                  `Got a null value for non-nullable field "${input.selection.name.value}"`
+                )
+              }
+            ]);
+          }
+        }
+        return ok$4({ type: "data", data: input.data });
+      }
+      read(_cache, input) {
+        const normalizedData = input.normalizedData;
+        if (normalizedData.type === "missing") {
+          return ok$4(void 0);
+        }
+        return ok$4(normalizedData.data);
+      }
+      augmentSelections(input) {
+        return input;
+      }
+      buildFieldKey(selection, variables) {
+        return buildFieldKey(selection.name.value, selection.arguments, variables);
+      }
+    }
+    class BaseArrayFieldDef {
+      constructor(items, nullable) {
+        this.items = items;
+        this.nullable = nullable;
+      }
+      augmentSelections(input) {
+        return this.items.augmentSelections(input);
+      }
+      buildFieldKey(selection, variables) {
+        return this.items.buildFieldKey(selection, variables);
+      }
+      write(cache, input) {
+        if (input.data === void 0) {
+          return ok$4({ type: "missing" });
+        }
+        if (input.data === null) {
+          if (!this.nullable) {
+            return err$4([
+              {
+                type: "unknown",
+                error: new Error(
+                  `Got a null value for non-nullable field "${input.selection.name.value}"`
+                )
+              }
+            ]);
+          }
+          return ok$4({ type: "data", data: input.data });
+        }
+        if (!Array.isArray(input.data)) {
+          return err$4([
+            {
+              type: "unknown",
+              error: new Error(
+                `Got a non array value for array field "${input.selection.name.value}"`
+              )
+            }
+          ]);
+        }
+        const arrayNormalizationErrors = [];
+        const normalizedArray = [];
+        input.data.forEach((item, index) => {
+          var _a;
+          const existingItemData = (_a = input.existingNormalizedData) == null ? void 0 : _a[index];
+          const normalizedItemResult = this.items.write(cache, {
+            ...input,
+            data: item,
+            existingNormalizedData: existingItemData,
+            request: input.request,
+            selection: input.selection
+          });
+          if (normalizedItemResult.isOk()) {
+            normalizedArray.push(normalizedItemResult.value);
+          } else {
+            arrayNormalizationErrors.push(...normalizedItemResult.error);
+          }
+        });
+        if (arrayNormalizationErrors.length > 0) {
+          return err$4(arrayNormalizationErrors);
+        }
+        return ok$4({ type: "data", data: normalizedArray });
+      }
+      read(cache, input) {
+        const normalizedData = input.normalizedData;
+        if (normalizedData.type === "missing") {
+          return ok$4(void 0);
+        }
+        if (normalizedData.data === null) {
+          if (!this.nullable) {
+            return err$4([
+              {
+                type: "unknown",
+                error: new Error(
+                  `Got a null value for non-nullable field "${input.selection.name.value}"`
+                )
+              }
+            ]);
+          }
+          return ok$4({ type: "data", data: null });
+        }
+        if (!Array.isArray(normalizedData.data)) {
+          return err$4([
+            {
+              type: "unknown",
+              error: new Error(
+                `Got a non array value for array field "${input.selection.name.value}"`
+              )
+            }
+          ]);
+        }
+        const arrayDenormalizationErrors = [];
+        const denormalizedArray = [];
+        normalizedData.data.forEach((item) => {
+          const denormalizedItemResult = this.items.read(cache, {
+            ...input,
+            normalizedData: item,
+            request: input.request,
+            selection: input.selection
+          });
+          if (denormalizedItemResult.isOk()) {
+            denormalizedArray.push(denormalizedItemResult.value);
+          } else {
+            arrayDenormalizationErrors.push(...denormalizedItemResult.error);
+          }
+        });
+        if (arrayDenormalizationErrors.length > 0) {
+          return err$4(arrayDenormalizationErrors);
+        }
+        return ok$4(denormalizedArray);
+      }
+    }
+    class BaseObjectFieldDef {
+      constructor(repository, nullable) {
+        this.repository = repository;
+        this.nullable = nullable;
+      }
+      augmentSelections(input) {
+        return this.repository.augmentSelections(input);
+      }
+      buildFieldKey(selection, variables) {
+        return this.repository.buildFieldKey(selection, variables);
+      }
+      write(cache, input) {
+        var _a;
+        if (!input.selection.selectionSet) {
+          return err$4([
+            {
+              type: "unknown",
+              error: new Error(
+                `Selection set required for object type found on field "${input.selection.name.value}" in type ${this.repository.typeName}`
+              )
+            }
+          ]);
+        }
+        if (input.data === void 0) {
+          return ok$4({ type: "missing" });
+        }
+        if (input.data === null) {
+          if (!this.nullable) {
+            return err$4([
+              {
+                type: "unknown",
+                error: new Error(
+                  `Got a null value for non-nullable field "${input.selection.name.value}"`
+                )
+              }
+            ]);
+          }
+          return ok$4({ type: "data", data: null });
+        }
+        const writeResult = this.repository.write(cache, {
+          ...input,
+          data: input.data,
+          existingNormalizedData: (_a = input.existingNormalizedData) == null ? void 0 : _a.data,
+          request: input.request,
+          selections: input.selection.selectionSet.selections,
+          parentFieldSelection: input.selection
+        });
+        if (writeResult.isErr()) {
+          return writeResult;
+        }
+        return ok$4({ type: "data", data: writeResult.value });
+      }
+      read(cache, input) {
+        var _a;
+        if (!input.selection.selectionSet) {
+          return err$4([
+            {
+              type: "unknown",
+              error: new Error(
+                `Selection set required for object type found on field "${input.selection.name.value}" in type ${this.repository.typeName}`
+              )
+            }
+          ]);
+        }
+        const normalizedData = input.normalizedData;
+        if (normalizedData.type === "missing") {
+          return ok$4(void 0);
+        }
+        if (normalizedData.data === null) {
+          if (!this.nullable) {
+            return err$4([
+              {
+                type: "unknown",
+                error: new Error(
+                  `Got a null value for non-nullable field "${input.selection.name.value}"`
+                )
+              }
+            ]);
+          }
+          return ok$4(null);
+        }
+        return this.repository.read(cache, {
+          ...input,
+          normalizedData: normalizedData.data,
+          request: input.request,
+          selections: (_a = input.selection.selectionSet) == null ? void 0 : _a.selections,
+          parentFieldSelection: input.selection
+        });
+      }
+    }
+    const missingFieldDef = new BaseScalarFieldDef(false);
     class BaseGraphQLTypeRepository {
       equals(x, y) {
         return deepEquals$2(x, y);
@@ -99114,7 +99460,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 +99481,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 +99575,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 +99596,7 @@
                 ]
               };
             }
-            deepMerge$1(denormalized, this.denormalizeFragment(cache, input, fragment, errors));
+            deepMerge$2(denormalized, this.denormalizeFragment(cache, input, fragment, errors));
           }
         }
         return buildReadWriteResult(denormalized, errors);
@@ -99358,9 +99704,23 @@
         }
         return {};
       }
-      getFieldDef(_input, selection) {
+      getFieldDef(input, selection) {
+        var _a, _b, _c;
         const canonicalFieldName = selection.name.value;
-        return this.fields[canonicalFieldName];
+        const fieldDef = this.fields[canonicalFieldName];
+        if (fieldDef) {
+          return fieldDef;
+        }
+        const dataInstanceFieldName = ((_a = selection.alias) == null ? void 0 : _a.value) ?? selection.name.value;
+        if (input === void 0) {
+          return void 0;
+        }
+        if ("data" in input && input.data[dataInstanceFieldName] === void 0) {
+          return missingFieldDef;
+        } else if ("normalizedData" in input && ((_c = (_b = input.normalizedData) == null ? void 0 : _b[dataInstanceFieldName]) == null ? void 0 : _c.type) === "missing") {
+          return missingFieldDef;
+        }
+        return void 0;
       }
       shouldProcessFragment(fragment, variables) {
         const shouldSkipResult = shouldSkip(fragment, variables);
@@ -99466,7 +99826,7 @@
           return normalizeDataResult;
         }
         return ok$4(
-          deepMerge$1(
+          deepMerge$2(
             {},
             (existingNormalizedData == null ? void 0 : existingNormalizedData.value) || {},
             normalizeDataResult.value
@@ -99742,245 +100102,6 @@
       });
       return { selections: augmentedSelections, fragments: augmentedFragments };
     }
-    class BaseScalarFieldDef {
-      constructor(nullable) {
-        this.nullable = nullable;
-        this.type = "scalar";
-      }
-      write(_cache, input) {
-        if (input.data === void 0) {
-          return ok$4({ type: "missing" });
-        }
-        if (input.data === null) {
-          if (!this.nullable) {
-            return err$4([
-              {
-                type: "unknown",
-                error: new Error(
-                  `Got a null value for non-nullable field "${input.selection.name.value}"`
-                )
-              }
-            ]);
-          }
-        }
-        return ok$4({ type: "data", data: input.data });
-      }
-      read(_cache, input) {
-        const normalizedData = input.normalizedData;
-        if (normalizedData.type === "missing") {
-          return ok$4(void 0);
-        }
-        return ok$4(normalizedData.data);
-      }
-      augmentSelections(input) {
-        return input;
-      }
-      buildFieldKey(selection, variables) {
-        return buildFieldKey(selection.name.value, selection.arguments, variables);
-      }
-    }
-    class BaseArrayFieldDef {
-      constructor(items, nullable) {
-        this.items = items;
-        this.nullable = nullable;
-        this.type = "array";
-      }
-      augmentSelections(input) {
-        return this.items.augmentSelections(input);
-      }
-      buildFieldKey(selection, variables) {
-        return this.items.buildFieldKey(selection, variables);
-      }
-      write(cache, input) {
-        if (input.data === void 0) {
-          return ok$4({ type: "missing" });
-        }
-        if (input.data === null) {
-          if (!this.nullable) {
-            return err$4([
-              {
-                type: "unknown",
-                error: new Error(
-                  `Got a null value for non-nullable field "${input.selection.name.value}"`
-                )
-              }
-            ]);
-          }
-          return ok$4({ type: "data", data: input.data });
-        }
-        if (!Array.isArray(input.data)) {
-          return err$4([
-            {
-              type: "unknown",
-              error: new Error(
-                `Got a non array value for array field "${input.selection.name.value}"`
-              )
-            }
-          ]);
-        }
-        const arrayNormalizationErrors = [];
-        const normalizedArray = [];
-        input.data.forEach((item, index) => {
-          var _a;
-          const existingItemData = (_a = input.existingNormalizedData) == null ? void 0 : _a[index];
-          const normalizedItemResult = this.items.write(cache, {
-            ...input,
-            data: item,
-            existingNormalizedData: existingItemData,
-            request: input.request,
-            selection: input.selection
-          });
-          if (normalizedItemResult.isOk()) {
-            normalizedArray.push(normalizedItemResult.value);
-          } else {
-            arrayNormalizationErrors.push(...normalizedItemResult.error);
-          }
-        });
-        if (arrayNormalizationErrors.length > 0) {
-          return err$4(arrayNormalizationErrors);
-        }
-        return ok$4({ type: "data", data: normalizedArray });
-      }
-      read(cache, input) {
-        const normalizedData = input.normalizedData;
-        if (normalizedData.type === "missing") {
-          return ok$4(void 0);
-        }
-        if (normalizedData.data === null) {
-          if (!this.nullable) {
-            return err$4([
-              {
-                type: "unknown",
-                error: new Error(
-                  `Got a null value for non-nullable field "${input.selection.name.value}"`
-                )
-              }
-            ]);
-          }
-          return ok$4({ type: "data", data: null });
-        }
-        if (!Array.isArray(normalizedData.data)) {
-          return err$4([
-            {
-              type: "unknown",
-              error: new Error(
-                `Got a non array value for array field "${input.selection.name.value}"`
-              )
-            }
-          ]);
-        }
-        const arrayDenormalizationErrors = [];
-        const denormalizedArray = [];
-        normalizedData.data.forEach((item) => {
-          const denormalizedItemResult = this.items.read(cache, {
-            ...input,
-            normalizedData: item,
-            request: input.request,
-            selection: input.selection
-          });
-          if (denormalizedItemResult.isOk()) {
-            denormalizedArray.push(denormalizedItemResult.value);
-          } else {
-            arrayDenormalizationErrors.push(...denormalizedItemResult.error);
-          }
-        });
-        if (arrayDenormalizationErrors.length > 0) {
-          return err$4(arrayDenormalizationErrors);
-        }
-        return ok$4(denormalizedArray);
-      }
-    }
-    class BaseObjectFieldDef {
-      constructor(repository, nullable) {
-        this.repository = repository;
-        this.nullable = nullable;
-        this.type = "object";
-      }
-      augmentSelections(input) {
-        return this.repository.augmentSelections(input);
-      }
-      buildFieldKey(selection, variables) {
-        return this.repository.buildFieldKey(selection, variables);
-      }
-      write(cache, input) {
-        var _a;
-        if (!input.selection.selectionSet) {
-          return err$4([
-            {
-              type: "unknown",
-              error: new Error(
-                `Selection set required for object type found on field "${input.selection.name.value}" in type ${this.repository.typeName}`
-              )
-            }
-          ]);
-        }
-        if (input.data === void 0) {
-          return ok$4({ type: "missing" });
-        }
-        if (input.data === null) {
-          if (!this.nullable) {
-            return err$4([
-              {
-                type: "unknown",
-                error: new Error(
-                  `Got a null value for non-nullable field "${input.selection.name.value}"`
-                )
-              }
-            ]);
-          }
-          return ok$4({ type: "data", data: null });
-        }
-        const writeResult = this.repository.write(cache, {
-          ...input,
-          data: input.data,
-          existingNormalizedData: (_a = input.existingNormalizedData) == null ? void 0 : _a.data,
-          request: input.request,
-          selections: input.selection.selectionSet.selections,
-          parentFieldSelection: input.selection
-        });
-        if (writeResult.isErr()) {
-          return writeResult;
-        }
-        return ok$4({ type: "data", data: writeResult.value });
-      }
-      read(cache, input) {
-        var _a;
-        if (!input.selection.selectionSet) {
-          return err$4([
-            {
-              type: "unknown",
-              error: new Error(
-                `Selection set required for object type found on field "${input.selection.name.value}" in type ${this.repository.typeName}`
-              )
-            }
-          ]);
-        }
-        const normalizedData = input.normalizedData;
-        if (normalizedData.type === "missing") {
-          return ok$4(void 0);
-        }
-        if (normalizedData.data === null) {
-          if (!this.nullable) {
-            return err$4([
-              {
-                type: "unknown",
-                error: new Error(
-                  `Got a null value for non-nullable field "${input.selection.name.value}"`
-                )
-              }
-            ]);
-          }
-          return ok$4(null);
-        }
-        return this.repository.read(cache, {
-          ...input,
-          normalizedData: normalizedData.data,
-          request: input.request,
-          selections: (_a = input.selection.selectionSet) == null ? void 0 : _a.selections,
-          parentFieldSelection: input.selection
-        });
-      }
-    }
     const GraphQLQueryJsonSchema = {
       type: "object",
       properties: {
@@ -100281,10 +100402,10 @@
         return;
       }
       if ("subscribe" in result.value) {
-        callback(result.value.data);
+        callback(formatGraphQLData(result.value.data));
         return;
       }
-      callback(result.value);
+      callback(formatGraphQLData(result.value));
     }
     function resolveAst(ast) {
       const result = astResolver(ast);
@@ -100293,6 +100414,18 @@
       }
       return result;
     }
+    function formatGraphQLData(data) {
+      if (data.errors === void 0 || data.errors.length === 0) {
+        return {
+          data: data.data,
+          errors: void 0
+        };
+      }
+      return {
+        data: data.data,
+        errors: data.errors
+      };
+    }
     class GraphQLCommandWireAdapterConstructor extends CommandWireAdapterConstructor {
       emit(result) {
         try {
@@ -100371,7 +100504,7 @@
       };
       return { invoke, subscribe };
     }
-    // version: 1.377.0-b0d5c49e07
+    // version: 1.378.0-63d7c07562
 
     class Analytics__AnalyticsBrowseRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
@@ -101547,7 +101680,7 @@
         }
     }
 
-    class PolymorphicParentRelationshipRepository extends BaseUnionRepository {
+    let PolymorphicParentRelationshipRepository$1 = class PolymorphicParentRelationshipRepository extends BaseUnionRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101564,7 +101697,7 @@
                 __typename: new BaseScalarFieldDef(false),
             };
         }
-    }
+    };
 
     class QueryRepository extends GraphQLDocumentRootTypeRepository {
         constructor(services, typeRegistry) {
@@ -102602,7 +102735,7 @@
             this._Base64Value = new Base64ValueRepository(this.services, this);
             this._JSONValue = new JSONValueRepository(this.services, this);
             this._PolymorphicParentRelationship =
-                new PolymorphicParentRelationshipRepository(this.services, this);
+                new PolymorphicParentRelationshipRepository$1(this.services, this);
             this._CompoundField = new CompoundFieldRepository$1(this.services, this);
             this._AnyType = new AnyTypeRepository(this.services, this);
             this._RecordRepresentation =
@@ -103055,6 +103188,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
@@ -103062,8 +103239,6 @@
             return fields[selection.name.value];
         }
         return {
-            type: 'object',
-            nullable: true,
             read: (cache, input) => {
                 if (!input.selection.selectionSet) {
                     return err([
@@ -103077,6 +103252,9 @@
                 if (normalizedData.type === 'missing') {
                     return ok(undefined);
                 }
+                if (normalizedData.data === null) {
+                    return ok(null);
+                }
                 const fieldCategory = normalizedData.fieldCategory;
                 const fieldDef = fields[fieldCategory];
                 if (!fieldDef) {
@@ -103101,6 +103279,9 @@
                 if (input.data === undefined) {
                     return ok({ type: 'missing' });
                 }
+                if (input.data === null) {
+                    return ok({ type: 'data', data: null });
+                }
                 const fieldCategory = getFieldCategoryFromData(input.data);
                 const fieldDef = fields[fieldCategory];
                 if (!fieldDef) {
@@ -103119,7 +103300,6 @@
             },
             buildFieldKey: (selection, variables) => buildFieldKey(selection.name.value, selection.arguments, variables),
             augmentSelections: (input) => input,
-            repository: {}, // This shouldn't be part of the interface
         };
     }
     function getFieldCategoryFromData(data) {
@@ -103171,13 +103351,38 @@
             return this._graphqlRepositoryOverride;
         }
         write(cache, input) {
-            const result = super.write(cache, input);
-            input.data.Id;
+            let overridenInput = input;
+            // If ID exists in the data but wasn't asked for, its from the extensions, and we should normalize it
+            if (input.data.Id !== undefined &&
+                input.selections.find((selection) => selection.kind === 'Field' && selection.name.value === 'Id')) {
+                overridenInput = {
+                    ...input,
+                    selections: [
+                        ...input.selections,
+                        { kind: 'Field', name: { kind: 'Name', value: 'Id' } },
+                    ],
+                };
+            }
+            const result = super.write(cache, overridenInput);
+            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;
         }
     }
@@ -103305,8 +103510,6 @@
     }
 
     const blobTypeDef = {
-        type: 'scalar',
-        nullable: true,
         read: (_cache, input) => {
             return ok({
                 data: input.data,
@@ -103416,6 +103619,14 @@
         }
     }
 
+    class PolymorphicParentRelationshipRepository extends PolymorphicParentRelationshipRepository$1 {
+        getTypeDiscriminator(data, _selections) {
+            // Hardcoded to record representation since that's the only type of parent
+            // relationship possible
+            return 'RecordRepresentation';
+        }
+    }
+
     class CustomGraphQLTypeRegistry extends GraphQLTypeRegistry {
         constructor(services) {
             super(services);
@@ -103428,6 +103639,7 @@
             this._SetupQueryAggregate = new SetupQueryAggregateRepository(services, this);
             this._SetupQuery = new SetupQueryRepository(services, this);
             this._SetupRecordAggregate = new SetupRecordAggregateRepository(services, this);
+            this._PolymorphicParentRelationship = new PolymorphicParentRelationshipRepository(services, this);
         }
         get CompoundField() {
             return this._CompoundField;
@@ -103456,9 +103668,78 @@
         get SetupRecordAggregate() {
             return this._SetupRecordAggregate;
         }
+        get PolymorphicParentRelationship() {
+            return this._PolymorphicParentRelationship;
+        }
     }
 
     const CONFIG_SCHEMA = GraphQLQueryJsonSchema;
+
+    function mergeResponseWithExtensions(response) {
+        return {
+            data: deepMerge$1(response.data, response.extensions?.lds || {}),
+            ...(response.errors && { errors: response.errors }),
+        };
+    }
+    function deepMerge$1(data, extensions) {
+        const dataType = typeof data;
+        const extensionsType = typeof extensions;
+        if (dataType === 'function' || extensionsType === 'function') {
+            throw new Error('Cannot merge functions');
+        }
+        if (dataType === 'undefined' || data === undefined) {
+            return extensions;
+        }
+        if (extensionsType === 'undefined' || extensions === undefined) {
+            return data;
+        }
+        if (dataType === 'string' ||
+            dataType === 'number' ||
+            dataType === 'boolean' ||
+            dataType === 'bigint' ||
+            dataType === 'symbol' ||
+            extensionsType === 'string' ||
+            extensionsType === 'number' ||
+            extensionsType === 'boolean' ||
+            extensionsType === 'bigint' ||
+            extensionsType === 'symbol' ||
+            data === null ||
+            extensions === null) {
+            // if either is a scalar, prefer data
+            return data;
+        }
+        // data and extensions are both objects or arrays
+        // if data is an array but extensions is not, prefer data
+        const dataIsArray = Array.isArray(data);
+        const extensionsIsArray = Array.isArray(extensions);
+        // if one is an array and the other is not, prefer data
+        if ((dataIsArray && !extensionsIsArray) || (!dataIsArray && extensionsIsArray)) {
+            return data;
+        }
+        // if both are arrays, merge them, maintaining the length of data
+        if (dataIsArray && extensionsIsArray) {
+            return data.map((item, index) => deepMerge$1(item, extensions[index]));
+        }
+        // if both are objects, merge them
+        // get the keys of both objects
+        const dataKeys = Object.keys(data);
+        const extensionsKeys = Object.keys(extensions);
+        // get the keys that are in both objects
+        const commonKeys = dataKeys.filter((key) => extensionsKeys.includes(key));
+        // get the keys that are in data but not in extensions
+        const dataKeysNotInExtensions = dataKeys.filter((key) => !extensionsKeys.includes(key));
+        // get the keys that are in extensions but not in data
+        const extensionsKeysNotInData = extensionsKeys.filter((key) => !dataKeys.includes(key));
+        return {
+            ...Object.fromEntries(commonKeys.map((key) => [
+                key,
+                deepMerge$1(data[key], extensions[key]),
+            ])),
+            ...Object.fromEntries(dataKeysNotInExtensions.map((key) => [key, data[key]])),
+            ...Object.fromEntries(extensionsKeysNotInData.map((key) => [key, extensions[key]])),
+        };
+    }
+
     function buildCommandClass(baseClass) {
         return class extends baseClass {
             constructor(config, documentRootType, services) {
@@ -103466,21 +103747,167 @@
                 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 augmentedResponse = mergeResponseWithExtensions(data);
+                const extensionResult = buildGraphQLInputExtension({
+                    ...this.config,
+                    query: this.buildRequestQuery(),
+                });
+                if (extensionResult.isErr()) {
+                    throw new InternalError(extensionResult.error);
+                }
+                return {
+                    data: augmentedResponse.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()) {
+                                    return this.buildResultType().write(cache.buildFixedTimeWritableCache(Date.now() / 1000), {
+                                        ...this.buildWriteInput(networkResult.value),
+                                        reader,
+                                        getNormalizedLuvioRecord: this.services.luvioUiapiRecords
+                                            .getNormalizedLuvioRecord,
+                                    });
+                                }
+                            },
+                        },
+                        variables: {},
+                    });
+                }
+                catch (error) {
+                    // swallow 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 +103951,10 @@
             version: '1.0',
             optional: true,
         },
+        luvioUiapiRecords: {
+            type: 'luvioUiapiRecords',
+            version: '1.0',
+        },
     };
     let provisionedCallback;
     getServices(serviceRequirements).then((services) => {
@@ -103559,7 +103990,7 @@
             cb(graphql$1, graphql_imperative$1, useOneStoreGraphQL);
         }
     }
-    // version: 1.377.0-b0d5c49e07
+    // version: 1.378.0-63d7c07562
 
     function createFragmentMap(documentNode) {
         const fragments = {};
@@ -130054,7 +130485,7 @@
         }
         return refresh$3(data, 'refreshUiApi');
     }
-    // version: 1.377.0-b0d5c49e07
+    // version: 1.378.0-63d7c07562
 
     // On core the unstable adapters are re-exported with different names,
     // we want to match them here.
@@ -130206,7 +130637,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.377.0-b0d5c49e07
+    // version: 1.378.0-63d7c07562
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -131005,7 +131436,7 @@
     function register(r) {
         callbacks$1.forEach((callback) => callback(r));
     }
-    // version: 1.377.0-3c95caf11c
+    // version: 1.378.0-0ab3d40d29
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -132342,4 +132773,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.377.0-3c95caf11c
+// version: 1.378.0-0ab3d40d29