@salesforce/lds-worker-api 1.377.1 → 1.379.0

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

@@ -4280,7 +4280,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.377.1-dadb6358f3
+    // version: 1.379.0-fc97fd9203
 
     // 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.1-dadb6358f3
+    // version: 1.379.0-fc97fd9203
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -34160,7 +34160,7 @@
         throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
         throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
     });
-    // version: 1.377.1-db77d3f339
+    // version: 1.379.0-a57c798add
 
     function requestIdleDetectedCallback(_callback) { }
     function declareNotifierTaskSingle(_name) {
@@ -45770,15 +45770,6 @@
         },
     };
 
-    var productConsumedSideEffects = {
-        isOpen: function (e) {
-            return e.fallback;
-        },
-        hasError: function () {
-            return !0;
-        },
-    };
-
     var useOneStore = {
         isOpen: function (e) {
             return e.fallback;
@@ -46123,6 +46114,15 @@
       return ok$4(data);
     }
 
+    var productConsumedSideEffects = {
+        isOpen: function (e) {
+            return e.fallback;
+        },
+        hasError: function () {
+            return !0;
+        },
+    };
+
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
      * All rights reserved.
@@ -87035,9 +87035,9 @@
                             }
                             // spanning field needs to have the directive with 'parentRelationship'
                             const directives = isSpanning && !isInlineFragment ? [parentRelationshipDirective] : [];
-                            let idField = isSpanning && !isPolymorphicField ? [createFieldNode$1('Id')] : [];
+                            let idField = isSpanning && !isPolymorphicField ? [createFieldNode('Id')] : [];
                             // This variable change to InlineFragment if 'isInlineFragment' is true
-                            let sel = createFieldNode$1(fieldName);
+                            let sel = createFieldNode(fieldName);
                             // Check if fields is valid
                             if (apiNames.length === 1 && !isInlineFragment) {
                                 const objectInfo = objectInfos[apiNames[0]];
@@ -87083,7 +87083,7 @@
                                     idField = [];
                                 }
                                 if (isInlineFragment && !isTypeNameExisting) {
-                                    idField.push(createFieldNode$1('__typename'));
+                                    idField.push(createFieldNode('__typename'));
                                 }
                                 //Inject Conditions: 1. Same field does not exist 2. Same fields has different children. 3. Filter spanning field does not have Id. 4. InLineFragment does not have the '__typename' field
                                 if (!existingFields ||
@@ -87150,7 +87150,7 @@
                                         .filter(isFieldNode)
                                         .filter((subNode) => subNode.name.value === relationField);
                                 if (!existingRelationFields || existingRelationFields.length === 0) {
-                                    injectedSelections.push(createFieldNode$1(relationField, FieldValueNodeSelectionSet));
+                                    injectedSelections.push(createFieldNode(relationField, FieldValueNodeSelectionSet));
                                 }
                             }
                         }
@@ -87241,7 +87241,7 @@
                 .filter(isFieldNode)
                 .filter((subNode) => subNode.name.value === 'value');
         return !existingValueFields || existingValueFields.length === 0
-            ? [createFieldNode$1('value')]
+            ? [createFieldNode('value')]
             : [];
     }
     function updateIDInfo(fieldNode, idState, draftFunctions) {
@@ -87322,20 +87322,20 @@
                         .filter(isFieldNode)
                         .filter((subNode) => subNode.name.value === relationshipId);
                     if (existingRelationFields.length === 0) {
-                        parentInjectedNodes.push(createFieldNode$1(relationshipId, FieldValueNodeSelectionSet));
+                        parentInjectedNodes.push(createFieldNode(relationshipId, FieldValueNodeSelectionSet));
                     }
                 }
                 // For polymorphic fields, the Id field is excluded.
                 const excludeId = isPolymorphicFieldPath(curPath, pathToObjectApiNamesMap, objectInfos);
                 const idSelection = [];
                 if (!excludeId && hasIdNode === false) {
-                    idSelection.push(createFieldNode$1('Id'));
+                    idSelection.push(createFieldNode('Id'));
                 }
                 // Inject '__typename' for InlineFragment. '__typename' field acts as a reference to concrete type of a polymorphic field or a standard field in the returned GQL response, which equals to
                 // `typedCondition` of the InlineFragment in the query AST. It is used to match JSON response with AST node. For more detail, please reference 'removeSyntheticFields'.
                 if (isInlineFragmentNode(selection) &&
                     !selection.selectionSet.selections.find((selection) => isFieldNode(selection) && selection.name.value === '__typename')) {
-                    idSelection.push(createFieldNode$1('__typename'));
+                    idSelection.push(createFieldNode('__typename'));
                 }
                 // 'ServiceAppointment' --> 'Contact' --> 'Id', Inject 'Contact' with Id. 'Id' field is at the sub level.
                 if (idSelection.length > 0 || subInjectedSelections.length > 0) {
@@ -87379,7 +87379,7 @@
                 objectInfo.nameFields !== undefined &&
                 objectInfo.nameFields.length > 0) {
                 displayValueNameFields = objectInfo.nameFields.map((fieldName) => {
-                    return createFieldNode$1(fieldName, FieldValueNodeSelectionSet);
+                    return createFieldNode(fieldName, FieldValueNodeSelectionSet);
                 });
             }
         }
