@salesforce/lds-worker-api 1.377.1 → 1.379.0

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

@@ -4274,7 +4274,7 @@ function withDefaultLuvio(callback) {
     }
     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) {
@@ -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.1-dadb6358f3
+// version: 1.379.0-fc97fd9203
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -34154,7 +34154,7 @@ withDefaultLuvio((luvio) => {
     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) {
@@ -45764,15 +45764,6 @@ var graphqlL2AdapterGate = {
     },
 };
 
-var productConsumedSideEffects = {
-    isOpen: function (e) {
-        return e.fallback;
-    },
-    hasError: function () {
-        return !0;
-    },
-};
-
 var useOneStore = {
     isOpen: function (e) {
         return e.fallback;
@@ -46117,6 +46108,15 @@ function buildReadWriteResult(data, errors) {
   return ok$4(data);
 }
 
+var productConsumedSideEffects = {
+    isOpen: function (e) {
+        return e.fallback;
+    },
+    hasError: function () {
+        return !0;
+    },
+};
+
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -87029,9 +87029,9 @@ function injectFilter(filterNode, idState, parentPath, isParentPolymorphic, obje
                         }
                         // spanning field needs to have the directive with 'parentRelationship'
                         const directives = isSpanning && !isInlineFragment ? [parentRelationshipDirective] : [];
-                        let idField = isSpanning && !isPolymorphicField ? [createFieldNode$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]];
@@ -87077,7 +87077,7 @@ function injectFilter(filterNode, idState, parentPath, isParentPolymorphic, obje
                                 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 ||
@@ -87144,7 +87144,7 @@ function injectFilter(filterNode, idState, parentPath, isParentPolymorphic, obje
                                     .filter(isFieldNode)
                                     .filter((subNode) => subNode.name.value === relationField);
                             if (!existingRelationFields || existingRelationFields.length === 0) {
-                                injectedSelections.push(createFieldNode$1(relationField, FieldValueNodeSelectionSet));
+                                injectedSelections.push(createFieldNode(relationField, FieldValueNodeSelectionSet));
                             }
                         }
                     }
@@ -87235,7 +87235,7 @@ function produceValueFieldLeaves(queryNode) {
             .filter(isFieldNode)
             .filter((subNode) => subNode.name.value === 'value');
     return !existingValueFields || existingValueFields.length === 0
-        ? [createFieldNode$1('value')]
+        ? [createFieldNode('value')]
         : [];
 }
 function updateIDInfo(fieldNode, idState, draftFunctions) {
@@ -87316,20 +87316,20 @@ function injectParentRelationships(selections, parentNode, parentPath, ancestors
                     .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) {
@@ -87373,7 +87373,7 @@ function injectFieldsForDisplayValue(topNode, apiName, objectInfos) {
             objectInfo.nameFields !== undefined &&
             objectInfo.nameFields.length > 0) {
             displayValueNameFields = objectInfo.nameFields.map((fieldName) => {
-                return createFieldNode$1(fieldName, FieldValueNodeSelectionSet);
+                return createFieldNode(fieldName, FieldValueNodeSelectionSet);
             });
         }
     }
@@ -87404,7 +87404,7 @@ function injectFields(selections, parentNode, parentPath, ancestors, objectInfos
         if (parentNode.name.value === 'node') {
             const idNode = findIdFieldNode(parentNode);
             if (idNode === false) {
-                rootQueryIdField.push(createFieldNode$1('Id'));
+                rootQueryIdField.push(createFieldNode('Id'));
             }
         }
         // example { node { Id } }. The operation happens at the 'edges' -> 'node'  level of the 'childRelationship' field
@@ -87432,7 +87432,7 @@ function injectFields(selections, parentNode, parentPath, ancestors, objectInfos
                             .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));
                     }
@@ -87884,7 +87884,7 @@ function referenceIdFieldForRelationship(relationshipName) {
  * @param selectionSet
  * @returns
  */
-function createFieldNode$1(nameValue, selectionSet) {
+function createFieldNode(nameValue, selectionSet) {
     return {
         kind: Kind$3.FIELD,
         name: {
@@ -95881,7 +95881,7 @@ function buildServiceDescriptor$5(luvio) {
         },
     };
 }
-// version: 1.377.1-db77d3f339
+// version: 1.379.0-a57c798add
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -95907,7 +95907,7 @@ function buildServiceDescriptor$4(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.377.1-db77d3f339
+// version: 1.379.0-a57c798add
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -98023,7 +98023,7 @@ register$1({
     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;
@@ -98887,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) {
@@ -99101,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);
@@ -99169,7 +99402,11 @@ class BaseGraphQLTypeRepository {
   }
   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({
@@ -99195,7 +99432,11 @@ class BaseGraphQLTypeRepository {
     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({
@@ -99308,10 +99549,7 @@ class BaseGraphQLTypeRepository {
     };
   }
   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",
@@ -99442,10 +99680,7 @@ class BaseGraphQLTypeRepository {
     };
   }
   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",
@@ -99465,32 +99700,46 @@ 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);
+  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;
@@ -99849,245 +100098,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: {
@@ -100388,10 +100398,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);
@@ -100400,6 +100410,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 {
@@ -100446,10 +100468,11 @@ class GraphQLCommandWireAdapterConstructor extends CommandWireAdapterConstructor
   }
 }
 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);
       }
@@ -100458,11 +100481,12 @@ function buildAsyncGraphQLImperativeLegacyInvoker(getCommand) {
       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;
@@ -100478,7 +100502,10 @@ function buildAsyncGraphQLImperativeLegacyInvoker(getCommand) {
   };
   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) {
@@ -100690,7 +100717,14 @@ class AnyTypeRepository extends BaseUnionRepository {
         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,
@@ -100698,11 +100732,6 @@ class AnyTypeRepository extends BaseUnionRepository {
             StringValue: this.typeRegistry.StringValue,
         };
     }
-    get fields() {
-        return {
-            __typename: new BaseScalarFieldDef(false),
-        };
-    }
 }
 
 class Base64ValueRepository extends UnidentifiableGraphQLTypeRepository {
@@ -101635,7 +101664,7 @@ class PicklistValueRepository extends UnidentifiableGraphQLTypeRepository {
     }
 }
 
-class PolymorphicAggregateParentRelationshipRepository extends BaseUnionRepository {
+let PolymorphicAggregateParentRelationshipRepository$1 = class PolymorphicAggregateParentRelationshipRepository extends BaseUnionRepository {
     constructor(services, typeRegistry) {
         super(services);
         this.services = services;
@@ -101643,18 +101672,20 @@ class PolymorphicAggregateParentRelationshipRepository extends BaseUnionReposito
         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;
@@ -101662,16 +101693,18 @@ class PolymorphicParentRelationshipRepository extends BaseUnionRepository {
         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) {
@@ -101695,7 +101728,7 @@ class QueryRepository extends GraphQLDocumentRootTypeRepository {
     }
 }
 
-class RecordAggregateConnectionRepository extends UnidentifiableGraphQLTypeRepository {
+let RecordAggregateConnectionRepository$1 = class RecordAggregateConnectionRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
         super(services);
         this.services = services;
@@ -101712,9 +101745,9 @@ class RecordAggregateConnectionRepository extends UnidentifiableGraphQLTypeRepos
             totalCount: new BaseScalarFieldDef(false),
         };
     }
-}
+};
 
-class RecordAggregateEdgeRepository extends UnidentifiableGraphQLTypeRepository {
+let RecordAggregateEdgeRepository$1 = class RecordAggregateEdgeRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
         super(services);
         this.services = services;
@@ -101730,7 +101763,7 @@ class RecordAggregateEdgeRepository extends UnidentifiableGraphQLTypeRepository
             cursor: new BaseScalarFieldDef(false),
         };
     }
-}
+};
 
 let RecordAggregateRepository$1 = class RecordAggregateRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
@@ -101768,7 +101801,7 @@ let RecordAggregateRepository$1 = class RecordAggregateRepository extends Uniden
     }
 };
 
-class RecordConnectionRepository extends UnidentifiableGraphQLTypeRepository {
+let RecordConnectionRepository$1 = class RecordConnectionRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
         super(services);
         this.services = services;
@@ -101786,9 +101819,9 @@ class RecordConnectionRepository extends UnidentifiableGraphQLTypeRepository {
             pageResultCount: new BaseScalarFieldDef(false),
         };
     }
-}
+};
 
