@salesforce/lds-worker-api 1.378.0 → 1.379.1

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

@@ -4280,7 +4280,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.378.0-0ab3d40d29
+    // version: 1.379.1-5350e195b2
 
     // 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.378.0-0ab3d40d29
+    // version: 1.379.1-5350e195b2
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -34160,7 +34160,7 @@
         throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
         throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
     });
-    // version: 1.378.0-63d7c07562
+    // version: 1.379.1-7ea94edc38
 
     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;
@@ -45808,7 +45799,7 @@
         return !this.isOk();
       }
     };
-    let Err$4 = class Err {
+    let Err$3 = class Err {
       constructor(error) {
         this.error = error;
       }
@@ -45820,7 +45811,7 @@
       }
     };
     const ok$4 = (value) => new Ok$4(value);
-    const err$4 = (err2) => new Err$4(err2);
+    const err$3 = (err2) => new Err$3(err2);
     function resolvedPromiseLike$5(result) {
       if (isPromiseLike$5(result)) {
         return result.then((nextResult) => nextResult);
@@ -46051,7 +46042,7 @@
         const existingNormalizedData = (_a = cache.get(key)) == null ? void 0 : _a.value;
         const normalized = this.normalizeData(cache, { ...input, existingNormalizedData });
         if (normalized.isErr()) {
-          return err$4(normalized.error);
+          return err$3(normalized.error);
         }
         cache.set(key, {
           value: normalized.value,
@@ -46064,7 +46055,7 @@
       }
       validateEntry(entry) {
         if (!isCacheEntryForType(entry, this)) {
-          return err$4([
+          return err$3([
             {
               type: "incorrectType",
               expectedType: this.typeName,
@@ -46090,12 +46081,12 @@
         if (cacheEntry) {
           const validationResult = this.validateEntry(cacheEntry);
           if (validationResult.isErr()) {
-            return err$4([...validationResult.error]);
+            return err$3([...validationResult.error]);
           }
           const normalizedData = cacheEntry.value;
           return this.denormalizeData(cache, { ...input, normalizedData });
         }
-        return err$4([this.buildMissingDataError()]);
+        return err$3([this.buildMissingDataError()]);
       }
       equals(x, y) {
         return deepEquals$2(x, y);
@@ -46118,11 +46109,20 @@
     }
     function buildReadWriteResult(data, errors) {
       if (errors.length > 0) {
-        return err$4(errors);
+        return err$3(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.
@@ -94154,7 +94154,7 @@
         return !this.isOk();
       }
     };
-    let Err$3 = class Err {
+    let Err$2 = class Err {
       constructor(error) {
         this.error = error;
       }
@@ -94166,7 +94166,7 @@
       }
     };
     const ok$3 = (value) => new Ok$3(value);
-    const err$3 = (err2) => new Err$3(err2);
+    const err$2 = (err2) => new Err$2(err2);
     function resolvedPromiseLike$2(result) {
       if (isPromiseLike$2(result)) {
         return result.then((nextResult) => nextResult);
@@ -94266,7 +94266,7 @@
         const resultPromise = this.readFromCacheInternal(cache);
         return resultPromise.then((result) => {
           if (result.isErr()) {
-            return err$3(result.error);
+            return err$2(result.error);
           }
           this.returnData = result;
           return ok$3(void 0);
@@ -94325,7 +94325,7 @@
             if (networkData) {
               return this.constructSubscribableResult(networkData.value);
             }
-            return err$3(result.error);
+            return err$2(result.error);
           }
           if (this.subscriptions.length > 0) {
             this.subscribeToKeysUsed();
@@ -94334,7 +94334,7 @@
             if (networkData) {
               return this.constructSubscribableResult(networkData.value);
             }
-            return err$3(new Error("Cache miss after fetching from network"));
+            return err$2(new Error("Cache miss after fetching from network"));
           }
           if (returnData.isOk() && this.lastEmittedData === void 0) {
             this.lastEmittedData = returnData.value.data;
@@ -94397,7 +94397,7 @@
       refresh() {
         return this.rerun({ cacheControlConfig: { type: "no-cache" } }).then((result) => {
           if (result.isErr()) {
-            return err$3(result.error);
+            return err$2(result.error);
           }
           return ok$3(void 0);
         });
@@ -94415,7 +94415,7 @@
         const result = this.readFromCache(recordableCache);
         return result.then((readResult) => {
           if (readResult.isErr()) {
-            return err$3(readResult.error);
+            return err$2(readResult.error);
           } else {
             const data = readResult.value;
             this.keysUsed = recordableCache.keysRead;
@@ -95887,7 +95887,7 @@
             },
         };
     }
-    // version: 1.378.0-63d7c07562
+    // version: 1.379.1-7ea94edc38
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -95913,7 +95913,7 @@
             },
         };
     }
-    // version: 1.378.0-63d7c07562
+    // version: 1.379.1-7ea94edc38
 
     /*!
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -98029,7 +98029,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$2,
     });
-    // version: 1.378.0-0ab3d40d29
+    // version: 1.379.1-5350e195b2
 
     const { create: create$3, keys: keys$3 } = Object;
     const { stringify: stringify$1, parse } = JSON;
@@ -98058,7 +98058,7 @@
         return !this.isOk();
       }
     };
-    let Err$2 = class Err {
+    let Err$1 = class Err {
       constructor(error) {
         this.error = error;
       }
@@ -98070,7 +98070,7 @@
       }
     };
     const ok$2 = (value) => new Ok$2(value);
-    const err$2 = (err2) => new Err$2(err2);
+    const err$1 = (err2) => new Err$1(err2);
     function deepEquals(x, y) {
       if (x === void 0) {
         return y === void 0;
@@ -98145,7 +98145,7 @@
         this.errors.unshift(error);
       }
       toValidationResponse() {
-        return !this.hasErrors() ? ok$2(true) : err$2(this.errors);
+        return !this.hasErrors() ? ok$2(true) : err$1(this.errors);
       }
     }
     function createThrowableError(errors) {
@@ -98184,7 +98184,7 @@
       return ok$2(true);
     }
     function invalidSchemaResponseWithError(error) {
-      return err$2([error]);
+      return err$1([error]);
     }
     function validateJsonSchema(data, schema, path = "$", document = schema) {
       if (schema === true) return validSchemaResponse();
@@ -98883,7 +98883,7 @@
     function extractVariableValue(variableName, variableDefinitions) {
       const variable = variableDefinitions[variableName];
       if (!variable) {
-        return err$4(
+        return err$3(
           new Error(`Variable '${variableName}' was used in the query but was not defined`)
         );
       }
@@ -98903,7 +98903,7 @@
         if (expectedType.nullable) {
           return ok$4(value);
         } else {
-          return err$4(new Error(`Expected ${expectedType.type}, but got null`));
+          return err$3(new Error(`Expected ${expectedType.type}, but got null`));
         }
       }
       const actualType = typeof value;
@@ -98911,7 +98911,7 @@
         return ok$4(value);
       }
       const expectedTypeString = expectedType.nullable ? `${expectedType.type} | null` : expectedType.type;
-      return err$4(
+      return err$3(
         new Error(`Expected ${expectedTypeString}, but got ${actualType}: ${JSON.stringify(value)}`)
       );
     }
@@ -98954,7 +98954,7 @@
         (def) => def.kind === Kind.OPERATION_DEFINITION
       );
       if (operations.length === 0) {
-        return err$4(new Error("No operations found in query"));
+        return err$3(new Error("No operations found in query"));
       }
       if (operations.length === 1 && !input.operationName) {
         return ok$4(operations[0]);
@@ -98967,14 +98967,14 @@
         if (specifiedOperation) {
           return ok$4(specifiedOperation);
         }
-        return err$4(new Error(`Operation "${input.operationName}" not found in query`));
+        return err$3(new Error(`Operation "${input.operationName}" not found in query`));
       }
-      return err$4(new Error("Multiple operations found in query, and no operation name provided"));
+      return err$3(new Error("Multiple operations found in query, and no operation name provided"));
     }
     function buildGraphQLInputExtension(input) {
       const operationResult = findExecutableOperation(input);
       if (operationResult.isErr()) {
-        return err$4(operationResult.error);
+        return err$3(operationResult.error);
       }
       const operation = operationResult.value;
       const selections = operation.selectionSet.selections;
@@ -99055,7 +99055,7 @@
       for (const arg of fieldArguments) {
         const result = extractValue(arg.value, variables);
         if (result.isErr()) {
-          return err$4(
+          return err$3(
             new Error(
               `Failed to extract argument '${arg.name.value}' for field '${canonicalFieldName}': ${result.error.message}`
             )
@@ -99069,11 +99069,11 @@
       var _a;
       const ifArg = (_a = directive.arguments) == null ? void 0 : _a.find((arg) => arg.name.value === "if");
       if (!ifArg) {
-        return err$4(new Error(`@${directiveName} directive requires an 'if' argument`));
+        return err$3(new Error(`@${directiveName} directive requires an 'if' argument`));
       }
       const result = extractValue(ifArg.value, variables, { type: "boolean", nullable: false });
       if (result.isErr()) {
-        return err$4(result.error);
+        return err$3(result.error);
       }
       return ok$4(result.value);
     }
@@ -99113,7 +99113,7 @@
         }
         if (input.data === null) {
           if (!this.nullable) {
-            return err$4([
+            return err$3([
               {
                 type: "unknown",
                 error: new Error(
@@ -99156,7 +99156,7 @@
         }
         if (input.data === null) {
           if (!this.nullable) {
-            return err$4([
+            return err$3([
               {
                 type: "unknown",
                 error: new Error(
@@ -99168,7 +99168,7 @@
           return ok$4({ type: "data", data: input.data });
         }
         if (!Array.isArray(input.data)) {
-          return err$4([
+          return err$3([
             {
               type: "unknown",
               error: new Error(
@@ -99196,7 +99196,7 @@
           }
         });
         if (arrayNormalizationErrors.length > 0) {
-          return err$4(arrayNormalizationErrors);
+          return err$3(arrayNormalizationErrors);
         }
         return ok$4({ type: "data", data: normalizedArray });
       }
@@ -99207,7 +99207,7 @@
         }
         if (normalizedData.data === null) {
           if (!this.nullable) {
-            return err$4([
+            return err$3([
               {
                 type: "unknown",
                 error: new Error(
@@ -99219,7 +99219,7 @@
           return ok$4({ type: "data", data: null });
         }
         if (!Array.isArray(normalizedData.data)) {
-          return err$4([
+          return err$3([
             {
               type: "unknown",
               error: new Error(
@@ -99244,7 +99244,7 @@
           }
         });
         if (arrayDenormalizationErrors.length > 0) {
-          return err$4(arrayDenormalizationErrors);
+          return err$3(arrayDenormalizationErrors);
         }
         return ok$4(denormalizedArray);
       }
@@ -99263,7 +99263,7 @@
       write(cache, input) {
         var _a;
         if (!input.selection.selectionSet) {
-          return err$4([
+          return err$3([
             {
               type: "unknown",
               error: new Error(
@@ -99277,7 +99277,7 @@
         }
         if (input.data === null) {
           if (!this.nullable) {
-            return err$4([
+            return err$3([
               {
                 type: "unknown",
                 error: new Error(
@@ -99304,7 +99304,7 @@
       read(cache, input) {
         var _a;
         if (!input.selection.selectionSet) {
-          return err$4([
+          return err$3([
             {
               type: "unknown",
               error: new Error(
@@ -99319,7 +99319,7 @@
         }
         if (normalizedData.data === null) {
           if (!this.nullable) {
-            return err$4([
+            return err$3([
               {
                 type: "unknown",
                 error: new Error(
@@ -99408,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({
@@ -99434,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({
@@ -99547,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",
@@ -99605,7 +99610,7 @@
         var _a;
         const fieldDef = this.getFieldDef(input, selection);
         if (!fieldDef) {
-          return err$4(
+          return err$3(
             new Error(
               `Unknown field "${selection.name.value}" on type "${this.typeName}". Expected one of fields ${Object.keys(this.fields)}.`
             )
@@ -99616,7 +99621,7 @@
           input.request.definitions.variables
         );
         if (cacheFieldKeyResult.isErr()) {
-          return err$4(cacheFieldKeyResult.error);
+          return err$3(cacheFieldKeyResult.error);
         }
         const cacheFieldKey = cacheFieldKeyResult.value;
         return ok$4((_a = input.existingNormalizedData || input.normalizedData) == null ? void 0 : _a[cacheFieldKey]);
@@ -99681,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",
@@ -99722,28 +99724,28 @@
         }
         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;
@@ -99801,7 +99803,7 @@
         const key = this.buildKey(this.buildKeyParams(input));
         const normalized = this.normalizeData(cache, input);
         if (normalized.isErr()) {
-          return err$4(normalized.error);
+          return err$3(normalized.error);
         }
         const existing = cache.get(key);
         if (!deepEquals$2(existing == null ? void 0 : existing.value, normalized.value)) {
@@ -99890,7 +99892,7 @@
         var _a;
         const operationResult = findExecutableOperation(input);
         if (operationResult.isErr()) {
-          return err$4(operationResult.error);
+          return err$3(operationResult.error);
         }
         const operation = operationResult.value;
         const fragmentDefinitions = input.query.definitions.filter(
@@ -99948,7 +99950,7 @@
       }
       write(cache, input) {
         if (typeof input.data !== "object") {
-          return err$4([
+          return err$3([
             {
               type: "unknown",
               error: new Error(`Got a non-object value for ${this.typeName} field"`)
@@ -99958,7 +99960,7 @@
         const discriminator = this.getTypeDiscriminator(input.data, input.selections);
         const concreteTypeRepository = this.possibleTypes[discriminator];
         if (!concreteTypeRepository) {
-          return err$4([
+          return err$3([
             {
               type: "unknown",
               error: new Error(
@@ -99969,7 +99971,7 @@
         }
         const selectionErr = this.verifyUnionFields(input.selections);
         if (selectionErr) {
-          return err$4(selectionErr);
+          return err$3(selectionErr);
         }
         const normalizeInput = {
           ...input,
@@ -99988,7 +99990,7 @@
       read(cache, input) {
         const unionRep = input.normalizedData;
         if (typeof unionRep.data !== "object" || unionRep.data === null) {
-          return err$4([
+          return err$3([
             {
               type: "unknown",
               error: new Error(`Got a non-object value for ${this.typeName} field.`)
@@ -99998,7 +100000,7 @@
         const discriminator = unionRep.discriminator;
         const concreteRepository = this.possibleTypes[discriminator];
         if (!concreteRepository) {
-          return err$4([
+          return err$3([
             {
               type: "unknown",
               error: new Error(
@@ -100009,7 +100011,7 @@
         }
         const selectionErr = this.verifyUnionFields(input.selections);
         if (selectionErr) {
-          return err$4(selectionErr);
+          return err$3(selectionErr);
         }
         const denormalizeInput = {
           ...input,
@@ -100146,19 +100148,7 @@
         return !this.isOk();
       }
     };
-    let Err$1 = class Err {
-      constructor(error) {
-        this.error = error;
-      }
-      isOk() {
-        return false;
-      }
-      isErr() {
-        return !this.isOk();
-      }
-    };
     const ok$1 = (value) => new Ok$1(value);
-    const err$1 = (err2) => new Err$1(err2);
     function isSubscribableResult(x) {
       if (typeof x !== "object" || x === null) {
         return false;
@@ -100291,41 +100281,50 @@
           if (result === void 0) {
             this.callback({ data: void 0, error: void 0 });
           } else {
-            if (result.isErr()) {
-              this.callback({
-                data: void 0,
-                error: result.error
-              });
-              return;
-            }
-            if (isSubscribableResult(result)) {
-              deepFreeze(result.value.data);
-              if (this.exposeRefresh) {
-                this.callback({
-                  data: result.value.data,
-                  error: void 0,
-                  refresh: () => {
-                    return result.value.refresh().then((res) => {
-                      if (res.isOk()) {
-                        return ok$1(void 0);
-                      }
-                      throw res.error;
-                    });
+            const consumerEmittedRefresh = () => {
+              if (!this.refresh) {
+                return Promise.resolve();
+              }
+              return new Promise((resolve, reject) => {
+                if (!this.refresh) {
+                  resolve();
+                  return;
+                }
+                this.refresh().then((res) => {
+                  if (res.isOk()) {
+                    resolve();
+                  } else {
+                    reject(
+                      new Error(
+                        "Internal error in Lightning Data Service adapter occurred: Failed to refresh data"
+                      )
+                    );
                   }
                 });
+              });
+            };
+            let consumerEmittedData = {
+              data: void 0,
+              error: void 0
+            };
+            if (this.exposeRefresh && this.refresh) {
+              consumerEmittedData.refresh = consumerEmittedRefresh;
+            }
+            if (result.isErr()) {
+              consumerEmittedData.error = result.error;
+            } else {
+              if (isSubscribableResult(result)) {
+                deepFreeze(result.value.data);
+                consumerEmittedData.data = result.value.data;
               } else {
-                this.callback({ data: result.value.data, error: void 0 });
+                deepFreeze(result.value);
+                consumerEmittedData.data = result.value;
               }
-              return;
             }
-            deepFreeze(result.value);
-            this.callback({
-              data: result.value,
-              error: void 0
-            });
+            this.callback(consumerEmittedData);
           }
         } catch (e) {
-          emitError(this.callback, e);
+          this.handleExecutionThrow(e);
         }
       }
       invokeAdapter() {
@@ -100335,11 +100334,11 @@
         if (this.configSchema) {
           try {
             assertIsValid(this.config, this.configSchema);
-          } catch (err2) {
-            if (isIncompleteConfigError(err2)) {
+          } catch (err) {
+            if (isIncompleteConfigError(err)) {
               return;
             }
-            throw err2;
+            throw err;
           }
         }
         const initialConfig = this.config;
@@ -100349,10 +100348,10 @@
             if (!this.connected || this.config !== initialConfig) {
               return;
             }
-            this.emit(result);
+            this.refresh = void 0;
             if (result.isOk()) {
-              const value = result.value;
-              if (typeof value === "object" && value !== null && "subscribe" in value) {
+              if (isSubscribableResult(result)) {
+                const value = result.value;
                 this.unsubscriber = value.subscribe((updatedResult) => {
                   if (!this.connected || this.config !== initialConfig) {
                     this.unsubscribe();
@@ -100360,10 +100359,15 @@
                   }
                   this.emit(updatedResult);
                 });
+                this.refresh = value.refresh;
+                this.emit(ok$1(value.data));
+              } else {
+                this.emit(result);
               }
             } else {
               this.unsubscriber = () => {
               };
+              this.emit(result);
             }
           });
         } catch (e) {
@@ -100380,87 +100384,76 @@
         }
       }
     }
-    function isIncompleteConfigError(err2) {
-      return err2 instanceof MissingRequiredPropertyError || err2 instanceof JsonSchemaViolationError && err2.validationErrors.find(
+    function isIncompleteConfigError(err) {
+      return err instanceof MissingRequiredPropertyError || err instanceof JsonSchemaViolationError && err.validationErrors.find(
         (validationError) => validationError instanceof MissingRequiredPropertyError
       ) !== void 0;
     }
-    function emitGraphQLResult(callback, result) {
-      if (result.isErr()) {
-        logError(result.error);
-        if (isUserVisibleError(result.error)) {
-          callback({
-            data: result.error.data.data,
-            errors: result.error.data.errors
-          });
-          return;
-        }
-        callback({
-          data: void 0,
-          errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
-        });
-        return;
-      }
-      if ("subscribe" in result.value) {
-        callback(formatGraphQLData(result.value.data));
-        return;
-      }
-      callback(formatGraphQLData(result.value));
-    }
-    function resolveAst(ast) {
-      const result = astResolver(ast);
-      if (result === void 0) {
-        throw new Error("Could not resolve AST. Did you parse the query with gql?");
-      }
-      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 {
           if (result === void 0) {
             this.callback({ data: void 0, errors: void 0 });
           } else {
-            if (result.isErr()) {
-              emitGraphQLResult(this.callback, result);
-              return;
-            }
-            const userEmittedData = {
-              ...result.value.data
-            };
-            if (this.exposeRefresh) {
-              userEmittedData.refresh = () => {
-                return result.value.refresh().then((res) => {
+            const consumerEmittedRefresh = () => {
+              if (!this.refresh) {
+                return Promise.resolve();
+              }
+              return new Promise((resolve, reject) => {
+                if (!this.refresh) {
+                  resolve();
+                  return;
+                }
+                this.refresh().then((res) => {
                   if (res.isOk()) {
-                    return;
+                    resolve();
+                  } else {
+                    reject(
+                      new Error(
+                        "Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data"
+                      )
+                    );
                   }
-                  throw new Error(
-                    "Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data"
-                  );
                 });
-              };
+              });
+            };
+            let consumerEmittedData = {
+              data: void 0,
+              errors: void 0
+            };
+            if (this.exposeRefresh && this.refresh) {
+              consumerEmittedData.refresh = consumerEmittedRefresh;
             }
-            deepFreeze(userEmittedData);
-            this.callback(userEmittedData);
-            return;
+            if (result.isErr()) {
+              logError(result.error);
+              if (isUserVisibleError(result.error)) {
+                consumerEmittedData.data = result.error.data.data;
+                consumerEmittedData.errors = result.error.data.errors;
+              } else {
+                consumerEmittedData.errors = [
+                  {
+                    message: "Internal error in GraphQL adapter occurred",
+                    locations: []
+                  }
+                ];
+              }
+            } else {
+              consumerEmittedData.data = result.value.data;
+            }
+            deepFreeze(consumerEmittedData);
+            this.callback(consumerEmittedData);
           }
         } catch (e) {
-          emitGraphQLResult(this.callback, err$1(e));
+          logError(e);
+          this.handleExecutionThrow(e);
         }
       }
       handleExecutionThrow(e) {
-        emitGraphQLResult(this.callback, err$1(e));
+        logError(e);
+        this.callback({
+          data: void 0,
+          errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+        });
       }
       update(config, _context) {
         this.unsubscribe();
@@ -100472,31 +100465,89 @@
       }
     }
     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);
+          const consumerEmittedData = {
+            data: void 0,
+            errors: void 0
+          };
           if (result.isOk()) {
             deepFreeze(result.value);
+            consumerEmittedData.data = result.value.data.data;
+          } else {
+            if (isUserVisibleError(result.error)) {
+              consumerEmittedData.data = result.error.data.data;
+              consumerEmittedData.errors = result.error.data.errors;
+            } else {
+              logError(result.error);
+              consumerEmittedData.errors = [
+                { message: "Internal error in GraphQL adapter occurred", locations: [] }
+              ];
+            }
           }
-          emitGraphQLResult(callback, result);
+          callback(consumerEmittedData);
         } catch (error) {
-          emitGraphQLResult(callback, err$1(error));
+          logError(error);
+          callback({
+            data: void 0,
+            errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+          });
         }
       };
-      const subscribe = (config, _requestContext, callback) => {
+      const subscribe = (config, requestContext, callback) => {
         const command = getCommand({ config, assertIsValid });
         let unsubscribe = () => {
         };
-        command.execute().then((result) => {
-          if (!result.isOk()) {
-            emitGraphQLResult(callback, result);
-            return;
+        const overrides = requestContextIsCachePolicy(requestContext) ? { cacheControlConfig: { type: "no-cache" } } : {};
+        command.execute(overrides).then((result) => {
+          const consumerEmittedData = {
+            data: void 0,
+            errors: void 0
+          };
+          if (result.isOk()) {
+            deepFreeze(result.value);
+            consumerEmittedData.data = result.value.data.data;
+            unsubscribe = result.value.subscribe((res) => {
+              const consumerEmittedData2 = {
+                data: void 0,
+                errors: void 0
+              };
+              if (res.isOk()) {
+                consumerEmittedData2.data = res.value.data;
+              } else {
+                if (isUserVisibleError(res.error)) {
+                  consumerEmittedData2.data = res.error.data.data;
+                  consumerEmittedData2.errors = res.error.data.errors;
+                } else {
+                  logError(res.error);
+                  consumerEmittedData2.errors = [
+                    {
+                      message: "Internal error in GraphQL adapter occurred",
+                      locations: []
+                    }
+                  ];
+                }
+              }
+              callback(consumerEmittedData2);
+            });
+          } else {
+            if (isUserVisibleError(result.error)) {
+              consumerEmittedData.data = result.error.data.data;
+              consumerEmittedData.errors = result.error.data.errors;
+            } else {
+              logError(result.error);
+              consumerEmittedData.errors = [
+                {
+                  message: "Internal error in GraphQL adapter occurred",
+                  locations: []
+                }
+              ];
+            }
           }
-          unsubscribe = result.value.subscribe((res) => {
-            emitGraphQLResult(callback, res);
-          });
-          emitGraphQLResult(callback, result);
+          callback(consumerEmittedData);
         });
         return () => {
           unsubscribe();
@@ -100504,7 +100555,17 @@
       };
       return { invoke, subscribe };
     }
-    // version: 1.378.0-63d7c07562
+    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";
+    }
+    function resolveAst(ast) {
+      const result = astResolver(ast);
+      if (result === void 0) {
+        throw new Error("Could not resolve AST. Did you parse the query with gql?");
+      }
+      return result;
+    }
+    // version: 1.379.1-7ea94edc38
 
     class Analytics__AnalyticsBrowseRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
@@ -100716,7 +100777,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,
@@ -100724,11 +100792,6 @@
                 StringValue: this.typeRegistry.StringValue,
             };
         }
-        get fields() {
-            return {
-                __typename: new BaseScalarFieldDef(false),
-            };
-        }
     }
 
     class Base64ValueRepository extends UnidentifiableGraphQLTypeRepository {
@@ -101661,7 +101724,7 @@
         }
     }
 
-    class PolymorphicAggregateParentRelationshipRepository extends BaseUnionRepository {
+    let PolymorphicAggregateParentRelationshipRepository$1 = class PolymorphicAggregateParentRelationshipRepository extends BaseUnionRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101669,16 +101732,18 @@
             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,
+            };
+        }
+    };
 
     let PolymorphicParentRelationshipRepository$1 = class PolymorphicParentRelationshipRepository extends BaseUnionRepository {
         constructor(services, typeRegistry) {
@@ -101688,15 +101753,17 @@
             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 {
@@ -101721,7 +101788,7 @@
         }
     }
 
-    class RecordAggregateConnectionRepository extends UnidentifiableGraphQLTypeRepository {
+    let RecordAggregateConnectionRepository$1 = class RecordAggregateConnectionRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101738,9 +101805,9 @@
                 totalCount: new BaseScalarFieldDef(false),
             };
         }
-    }
+    };
 
-    class RecordAggregateEdgeRepository extends UnidentifiableGraphQLTypeRepository {
+    let RecordAggregateEdgeRepository$1 = class RecordAggregateEdgeRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101756,7 +101823,7 @@
                 cursor: new BaseScalarFieldDef(false),
             };
         }
-    }
+    };
 
     let RecordAggregateRepository$1 = class RecordAggregateRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
@@ -101794,7 +101861,7 @@
         }
     };
 
-    class RecordConnectionRepository extends UnidentifiableGraphQLTypeRepository {
+    let RecordConnectionRepository$1 = class RecordConnectionRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101812,9 +101879,9 @@
                 pageResultCount: new BaseScalarFieldDef(false),
             };
         }
-    }
+    };
 
-    class RecordEdgeRepository extends UnidentifiableGraphQLTypeRepository {
+    let RecordEdgeRepository$1 = class RecordEdgeRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101830,7 +101897,7 @@
                 cursor: new BaseScalarFieldDef(false),
             };
         }
-    }
+    };
 
     let RecordQueryAggregateRepository$1 = class RecordQueryAggregateRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
@@ -101925,7 +101992,7 @@
         }
     };
 
-    class RecordResultRepository extends UnidentifiableGraphQLTypeRepository {
+    let RecordResultRepository$1 = class RecordResultRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101940,7 +102007,7 @@
                 aggregate: new BaseObjectFieldDef(this.typeRegistry.RecordAggregate, true),
             };
         }
-    }
+    };
 
     class RecordTypeInfoRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
@@ -102363,15 +102430,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 {
@@ -102382,15 +102451,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 {
@@ -102740,10 +102811,10 @@
             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);
@@ -102773,13 +102844,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 =
@@ -103329,9 +103400,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 {
@@ -103354,15 +103435,26 @@
             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')) {
+                !input.selections.find((selection) => selection.kind === 'Field' && selection.name.value === 'Id')) {
                 overridenInput = {
-                    ...input,
+                    ...overridenInput,
                     selections: [
-                        ...input.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);
@@ -103375,13 +103467,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;
         }
@@ -103474,6 +103571,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 {
@@ -103495,6 +103602,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 {
@@ -103509,16 +103626,14 @@
         }
     }
 
+    // This should be smarter, and filter on selections, but for now,
+    // we'll match the luvio behavior of returning the blob
     const blobTypeDef = {
         read: (_cache, input) => {
-            return ok({
-                data: input.data,
-            });
+            return ok(input.normalizedData);
         },
         write: (_cache, input) => {
-            return ok({
-                data: input.data,
-            });
+            return ok(input.data);
         },
         buildFieldKey: (selection, variables) => buildFieldKey(selection.name.value, selection.arguments, variables),
         augmentSelections: (input) => input,
@@ -103580,6 +103695,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 {
@@ -103617,6 +103742,16 @@
             }
             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 {
@@ -103627,26 +103762,242 @@
         }
     }
 
+    // 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._PolymorphicParentRelationship = new PolymorphicParentRelationshipRepository(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;
         }
@@ -103656,20 +104007,44 @@
         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 PolymorphicParentRelationship() {
-            return this._PolymorphicParentRelationship;
+        get Setup__SetupRecordResult() {
+            return this._SetupRecordResult;
+        }
+        get Setup__Setup() {
+            return this._Setup;
         }
     }
 
@@ -103821,10 +104196,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;
                             },
@@ -103876,15 +104253,20 @@
                 }
                 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) {
@@ -103893,6 +104275,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
@@ -103900,15 +104289,53 @@
                     try {
                         const luvioService = this.services.luvio;
                         const luvioInstance = luvioService.luvio;
-                        // Subscribe to changes using the stored snapshot
+                        if (this.unsubscribeFromLuvioSnapshot) {
+                            this.unsubscribeFromLuvioSnapshot();
+                        }
                         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;
+            }
         };
     }
 
@@ -103955,6 +104382,11 @@
             type: 'luvioUiapiRecords',
             version: '1.0',
         },
+        instrumentation: {
+            type: 'instrumentation',
+            version: '1.0',
+            optional: true,
+        },
     };
     let provisionedCallback;
     getServices(serviceRequirements).then((services) => {
@@ -103965,7 +104397,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);
@@ -103990,7 +104422,7 @@
             cb(graphql$1, graphql_imperative$1, useOneStoreGraphQL);
         }
     }
-    // version: 1.378.0-63d7c07562
+    // version: 1.379.1-7ea94edc38
 
     function createFragmentMap(documentNode) {
         const fragments = {};
@@ -130485,7 +130917,7 @@
         }
         return refresh$3(data, 'refreshUiApi');
     }
-    // version: 1.378.0-63d7c07562
+    // version: 1.379.1-7ea94edc38
 
     // On core the unstable adapters are re-exported with different names,
     // we want to match them here.
@@ -130637,7 +131069,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.378.0-63d7c07562
+    // version: 1.379.1-7ea94edc38
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -131436,7 +131868,7 @@
     function register(r) {
         callbacks$1.forEach((callback) => callback(r));
     }
-    // version: 1.378.0-0ab3d40d29
+    // version: 1.379.1-5350e195b2
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -132773,4 +133205,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.378.0-0ab3d40d29
+// version: 1.379.1-5350e195b2