@@ -87410,7 +87410,7 @@
             if (parentNode.name.value === 'node') {
                 const idNode = findIdFieldNode(parentNode);
                 if (idNode === false) {
-                    rootQueryIdField.push(createFieldNode$1('Id'));
+                    rootQueryIdField.push(createFieldNode('Id'));
                 }
             }
             // example { node { Id } }. The operation happens at the 'edges' -> 'node'  level of the 'childRelationship' field
@@ -87438,7 +87438,7 @@
                                 .filter(isFieldNode)
                                 .some((sibling) => sibling.name.value === injectedParentFieldName)) {
                                 // example: TimeSheetId { value }
-                                relatedIdForChildRelationship.push(createFieldNode$1(injectedParentFieldName, FieldValueNodeSelectionSet));
+                                relatedIdForChildRelationship.push(createFieldNode(injectedParentFieldName, FieldValueNodeSelectionSet));
                             }
                             displayValueNameFields.push(...injectFieldsForDisplayValue(parentNode, targetRelationship.childObjectApiName, objectInfos));
                         }
@@ -87890,7 +87890,7 @@
      * @param selectionSet
      * @returns
      */
-    function createFieldNode$1(nameValue, selectionSet) {
+    function createFieldNode(nameValue, selectionSet) {
         return {
             kind: Kind$3.FIELD,
             name: {
@@ -95887,7 +95887,7 @@
             },
         };
     }
-    // version: 1.377.1-db77d3f339
+    // version: 1.379.0-a57c798add
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -95913,7 +95913,7 @@
             },
         };
     }