-class RecordEdgeRepository extends UnidentifiableGraphQLTypeRepository {
+let RecordEdgeRepository$1 = class RecordEdgeRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
         super(services);
         this.services = services;
@@ -101804,7 +101837,7 @@ class RecordEdgeRepository extends UnidentifiableGraphQLTypeRepository {
             cursor: new BaseScalarFieldDef(false),
         };
     }
-}
+};
 
 let RecordQueryAggregateRepository$1 = class RecordQueryAggregateRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
@@ -101899,7 +101932,7 @@ let RecordRepresentationRepository$1 = class RecordRepresentationRepository exte
     }
 };
 
-class RecordResultRepository extends UnidentifiableGraphQLTypeRepository {
+let RecordResultRepository$1 = class RecordResultRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
         super(services);
         this.services = services;
@@ -101914,7 +101947,7 @@ class RecordResultRepository extends UnidentifiableGraphQLTypeRepository {
             aggregate: new BaseObjectFieldDef(this.typeRegistry.RecordAggregate, true),
         };
     }
-}
+};
 
 class RecordTypeInfoRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
@@ -102337,15 +102370,17 @@ class Setup__SetupPolymorphicAggregateParentRelationshipRepository extends BaseU
         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 {
@@ -102356,15 +102391,17 @@ class Setup__SetupPolymorphicParentRelationshipRepository extends BaseUnionRepos
         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 {
@@ -102709,15 +102746,15 @@ 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 =
             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);
@@ -102747,13 +102784,13 @@ class GraphQLTypeRegistry {
         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 =
@@ -103213,8 +103250,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([
@@ -103228,6 +103263,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) {
@@ -103252,6 +103290,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) {
@@ -103270,7 +103311,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) {
@@ -103300,9 +103340,19 @@ class RecordRepresentationBaseRepository extends BaseGraphQLTypeRepository {
             '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 {
@@ -103322,7 +103372,30 @@ class RecordRepresentationRepository extends RecordRepresentationRepository$1 {
         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 &&
@@ -103334,13 +103407,18 @@ class RecordRepresentationRepository extends RecordRepresentationRepository$1 {
     }
     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;
     }
@@ -103433,6 +103511,16 @@ class CompoundFieldRepository extends CompoundFieldRepository$1 {
     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 {
@@ -103454,6 +103542,16 @@ class RecordAggregateRepository extends RecordAggregateRepository$1 {
     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 {
@@ -103468,12 +103566,12 @@ class RecordQueryAggregateRepository extends RecordQueryAggregateRepository$1 {
     }
 }
 
+// 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) => {
@@ -103541,6 +103639,16 @@ class SetupEntityRepresentationRepository extends UnidentifiableGraphQLTypeRepos
         // 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 {
@@ -103578,27 +103686,262 @@ class SetupRecordAggregateRepository extends Setup__SetupRecordAggregateReposito
         }
         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;
     }
@@ -103608,167 +103951,111 @@ class CustomGraphQLTypeRegistry extends GraphQLTypeRegistry {
     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]])),
     };
 }
 
@@ -103826,17 +104113,16 @@ function buildCommandClass(baseClass) {
         }
         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,
             };
