@salesforce/lds-worker-api 1.377.0 → 1.378.0

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.378.0-0ab3d40d29
 
 // 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.378.0-0ab3d40d29
 
 /**
  * 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.378.0-63d7c07562
 
 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 {
@@ -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.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.,
@@ -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.378.0-0ab3d40d29
 
 const { create: create$3, keys: keys$3 } = Object;
 const { stringify: stringify$1, parse } = JSON;
@@ -98800,11 +98887,7 @@ function extractVariableValue(variableName, variableDefinitions) {
   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) {
@@ -98826,7 +98909,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 +98925,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 +98965,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;
@@ -98988,6 +99097,243 @@ function shouldSkip(selection, variables) {
   }
   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);
@@ -99108,7 +99454,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 +99475,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 +99569,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 +99590,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);
@@ -99352,9 +99698,23 @@ class BaseGraphQLTypeRepository {
     }
     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);
@@ -99460,7 +99820,7 @@ class IdentifiableGraphQLTypeRepository extends IdentifiableTypeRepository {
       return normalizeDataResult;
     }
     return ok$4(
-      deepMerge$1(
+      deepMerge$2(
         {},
         (existingNormalizedData == null ? void 0 : existingNormalizedData.value) || {},
         normalizeDataResult.value
@@ -99736,245 +100096,6 @@ function augmentUnionLikeSelections(input, possibleTypes) {
   });
   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: {
@@ -100275,10 +100396,10 @@ function emitGraphQLResult(callback, result) {
     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);
@@ -100287,6 +100408,18 @@ function resolveAst(ast) {
   }
   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 {
@@ -100365,7 +100498,7 @@ function buildAsyncGraphQLImperativeLegacyInvoker(getCommand) {
   };
   return { invoke, subscribe };
 }
-// version: 1.377.0-b0d5c49e07
+// version: 1.378.0-63d7c07562
 
 class Analytics__AnalyticsBrowseRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
@@ -101541,7 +101674,7 @@ class PolymorphicAggregateParentRelationshipRepository extends BaseUnionReposito
     }
 }
 
-class PolymorphicParentRelationshipRepository extends BaseUnionRepository {
+let PolymorphicParentRelationshipRepository$1 = class PolymorphicParentRelationshipRepository extends BaseUnionRepository {
     constructor(services, typeRegistry) {
         super(services);
         this.services = services;
@@ -101558,7 +101691,7 @@ class PolymorphicParentRelationshipRepository extends BaseUnionRepository {
             __typename: new BaseScalarFieldDef(false),
         };
     }
-}
+};
 
 class QueryRepository extends GraphQLDocumentRootTypeRepository {
     constructor(services, typeRegistry) {
@@ -102596,7 +102729,7 @@ class GraphQLTypeRegistry {
         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 =
@@ -103049,6 +103182,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
@@ -103056,8 +103233,6 @@ function buildGenericTypeFieldDef(selection, fields, staticFieldNames, typename)
         return fields[selection.name.value];
     }
     return {
-        type: 'object',
-        nullable: true,
         read: (cache, input) => {
             if (!input.selection.selectionSet) {
                 return err([
@@ -103071,6 +103246,9 @@ function buildGenericTypeFieldDef(selection, fields, staticFieldNames, typename)
             if (normalizedData.type === 'missing') {
                 return ok(undefined);
             }
+            if (normalizedData.data === null) {
+                return ok(null);
+            }
             const fieldCategory = normalizedData.fieldCategory;
             const fieldDef = fields[fieldCategory];
             if (!fieldDef) {
@@ -103095,6 +103273,9 @@ function buildGenericTypeFieldDef(selection, fields, staticFieldNames, typename)
             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) {
@@ -103113,7 +103294,6 @@ function buildGenericTypeFieldDef(selection, fields, staticFieldNames, typename)
         },
         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) {
@@ -103165,13 +103345,38 @@ class RecordRepresentationRepository extends RecordRepresentationRepository$1 {
         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;
     }
 }
@@ -103299,8 +103504,6 @@ class RecordQueryAggregateRepository extends RecordQueryAggregateRepository$1 {
 }
 
 const blobTypeDef = {
-    type: 'scalar',
-    nullable: true,
     read: (_cache, input) => {
         return ok({
             data: input.data,
@@ -103410,6 +103613,14 @@ class SetupRecordAggregateRepository extends Setup__SetupRecordAggregateReposito
     }
 }
 
+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);
@@ -103422,6 +103633,7 @@ class CustomGraphQLTypeRegistry extends GraphQLTypeRegistry {
         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;
@@ -103450,9 +103662,78 @@ class CustomGraphQLTypeRegistry extends GraphQLTypeRegistry {
     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) {
@@ -103460,21 +103741,167 @@ 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 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) { }
+            }
         }
     };
 }
@@ -103518,6 +103945,10 @@ const serviceRequirements = {
         version: '1.0',
         optional: true,
     },
+    luvioUiapiRecords: {
+        type: 'luvioUiapiRecords',
+        version: '1.0',
+    },
 };
 let provisionedCallback;
 getServices(serviceRequirements).then((services) => {
@@ -103553,7 +103984,7 @@ function registerCallback(cb) {
         cb(graphql$1, graphql_imperative$1, useOneStoreGraphQL);
     }
 }
-// version: 1.377.0-b0d5c49e07
+// version: 1.378.0-63d7c07562
 
 function createFragmentMap(documentNode) {
     const fragments = {};
@@ -130048,7 +130479,7 @@ function refreshGraphQL(data) {
     }
     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.
@@ -130200,7 +130631,7 @@ withDefaultLuvio((luvio) => {
     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,
@@ -130999,7 +131430,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.377.0-3c95caf11c
+// version: 1.378.0-0ab3d40d29
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -132315,4 +132746,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.378.0-0ab3d40d29