-    // version: 1.377.1-db77d3f339
+    // version: 1.379.0-a57c798add
 
     /*!
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -98029,7 +98029,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$2,
     });
-    // version: 1.377.1-dadb6358f3
+    // version: 1.379.0-fc97fd9203
 
     const { create: create$3, keys: keys$3 } = Object;
     const { stringify: stringify$1, parse } = JSON;
@@ -98893,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) {
@@ -99107,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);
@@ -99175,7 +99408,11 @@
       }
       augmentInlineFragmentSelection(fragment, fragments) {
         var _a;
-        if (!this.satisfiesFragmentTypeCondition(fragment)) {
+        const satisfiedFragmentTypeConditionResult = this.satisfiesFragmentTypeCondition(
+          void 0,
+          fragment
+        );
+        if (satisfiedFragmentTypeConditionResult.isErr() || !satisfiedFragmentTypeConditionResult.value) {
           return { selections: [], fragments };
         }
         const augmentedFragmentSelections = this.augmentSelections({
@@ -99201,7 +99438,11 @@
         if (fragment === void 0) {
           return { selections: [selection], fragments };
         }
-        if (!this.satisfiesFragmentTypeCondition(fragment)) {
+        const satisfiedFragmentTypeConditionResult = this.satisfiesFragmentTypeCondition(
+          void 0,
+          fragment
+        );
+        if (satisfiedFragmentTypeConditionResult.isErr() || !satisfiedFragmentTypeConditionResult.value) {
           return { selections: [], fragments };
         }
         const augmentedFragmentSelections = this.augmentSelections({
@@ -99314,10 +99555,7 @@
         };
       }
       normalizeFragment(cache, input, fragment, errorCollector) {
-        const shouldProcessResult = this.shouldProcessFragment(
-          fragment,
-          input.request.definitions.variables
-        );
+        const shouldProcessResult = this.shouldProcessFragment(input, fragment);
         if (shouldProcessResult.isErr()) {
           errorCollector.push({
             type: "unknown",
@@ -99448,10 +99686,7 @@
         };
       }
       denormalizeFragment(cache, input, fragment, errorCollector) {
-        const shouldProcessResult = this.shouldProcessFragment(
-          fragment,
-          input.request.definitions.variables
-        );
+        const shouldProcessResult = this.shouldProcessFragment(input, fragment);
         if (shouldProcessResult.isErr()) {
           errorCollector.push({
             type: "unknown",
@@ -99471,32 +99706,46 @@
         }
         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);
+      shouldProcessFragment(input, fragment) {
+        const shouldSkipResult = shouldSkip(fragment, input.request.definitions.variables);
         if (shouldSkipResult.isErr()) {
           return shouldSkipResult;
         }
         if (shouldSkipResult.value) {
           return ok$4(false);
         }
-        return ok$4(this.satisfiesFragmentTypeCondition(fragment));
+        return this.satisfiesFragmentTypeCondition(input, fragment);
       }
-      satisfiesFragmentTypeCondition(fragment) {
+      satisfiesFragmentTypeCondition(_input, fragment) {
         if (!fragment.typeCondition) {
-          return true;
+          return ok$4(true);
         }
         const conditionalTypeName = fragment.typeCondition.name.value;
         if (conditionalTypeName === this.typeName) {
-          return true;
+          return ok$4(true);
         }
         if (this.implementedInterfaces.includes(conditionalTypeName)) {
-          return true;
+          return ok$4(true);
         }
-        return false;
+        return ok$4(false);
       }
       getCacheKeyFieldArguments(selection) {
         return selection.arguments;
@@ -99855,245 +100104,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: {
@@ -100394,10 +100404,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);
@@ -100406,6 +100416,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 {
@@ -100452,10 +100474,11 @@
       }
     }
     function buildAsyncGraphQLImperativeLegacyInvoker(getCommand) {
-      const invoke = async (config, _requestContext, callback) => {
+      const invoke = async (config, requestContext, callback) => {
         const command = getCommand({ config, assertIsValid });
         try {
-          const result = await command.execute();
+          const overrides = requestContextIsCachePolicy(requestContext) ? { cacheControlConfig: { type: "no-cache" } } : {};
+          const result = await command.execute(overrides);
           if (result.isOk()) {
             deepFreeze(result.value);
           }
@@ -100464,11 +100487,12 @@
           emitGraphQLResult(callback, err$1(error));
         }
       };
-      const subscribe = (config, _requestContext, callback) => {
+      const subscribe = (config, requestContext, callback) => {
         const command = getCommand({ config, assertIsValid });
         let unsubscribe = () => {
         };
-        command.execute().then((result) => {
+        const overrides = requestContextIsCachePolicy(requestContext) ? { cacheControlConfig: { type: "no-cache" } } : {};
+        command.execute(overrides).then((result) => {
           if (!result.isOk()) {
             emitGraphQLResult(callback, result);
             return;
@@ -100484,7 +100508,10 @@
       };
       return { invoke, subscribe };
     }
-    // version: 1.377.1-db77d3f339
+    function requestContextIsCachePolicy(requestContext) {
+      return typeof requestContext === "object" && requestContext !== null && "cachePolicy" in requestContext && typeof requestContext.cachePolicy === "object" && requestContext.cachePolicy !== null && "type" in requestContext.cachePolicy && requestContext.cachePolicy.type === "no-cache";
+    }
+    // version: 1.379.0-a57c798add
 
     class Analytics__AnalyticsBrowseRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
@@ -100696,7 +100723,14 @@
             this.namespace = "oas";
             this.typeName = "AnyType";
             this.implementedInterfaces = [];
-            this.possibleTypes = {
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+            };
+        }
+        get possibleTypes() {
+            return {
                 BooleanValue: this.typeRegistry.BooleanValue,
                 DateValue: this.typeRegistry.DateValue,
                 DateTimeValue: this.typeRegistry.DateTimeValue,
@@ -100704,11 +100738,6 @@
                 StringValue: this.typeRegistry.StringValue,
             };
         }
-        get fields() {
-            return {
-                __typename: new BaseScalarFieldDef(false),
-            };
-        }
     }
 
     class Base64ValueRepository extends UnidentifiableGraphQLTypeRepository {
@@ -101641,7 +101670,7 @@
         }
     }
 
-    class PolymorphicAggregateParentRelationshipRepository extends BaseUnionRepository {
+    let PolymorphicAggregateParentRelationshipRepository$1 = class PolymorphicAggregateParentRelationshipRepository extends BaseUnionRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101649,18 +101678,20 @@
             this.namespace = "oas";
             this.typeName = "PolymorphicAggregateParentRelationship";
             this.implementedInterfaces = [];
-            this.possibleTypes = {
-                RecordAggregate: this.typeRegistry.RecordAggregate,
-            };
         }
         get fields() {
             return {
                 __typename: new BaseScalarFieldDef(false),
             };
         }
-    }
+        get possibleTypes() {
+            return {
+                RecordAggregate: this.typeRegistry.RecordAggregate,
+            };
+        }
+    };
 
-    class PolymorphicParentRelationshipRepository extends BaseUnionRepository {
+    let PolymorphicParentRelationshipRepository$1 = class PolymorphicParentRelationshipRepository extends BaseUnionRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101668,16 +101699,18 @@
             this.namespace = "oas";
             this.typeName = "PolymorphicParentRelationship";
             this.implementedInterfaces = [];
-            this.possibleTypes = {
-                RecordRepresentation: this.typeRegistry.RecordRepresentation,
-            };
         }
         get fields() {
             return {
                 __typename: new BaseScalarFieldDef(false),
             };
         }
-    }
+        get possibleTypes() {
+            return {
+                RecordRepresentation: this.typeRegistry.RecordRepresentation,
+            };
+        }
+    };
 
     class QueryRepository extends GraphQLDocumentRootTypeRepository {
         constructor(services, typeRegistry) {
@@ -101701,7 +101734,7 @@
         }
     }
 
-    class RecordAggregateConnectionRepository extends UnidentifiableGraphQLTypeRepository {
+    let RecordAggregateConnectionRepository$1 = class RecordAggregateConnectionRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101718,9 +101751,9 @@
                 totalCount: new BaseScalarFieldDef(false),
             };
         }
-    }
+    };
 
-    class RecordAggregateEdgeRepository extends UnidentifiableGraphQLTypeRepository {
+    let RecordAggregateEdgeRepository$1 = class RecordAggregateEdgeRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101736,7 +101769,7 @@
                 cursor: new BaseScalarFieldDef(false),
             };
         }
-    }
+    };
 
     let RecordAggregateRepository$1 = class RecordAggregateRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
@@ -101774,7 +101807,7 @@
         }
     };
 
-    class RecordConnectionRepository extends UnidentifiableGraphQLTypeRepository {
+    let RecordConnectionRepository$1 = class RecordConnectionRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101792,9 +101825,9 @@
                 pageResultCount: new BaseScalarFieldDef(false),
             };
         }
-    }
+    };
 
-    class RecordEdgeRepository extends UnidentifiableGraphQLTypeRepository {
+    let RecordEdgeRepository$1 = class RecordEdgeRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101810,7 +101843,7 @@
                 cursor: new BaseScalarFieldDef(false),
             };
         }
-    }
+    };
 
     let RecordQueryAggregateRepository$1 = class RecordQueryAggregateRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
@@ -101905,7 +101938,7 @@
         }
     };
 
-    class RecordResultRepository extends UnidentifiableGraphQLTypeRepository {
+    let RecordResultRepository$1 = class RecordResultRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101920,7 +101953,7 @@
                 aggregate: new BaseObjectFieldDef(this.typeRegistry.RecordAggregate, true),
             };
         }
-    }
+    };
 
     class RecordTypeInfoRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
@@ -102343,15 +102376,17 @@
             this.namespace = "oas";
             this.typeName = "Setup__SetupPolymorphicAggregateParentRelationship";
             this.implementedInterfaces = [];
-            this.possibleTypes = {
-                Setup__SetupRecordAggregate: this.typeRegistry.Setup__SetupRecordAggregate,
-            };
         }
         get fields() {
             return {
                 __typename: new BaseScalarFieldDef(false),
             };
         }
+        get possibleTypes() {
+            return {
+                Setup__SetupRecordAggregate: this.typeRegistry.Setup__SetupRecordAggregate,
+            };
+        }
     }
 
     class Setup__SetupPolymorphicParentRelationshipRepository extends BaseUnionRepository {
@@ -102362,15 +102397,17 @@
             this.namespace = "oas";
             this.typeName = "Setup__SetupPolymorphicParentRelationship";
             this.implementedInterfaces = [];
-            this.possibleTypes = {
-                Setup__EntityRepresentation: this.typeRegistry.Setup__EntityRepresentation,
-            };
         }
         get fields() {
             return {
                 __typename: new BaseScalarFieldDef(false),
             };
         }
+        get possibleTypes() {
+            return {
+                Setup__EntityRepresentation: this.typeRegistry.Setup__EntityRepresentation,
+            };
+        }
     }
 
     class Setup__SetupQueryAggregateRepository extends UnidentifiableGraphQLTypeRepository {
@@ -102715,15 +102752,15 @@
             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 =
                 new RecordRepresentationRepository$1(this.services, this);
-            this._RecordEdge = new RecordEdgeRepository(this.services, this);
+            this._RecordEdge = new RecordEdgeRepository$1(this.services, this);
             this._PageInfo = new PageInfoRepository(this.services, this);
             this._RecordConnection =
-                new RecordConnectionRepository(this.services, this);
+                new RecordConnectionRepository$1(this.services, this);
             this._RecordQuery = new RecordQueryRepository$1(this.services, this);
             this._BooleanAggregate =
                 new BooleanAggregateRepository(this.services, this);
@@ -102753,13 +102790,13 @@
             this._TimeAggregate = new TimeAggregateRepository(this.services, this);
             this._UrlAggregate = new UrlAggregateRepository(this.services, this);
             this._PolymorphicAggregateParentRelationship =
-                new PolymorphicAggregateParentRelationshipRepository(this.services, this);
+                new PolymorphicAggregateParentRelationshipRepository$1(this.services, this);
             this._RecordAggregate = new RecordAggregateRepository$1(this.services, this);
-            this._RecordResult = new RecordResultRepository(this.services, this);
+            this._RecordResult = new RecordResultRepository$1(this.services, this);
             this._RecordAggregateEdge =
-                new RecordAggregateEdgeRepository(this.services, this);
+                new RecordAggregateEdgeRepository$1(this.services, this);
             this._RecordAggregateConnection =
-                new RecordAggregateConnectionRepository(this.services, this);
+                new RecordAggregateConnectionRepository$1(this.services, this);
             this._RecordQueryAggregate =
                 new RecordQueryAggregateRepository$1(this.services, this);
             this._ChildRelationship =
@@ -103219,8 +103256,6 @@
             return fields[selection.name.value];
         }
         return {
-            type: 'object',
-            nullable: true,
             read: (cache, input) => {
                 if (!input.selection.selectionSet) {
                     return err([
@@ -103234,6 +103269,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) {
@@ -103258,6 +103296,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) {
@@ -103276,7 +103317,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) {
@@ -103306,9 +103346,19 @@
                 'RecordTypeId',
             ];
         }
-        getFieldDef(input, selection) {
+        getFieldDef(_input, selection) {
             return buildGenericTypeFieldDef(selection, this.fields, this.staticFieldNames, this.typeName);
         }
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
     }
 
     class RecordRepresentationRepository extends RecordRepresentationRepository$1 {
@@ -103328,7 +103378,30 @@
             return this._graphqlRepositoryOverride;
         }
         write(cache, input) {
-            const result = super.write(cache, input);
+            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 = {
+                    ...overridenInput,
+                    selections: [
+                        ...overridenInput.selections,
+                        { kind: 'Field', name: { kind: 'Name', value: 'Id' } },
+                    ],
+                };
+            }
+            // If WeakEtag exists in the data but wasn't asked for, its from the extensions, and we should normalize it
+            if (input.data.WeakEtag !== undefined &&
+                !input.selections.find((selection) => selection.kind === 'Field' && selection.name.value === 'WeakEtag')) {
+                overridenInput = {
+                    ...overridenInput,
+                    selections: [
+                        ...overridenInput.selections,
+                        { kind: 'Field', name: { kind: 'Name', value: 'WeakEtag' } },
+                    ],
+                };
+            }
+            const result = super.write(cache, overridenInput);
             const recordId = input.data.Id;
             const luvioRecord = input.getNormalizedLuvioRecord(recordId, input.reader);
             if (luvioRecord?.weakEtag &&
@@ -103340,13 +103413,18 @@
         }
         read(cache, input) {
             const result = super.read(cache, input);
-            const idData = super.read(cache, {
+            const trackingData = super.read(cache, {
                 ...input,
-                selections: [{ kind: 'Field', name: { kind: 'Name', value: 'Id' } }],
+                selections: [
+                    { kind: 'Field', name: { kind: 'Name', value: 'Id' } },
+                    { kind: 'Field', name: { kind: 'Name', value: 'WeakEtag' } },
+                ],
             });
-            if (idData.isOk()) {
+            if (trackingData.isOk()) {
                 // Read the record to track subscription
-                input.getNormalizedLuvioRecord(idData.value.Id, input.reader);
+                input.getNormalizedLuvioRecord(trackingData.value.Id, input.reader);
+                // Track the weak etag for the record for cross cache invalidation
+                input.usedRecordIdToWeakEtagMap[trackingData.value.Id] = trackingData.value.WeakEtag;
             }
             return result;
         }
@@ -103439,6 +103517,16 @@
         isBaseFieldSelection(selection) {
             return super.getFieldDef(undefined, selection) !== undefined;
         }
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
     }
 
     class RecordQueryRepository extends RecordQueryRepository$1 {
@@ -103460,6 +103548,16 @@
         getFieldDef(input, selection) {
             return buildGenericTypeFieldDef(selection, this.fields, this.staticFieldNames, this.typeName);
         }
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
     }
 
     class RecordQueryAggregateRepository extends RecordQueryAggregateRepository$1 {
@@ -103474,12 +103572,12 @@
         }
     }
 
+    // This should be smarter, and filter on selections, but for now,
+    // we'll match the luvio behavior of returning the blob
     const blobTypeDef = {
-        type: 'scalar',
-        nullable: true,
         read: (_cache, input) => {
             return ok({
-                data: input.data,
+                data: input.normalizedData,
             });
         },
         write: (_cache, input) => {
@@ -103547,6 +103645,16 @@
             // We should make this smarter, storing and returning blobs isn't great since it could, and likely will, include unrequested field data
             return blobTypeDef;
         }
+        satisfiesFragmentTypeCondition(input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
     }
 
     class SetupQueryAggregateRepository extends Setup__SetupQueryAggregateRepository {
@@ -103584,27 +103692,262 @@
             }
             return blobTypeDef;
         }
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class PolymorphicParentRelationshipRepository extends PolymorphicParentRelationshipRepository$1 {
+        getTypeDiscriminator(data, _selections) {
+            // Hardcoded to record representation since that's the only type of parent
+            // relationship possible
+            return 'RecordRepresentation';
+        }
+    }
+
+    // We're going to override the generated repository
+    // to make this a pseudo-identifiable repository
+    // so that we can independently control its cache control (no-cache)
+    class SetupRepository extends IdentifiableGraphQLTypeRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.typeRegistry = typeRegistry;
+            this.namespace = 'oas';
+            this.typeName = 'Setup__Setup';
+            this.implementedInterfaces = [];
+            this.cacheControl = {
+                type: 'no-cache',
+            };
+            this.baseRepository = new Setup__SetupRepository(services, typeRegistry);
+        }
+        get fields() {
+            return this.baseRepository.fields;
+        }
+        buildKeyParams(_input) {
+            return null;
+        }
+        augmentSelections(input) {
+            return this.baseRepository.augmentSelections(input);
+        }
+    }
+
+    class SetupEdgeRepository extends Setup__SetupEdgeRepository {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class PolymorphicAggregateParentRelationshipRepository extends PolymorphicAggregateParentRelationshipRepository$1 {
+        getTypeDiscriminator(data, _selections) {
+            // Hardcoded to record aggregate since that's the only type of parent
+            // relationship possible
+            return 'RecordAggregate';
+        }
+    }
+
+    class RecordAggregateConnectionRepository extends RecordAggregateConnectionRepository$1 {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class RecordAggregateEdgeRepository extends RecordAggregateEdgeRepository$1 {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class RecordConnectionRepository extends RecordConnectionRepository$1 {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class RecordEdgeRepository extends RecordEdgeRepository$1 {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class RecordResultRepository extends RecordResultRepository$1 {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class SetupRecordResultRepository extends Setup__SetupRecordResultRepository {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class SetupAggregateConnectionRepository extends Setup__SetupAggregateConnectionRepository {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class SetupAggregateEdgeRepository extends Setup__SetupAggregateEdgeRepository {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class SetupConnectionRepository extends Setup__SetupConnectionRepository {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class SetupPolymorphicAggregateParentRelationshipRepository extends Setup__SetupPolymorphicAggregateParentRelationshipRepository {
+        getTypeDiscriminator(data, _selections) {
+            // Hardcoded to Setup__SetupRecordAggregate since that's the only type of parent
+            // relationship possible
+            return 'Setup__SetupRecordAggregate';
+        }
+    }
+
+    class SetupPolymorphicParentRelationshipRepository extends Setup__SetupPolymorphicParentRelationshipRepository {
+        getTypeDiscriminator(data, _selections) {
+            // Hardcoded to Setup__EntityRepresentation since that's the only type of parent
+            // relationship possible
+            return 'Setup__EntityRepresentation';
+        }
     }
 
     class CustomGraphQLTypeRegistry extends GraphQLTypeRegistry {
         constructor(services) {
             super(services);
-            this._RecordRepresentation = new RecordRepresentationRepository(services, this);
+            // UIAPI Records overrides
             this._CompoundField = new CompoundFieldRepository(services, this);
-            this._RecordQuery = new RecordQueryRepository(services, this);
+            this._PolymorphicAggregateParentRelationship =
+                new PolymorphicAggregateParentRelationshipRepository(services, this);
+            this._PolymorphicParentRelationship = new PolymorphicParentRelationshipRepository(services, this);
+            this._RecordAggregateConnection = new RecordAggregateConnectionRepository(services, this);
+            this._RecordAggregateEdge = new RecordAggregateEdgeRepository(services, this);
             this._RecordAggregate = new RecordAggregateRepository(services, this);
+            this._RecordConnection = new RecordConnectionRepository(services, this);
+            this._RecordEdge = new RecordEdgeRepository(services, this);
             this._RecordQueryAggregate = new RecordQueryAggregateRepository(services, this);
+            this._RecordQuery = new RecordQueryRepository(services, this);
+            this._RecordRepresentation = new RecordRepresentationRepository(services, this);
+            this._RecordResult = new RecordResultRepository(services, this);
+            // Setup overrides
+            this._SetupAggregateConnection = new SetupAggregateConnectionRepository(services, this);
+            this._SetupAggregateEdge = new SetupAggregateEdgeRepository(services, this);
+            this._SetupConnection = new SetupConnectionRepository(services, this);
+            this._SetupEdge = new SetupEdgeRepository(services, this);
             this._SetupEntityRepresentation = new SetupEntityRepresentationRepository(services, this);
+            this._SetupPolymorphicAggregateParentRelationship =
+                new SetupPolymorphicAggregateParentRelationshipRepository(services, this);
+            this._SetupPolymorphicParentRelationship = new SetupPolymorphicParentRelationshipRepository(services, this);
             this._SetupQueryAggregate = new SetupQueryAggregateRepository(services, this);
             this._SetupQuery = new SetupQueryRepository(services, this);
             this._SetupRecordAggregate = new SetupRecordAggregateRepository(services, this);
+            this._SetupRecordResult = new SetupRecordResultRepository(services, this);
+            this._Setup = new SetupRepository(services, this);
         }
         get CompoundField() {
             return this._CompoundField;
         }
+        get PolymorphicAggregateParentRelationship() {
+            return this._PolymorphicAggregateParentRelationship;
+        }
+        get PolymorphicParentRelationship() {
+            return this._PolymorphicParentRelationship;
+        }
+        get RecordAggregateConnection() {
+            return this._RecordAggregateConnection;
+        }
+        get RecordAggregateEdge() {
+            return this._RecordAggregateEdge;
+        }
         get RecordAggregate() {
             return this._RecordAggregate;
         }
+        get RecordConnection() {
+            return this._RecordConnection;
+        }
+        get RecordEdge() {
+            return this._RecordEdge;
+        }
         get RecordQueryAggregate() {
             return this._RecordQueryAggregate;
         }
@@ -103614,167 +103957,111 @@
         get RecordRepresentation() {
             return this._RecordRepresentation;
         }
-        get SetupEntityRepresentation() {
+        get RecordResult() {
+            return this._RecordResult;
+        }
+        get Setup__SetupAggregateConnection() {
+            return this._SetupAggregateConnection;
+        }
+        get Setup__SetupAggregateEdge() {
+            return this._SetupAggregateEdge;
+        }
+        get Setup__SetupConnection() {
+            return this._SetupConnection;
+        }
+        get Setup__SetupEdge() {
+            return this._SetupEdge;
+        }
+        get Setup__EntityRepresentation() {
             return this._SetupEntityRepresentation;
         }
-        get SetupQueryAggregate() {
+        get Setup__SetupPolymorphicAggregateParentRelationship() {
+            return this._SetupPolymorphicAggregateParentRelationship;
+        }
+        get Setup__SetupPolymorphicParentRelationship() {
+            return this._SetupPolymorphicParentRelationship;
+        }
+        get Setup__SetupQueryAggregate() {
             return this._SetupQueryAggregate;
         }
-        get SetupQuery() {
+        get Setup__SetupQuery() {
             return this._SetupQuery;
         }
-        get SetupRecordAggregate() {
+        get Setup__SetupRecordAggregate() {
             return this._SetupRecordAggregate;
         }
+        get Setup__SetupRecordResult() {
+            return this._SetupRecordResult;
+        }
+        get Setup__Setup() {
+            return this._Setup;
+        }
     }
 
     const CONFIG_SCHEMA = GraphQLQueryJsonSchema;
 
-    // Fields with arguments need to be aliased to avoid a potential conflict.
-    const ALIASED_FIELDS = {
-        ldsRecordTypeId: {
-            kind: Kind$1.FIELD,
-            name: {
-                kind: Kind$1.NAME,
-                value: 'RecordTypeId',
-            },
-            arguments: [
-                {
-                    kind: Kind$1.ARGUMENT,
-                    name: {
-                        kind: Kind$1.NAME,
-                        value: 'fallback',
-                    },
-                    value: {
-                        kind: Kind$1.BOOLEAN,
-                        value: true,
-                    },
-                },
-            ],
-            alias: {
-                kind: Kind$1.NAME,
-                value: 'ldsRecordTypeId',
-            },
-        },
-    };
-    // TODO: export graphql's deepMerge from @luvio/graphql-normalization? Promote to @luvio/utils?
-    function deepMerge$1(target, source) {
-        if (source === null || source === undefined)
-            return target;
-        if (target === null || target === undefined)
-            return source;
-        if (typeof source !== 'object' || typeof target !== 'object') {
-            return source;
-        }
-        if (Array.isArray(source)) {
-            return source;
-        }
-        const result = { ...target };
-        for (const key of Object.keys(source)) {
-            if (key === 'extensions') {
-                // Skip extensions key from final result
-                continue;
-            }
-            if (source[key] !== null &&
-                typeof source[key] === 'object' &&
-                !Array.isArray(source[key])) {
-                result[key] = deepMerge$1(result[key], source[key]);
-            }
-            else {
-                result[key] = source[key];
-            }
-        }
-        return result;
-    }
-    function createFieldNode(name, data) {
-        if (name === '__genericTypename') {
-            return undefined;
-        }
-        const baseField = ALIASED_FIELDS[name] ?? {
-            kind: Kind$1.FIELD,
-            name: {
-                kind: Kind$1.NAME,
-                value: name,
-            },
-        };
-        if (typeof data === 'object' && data !== null && data !== undefined) {
-            if (Array.isArray(data)) {
-                // For arrays, we need to merge the structure from all non-null elements
-                // to capture the full schema, not just the first element
-                let mergedStructure = {};
-                for (const item of data) {
-                    if (item !== null && typeof item === 'object' && !Array.isArray(item)) {
-                        mergedStructure = deepMerge$1(mergedStructure, item);
-                    }
-                }
-                if (Object.keys(mergedStructure).length > 0) {
-                    baseField.selectionSet = {
-                        kind: Kind$1.SELECTION_SET,
-                        selections: Object.entries(mergedStructure)
-                            .map(([key, value]) => createFieldNode(key, value))
-                            .filter((node) => node !== undefined),
-                    };
-                }
-            }
-            else {
-                baseField.selectionSet = {
-                    kind: Kind$1.SELECTION_SET,
-                    selections: Object.entries(data)
-                        .map(([key, value]) => createFieldNode(key, value))
-                        .filter((node) => node !== undefined),
-                };
-            }
-        }
-        return baseField;
-    }
-    function createASTFromExtensions(extensions) {
-        const fieldNodes = Object.entries(extensions)
-            .map(([field, value]) => createFieldNode(field, value))
-            .filter((node) => node !== undefined);
-        return {
-            kind: Kind$1.SELECTION_SET,
-            selections: fieldNodes,
-        };
-    }
-    function mergeASTs(query, extensionsAST) {
-        return {
-            ...query,
-            definitions: query.definitions.map((def) => {
-                if (def.kind === Kind$1.OPERATION_DEFINITION) {
-                    return {
-                        ...def,
-                        selectionSet: {
-                            kind: Kind$1.SELECTION_SET,
-                            selections: [...def.selectionSet.selections, ...extensionsAST.selections],
-                        },
-                    };
-                }
-                return def;
-            }),
-        };
-    }
-    /**
-     * Augments a query with the extensions from a response. The general algorithm is:
-     * 1. Create an AST from just the extensions.
-     * 2. Deep merge the extensions AST into the query AST.
-     * 3. Deep merge the extensions into the response data.
-     * 4. Return the augmented query and response.
-     * @param query - The query to augment.
-     * @param response - The response to augment the query with.
-     * @returns The augmented query and response.
-     */
-    function augmentQueryByResponse(query, response) {
-        const extensions = response.extensions?.lds || {};
-        const extensionsAST = createASTFromExtensions(extensions);
-        const augmentedQuery = mergeASTs(query, extensionsAST);
-        // Deep merge extensions into data, removing extensions key from result
-        const mergedData = deepMerge$1(response.data, extensions);
-        return {
-            query: augmentedQuery,
-            response: {
-                data: mergedData,
-                ...(response.errors && { errors: response.errors }),
-            },
+    function 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]])),
         };
     }
 