@@ -103854,10 +104140,12 @@ function buildCommandClass(baseClass) {
                         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;
                         },
@@ -103892,7 +104180,7 @@ function buildCommandClass(baseClass) {
                         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
@@ -103906,19 +104194,23 @@ function buildCommandClass(baseClass) {
             }
             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) {
@@ -103927,6 +104219,13 @@ function buildCommandClass(baseClass) {
             });
             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
@@ -103937,12 +104236,48 @@ function buildCommandClass(baseClass) {
                     // 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;
+        }
     };
 }
 
@@ -103989,6 +104324,11 @@ const serviceRequirements = {
         type: 'luvioUiapiRecords',
         version: '1.0',
     },
+    instrumentation: {
+        type: 'instrumentation',
+        version: '1.0',
+        optional: true,
+    },
 };
 let provisionedCallback;
 getServices(serviceRequirements).then((services) => {
@@ -103999,7 +104339,7 @@ getServices(serviceRequirements).then((services) => {
         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);
@@ -104024,7 +104364,7 @@ function registerCallback(cb) {
         cb(graphql$1, graphql_imperative$1, useOneStoreGraphQL);
     }
 }
-// version: 1.377.1-db77d3f339
+// version: 1.379.0-a57c798add
 
 function createFragmentMap(documentNode) {
     const fragments = {};
@@ -130519,7 +130859,7 @@ function refreshGraphQL(data) {
     }
     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.
@@ -130671,7 +131011,7 @@ withDefaultLuvio((luvio) => {
     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,
@@ -131470,7 +131810,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.377.1-dadb6358f3
+// version: 1.379.0-fc97fd9203
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -132786,4 +133126,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.1-dadb6358f3
+// version: 1.379.0-fc97fd9203