@@ -103832,17 +104119,16 @@
             }
             buildWriteInput(data) {
                 this.latestLuvioRecordIdsToInvalidate = [];
-                const baseQuery = this.buildRequestQuery();
-                const { query: augmentedQuery, response: augmentedData } = augmentQueryByResponse(baseQuery, data);
+                const augmentedResponse = mergeResponseWithExtensions(data);
                 const extensionResult = buildGraphQLInputExtension({
                     ...this.config,
-                    query: augmentedQuery,
+                    query: this.buildRequestQuery(),
                 });
                 if (extensionResult.isErr()) {
                     throw new InternalError(extensionResult.error);
                 }
                 return {
-                    data: augmentedData.data,
+                    data: augmentedResponse.data,
                     ...extensionResult.value,
                     luvioRecordIdsToInvalidate: this.latestLuvioRecordIdsToInvalidate,
                 };
@@ -103860,10 +104146,12 @@
                             reader: true,
                             synthetic: true,
                             read: (reader) => {
+                                this.latestUsedRecordIdToWeakEtagMap = {};
                                 readFromCacheResult = this.buildResultType().query(cache, {
                                     ...this.buildQuery(),
                                     reader,
                                     getNormalizedLuvioRecord: this.services.luvioUiapiRecords.getNormalizedLuvioRecord,
+                                    usedRecordIdToWeakEtagMap: this.latestUsedRecordIdToWeakEtagMap,
                                 });
                                 return readFromCacheResult;
                             },
@@ -103898,7 +104186,7 @@
                             synthetic: true,
                             read: (reader) => {
                                 if (networkResult.isOk()) {
-                                    const x = this.buildResultType().write(cache.buildFixedTimeWritableCache(Date.now() / 1000), {
+                                    return this.buildResultType().write(cache.buildFixedTimeWritableCache(Date.now() / 1000), {
                                         ...this.buildWriteInput(networkResult.value),
                                         reader,
                                         getNormalizedLuvioRecord: this.services.luvioUiapiRecords
@@ -103912,19 +104200,23 @@
                 }
                 catch (error) {
                     // swallow error
-                    console.error(error);
                 }
                 return resolvedPromiseLike(undefined);
             }
-            execute() {
+            execute(overrides) {
+                this.services.instrumentation?.metrics
+                    .getMeter('onestore')
+                    .createCounter(`graphql.execute.count`)
+                    .add(1);
                 // Clear snapshot and unsubscribe from any existing subscriptions at the beginning of execute calls
                 this.latestLuvioSnapshot = undefined;
                 this.latestLuvioRecordIdsToInvalidate = undefined;
+                this.latestUsedRecordIdToWeakEtagMap = undefined;
                 if (this.unsubscribeFromLuvioSnapshot) {
                     this.unsubscribeFromLuvioSnapshot();
                     this.unsubscribeFromLuvioSnapshot = undefined;
                 }
-                const result = super.execute();
+                const result = super.execute(overrides);
                 result.then((_) => {
                     if (this.latestLuvioRecordIdsToInvalidate &&
                         this.latestLuvioRecordIdsToInvalidate.length > 0) {
@@ -103933,6 +104225,13 @@
                 });
                 return result;
             }
+            runOriginalRequest() {
+                this.services.instrumentation?.metrics
+                    .getMeter('onestore')
+                    .createCounter(`graphql.fallback.count`)
+                    .add(1);
+                return super.runOriginalRequest();
+            }
             subscribeToKeysUsed() {
                 super.subscribeToKeysUsed();
                 // Subscribe to luvio cache changes using the stored snapshot
@@ -103943,12 +104242,48 @@
                         // 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();
+                            if (this.usedRecordsChanged()) {
+                                this.refresh();
+                            }
                         });
                     }
                     catch (error) { }
                 }
             }
+            usedRecordsChanged() {
+                if (!this.latestUsedRecordIdToWeakEtagMap ||
+                    Object.keys(this.latestUsedRecordIdToWeakEtagMap).length === 0) {
+                    return false;
+                }
+                const luvioService = this.services.luvio;
+                const luvioInstance = luvioService.luvio;
+                let dataChanged = false;
+                luvioInstance.storeLookup({
+                    recordId: 'onestore-graphql',
+                    node: {
+                        kind: 'Fragment',
+                        reader: true,
+                        synthetic: true,
+                        read: (reader) => {
+                            if (this.latestUsedRecordIdToWeakEtagMap) {
+                                Object.entries(this.latestUsedRecordIdToWeakEtagMap).forEach(([recordId, oneStoreRecordWeakEtag]) => {
+                                    const normalizedLuvioRecord = this.services.luvioUiapiRecords.getNormalizedLuvioRecord(recordId, reader);
+                                    if (!normalizedLuvioRecord) {
+                                        return;
+                                    }
+                                    const luvioRecordWeakEtag = normalizedLuvioRecord.weakEtag;
+                                    if (luvioRecordWeakEtag !== oneStoreRecordWeakEtag) {
+                                        dataChanged = true;
+                                    }
+                                });
+                            }
+                            return {};
+                        },
+                    },
+                    variables: {},
+                });
+                return dataChanged;
+            }
         };
     }
 
@@ -103995,6 +104330,11 @@
             type: 'luvioUiapiRecords',
             version: '1.0',
         },
+        instrumentation: {
+            type: 'instrumentation',
+            version: '1.0',
+            optional: true,
+        },
     };
     let provisionedCallback;
     getServices(serviceRequirements).then((services) => {
@@ -104005,7 +104345,7 @@
             constructor() {
                 super(...arguments);
                 this.configSchema = CONFIG_SCHEMA;
-                this.exposeRefresh = false;
+                this.exposeRefresh = true;
             }
             getCommand() {
                 return new graphql_ctor({ ...this.config, query: resolveAst(this.config.query) }, documentRootType, services);
@@ -104030,7 +104370,7 @@
             cb(graphql$1, graphql_imperative$1, useOneStoreGraphQL);
         }
     }
-    // version: 1.377.1-db77d3f339
+    // version: 1.379.0-a57c798add
 
     function createFragmentMap(documentNode) {
         const fragments = {};
@@ -130525,7 +130865,7 @@
         }
         return refresh$3(data, 'refreshUiApi');
     }
-    // version: 1.377.1-db77d3f339
+    // version: 1.379.0-a57c798add
 
     // On core the unstable adapters are re-exported with different names,
     // we want to match them here.
@@ -130677,7 +131017,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.377.1-db77d3f339
+    // version: 1.379.0-a57c798add
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -131476,7 +131816,7 @@
     function register(r) {
         callbacks$1.forEach((callback) => callback(r));
     }
-    // version: 1.377.1-dadb6358f3
+    // version: 1.379.0-fc97fd9203
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -132813,4 +133153,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.377.1-dadb6358f3
+// version: 1.379.0-fc97fd9203