@salesforce/lds-worker-api 1.378.0 → 1.379.1

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

@@ -4274,7 +4274,7 @@ function withDefaultLuvio(callback) {
     }
     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) {
@@ -5318,7 +5318,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     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.,
@@ -34154,7 +34154,7 @@ withDefaultLuvio((luvio) => {
     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) {
@@ -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;
@@ -45802,7 +45793,7 @@ let Ok$4 = class Ok {
     return !this.isOk();
   }
 };
-let Err$4 = class Err {
+let Err$3 = class Err {
   constructor(error) {
     this.error = error;
   }
@@ -45814,7 +45805,7 @@ let Err$4 = class Err {
   }
 };
 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);
@@ -46045,7 +46036,7 @@ class IdentifiableTypeRepository {
     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,
@@ -46058,7 +46049,7 @@ class IdentifiableTypeRepository {
   }
   validateEntry(entry) {
     if (!isCacheEntryForType(entry, this)) {
-      return err$4([
+      return err$3([
         {
           type: "incorrectType",
           expectedType: this.typeName,
@@ -46084,12 +46075,12 @@ class IdentifiableTypeRepository {
     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);
@@ -46112,11 +46103,20 @@ function extractReadWriteData(result, errorCollector) {
 }
 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.
@@ -94148,7 +94148,7 @@ let Ok$3 = class Ok {
     return !this.isOk();
   }
 };
-let Err$3 = class Err {
+let Err$2 = class Err {
   constructor(error) {
     this.error = error;
   }
@@ -94160,7 +94160,7 @@ let Err$3 = class Err {
   }
 };
 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);
@@ -94260,7 +94260,7 @@ class CacheControlRequestRunner {
     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);
@@ -94319,7 +94319,7 @@ class CacheControlCommand extends BaseCommand {
         if (networkData) {
           return this.constructSubscribableResult(networkData.value);
         }
-        return err$3(result.error);
+        return err$2(result.error);
       }
       if (this.subscriptions.length > 0) {
         this.subscribeToKeysUsed();
@@ -94328,7 +94328,7 @@ class CacheControlCommand extends BaseCommand {
         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;
@@ -94391,7 +94391,7 @@ class CacheControlCommand extends BaseCommand {
   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);
     });
@@ -94409,7 +94409,7 @@ class CacheControlCommand extends BaseCommand {
     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;
@@ -95881,7 +95881,7 @@ function buildServiceDescriptor$5(luvio) {
         },
     };
 }
-// version: 1.378.0-63d7c07562
+// version: 1.379.1-7ea94edc38
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -95907,7 +95907,7 @@ function buildServiceDescriptor$4(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.378.0-63d7c07562
+// version: 1.379.1-7ea94edc38
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -98023,7 +98023,7 @@ register$1({
     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;
@@ -98052,7 +98052,7 @@ let Ok$2 = class Ok {
     return !this.isOk();
   }
 };
-let Err$2 = class Err {
+let Err$1 = class Err {
   constructor(error) {
     this.error = error;
   }
@@ -98064,7 +98064,7 @@ let Err$2 = class Err {
   }
 };
 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;
@@ -98139,7 +98139,7 @@ class JsonSchemaErrorCollector {
     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) {
@@ -98178,7 +98178,7 @@ function validSchemaResponse() {
   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();
@@ -98877,7 +98877,7 @@ function extractValue(valueNode, variableDefinitions, expectedType) {
 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`)
     );
   }
@@ -98897,7 +98897,7 @@ function validateExpectedType(value, expectedType) {
     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;
@@ -98905,7 +98905,7 @@ function validateExpectedType(value, expectedType) {
     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)}`)
   );
 }
@@ -98948,7 +98948,7 @@ function findExecutableOperation(input) {
     (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]);
@@ -98961,14 +98961,14 @@ function findExecutableOperation(input) {
     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;
@@ -99049,7 +99049,7 @@ function buildFieldKey(canonicalFieldName, fieldArguments, variables) {
   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}`
         )
@@ -99063,11 +99063,11 @@ function extractIfArgument(directive, variables, directiveName) {
   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);
 }
@@ -99107,7 +99107,7 @@ class BaseScalarFieldDef {
     }
     if (input.data === null) {
       if (!this.nullable) {
-        return err$4([
+        return err$3([
           {
             type: "unknown",
             error: new Error(
@@ -99150,7 +99150,7 @@ class BaseArrayFieldDef {
     }
     if (input.data === null) {
       if (!this.nullable) {
-        return err$4([
+        return err$3([
           {
             type: "unknown",
             error: new Error(
@@ -99162,7 +99162,7 @@ class BaseArrayFieldDef {
       return ok$4({ type: "data", data: input.data });
     }
     if (!Array.isArray(input.data)) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -99190,7 +99190,7 @@ class BaseArrayFieldDef {
       }
     });
     if (arrayNormalizationErrors.length > 0) {
-      return err$4(arrayNormalizationErrors);
+      return err$3(arrayNormalizationErrors);
     }
     return ok$4({ type: "data", data: normalizedArray });
   }
@@ -99201,7 +99201,7 @@ class BaseArrayFieldDef {
     }
     if (normalizedData.data === null) {
       if (!this.nullable) {
-        return err$4([
+        return err$3([
           {
             type: "unknown",
             error: new Error(
@@ -99213,7 +99213,7 @@ class BaseArrayFieldDef {
       return ok$4({ type: "data", data: null });
     }
     if (!Array.isArray(normalizedData.data)) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -99238,7 +99238,7 @@ class BaseArrayFieldDef {
       }
     });
     if (arrayDenormalizationErrors.length > 0) {
-      return err$4(arrayDenormalizationErrors);
+      return err$3(arrayDenormalizationErrors);
     }
     return ok$4(denormalizedArray);
   }
@@ -99257,7 +99257,7 @@ class BaseObjectFieldDef {
   write(cache, input) {
     var _a;
     if (!input.selection.selectionSet) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -99271,7 +99271,7 @@ class BaseObjectFieldDef {
     }
     if (input.data === null) {
       if (!this.nullable) {
-        return err$4([
+        return err$3([
           {
             type: "unknown",
             error: new Error(
@@ -99298,7 +99298,7 @@ class BaseObjectFieldDef {
   read(cache, input) {
     var _a;
     if (!input.selection.selectionSet) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -99313,7 +99313,7 @@ class BaseObjectFieldDef {
     }
     if (normalizedData.data === null) {
       if (!this.nullable) {
-        return err$4([
+        return err$3([
           {
             type: "unknown",
             error: new Error(
@@ -99402,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({
@@ -99428,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({
@@ -99541,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",
@@ -99599,7 +99604,7 @@ class BaseGraphQLTypeRepository {
     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)}.`
         )
@@ -99610,7 +99615,7 @@ class BaseGraphQLTypeRepository {
       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]);
@@ -99675,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",
@@ -99716,28 +99718,28 @@ class BaseGraphQLTypeRepository {
     }
     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;
@@ -99795,7 +99797,7 @@ class IdentifiableGraphQLTypeRepository extends IdentifiableTypeRepository {
     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)) {
@@ -99884,7 +99886,7 @@ class GraphQLDocumentRootTypeRepository extends IdentifiableGraphQLTypeRepositor
     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(
@@ -99942,7 +99944,7 @@ class BaseUnionRepository {
   }
   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"`)
@@ -99952,7 +99954,7 @@ class BaseUnionRepository {
     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(
@@ -99963,7 +99965,7 @@ class BaseUnionRepository {
     }
     const selectionErr = this.verifyUnionFields(input.selections);
     if (selectionErr) {
-      return err$4(selectionErr);
+      return err$3(selectionErr);
     }
     const normalizeInput = {
       ...input,
@@ -99982,7 +99984,7 @@ class BaseUnionRepository {
   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.`)
@@ -99992,7 +99994,7 @@ class BaseUnionRepository {
     const discriminator = unionRep.discriminator;
     const concreteRepository = this.possibleTypes[discriminator];
     if (!concreteRepository) {
-      return err$4([
+      return err$3([
         {
           type: "unknown",
           error: new Error(
@@ -100003,7 +100005,7 @@ class BaseUnionRepository {
     }
     const selectionErr = this.verifyUnionFields(input.selections);
     if (selectionErr) {
-      return err$4(selectionErr);
+      return err$3(selectionErr);
     }
     const denormalizeInput = {
       ...input,
@@ -100140,19 +100142,7 @@ let Ok$1 = class Ok {
     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;
@@ -100285,41 +100275,50 @@ class CommandWireAdapterConstructor {
       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() {
@@ -100329,11 +100328,11 @@ class CommandWireAdapterConstructor {
     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;
@@ -100343,10 +100342,10 @@ class CommandWireAdapterConstructor {
         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();
@@ -100354,10 +100353,15 @@ class CommandWireAdapterConstructor {
               }
               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) {
@@ -100374,87 +100378,76 @@ class CommandWireAdapterConstructor {
     }
   }
 }
-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();
@@ -100466,31 +100459,89 @@ 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);
+      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();
@@ -100498,7 +100549,17 @@ function buildAsyncGraphQLImperativeLegacyInvoker(getCommand) {
   };
   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) {
@@ -100710,7 +100771,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,
@@ -100718,11 +100786,6 @@ class AnyTypeRepository extends BaseUnionRepository {
             StringValue: this.typeRegistry.StringValue,
         };
     }
-    get fields() {
-        return {
-            __typename: new BaseScalarFieldDef(false),
-        };
-    }
 }
 
 class Base64ValueRepository extends UnidentifiableGraphQLTypeRepository {
@@ -101655,7 +101718,7 @@ class PicklistValueRepository extends UnidentifiableGraphQLTypeRepository {
     }
 }
 
-class PolymorphicAggregateParentRelationshipRepository extends BaseUnionRepository {
+let PolymorphicAggregateParentRelationshipRepository$1 = class PolymorphicAggregateParentRelationshipRepository extends BaseUnionRepository {
     constructor(services, typeRegistry) {
         super(services);
         this.services = services;
@@ -101663,16 +101726,18 @@ 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,
+        };
+    }
+};
 
 let PolymorphicParentRelationshipRepository$1 = class PolymorphicParentRelationshipRepository extends BaseUnionRepository {
     constructor(services, typeRegistry) {
@@ -101682,15 +101747,17 @@ let PolymorphicParentRelationshipRepository$1 = class PolymorphicParentRelations
         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 {
@@ -101715,7 +101782,7 @@ class QueryRepository extends GraphQLDocumentRootTypeRepository {
     }
 }
 
-class RecordAggregateConnectionRepository extends UnidentifiableGraphQLTypeRepository {
+let RecordAggregateConnectionRepository$1 = class RecordAggregateConnectionRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
         super(services);
         this.services = services;
@@ -101732,9 +101799,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;
@@ -101750,7 +101817,7 @@ class RecordAggregateEdgeRepository extends UnidentifiableGraphQLTypeRepository
             cursor: new BaseScalarFieldDef(false),
         };
     }
-}
+};
 
 let RecordAggregateRepository$1 = class RecordAggregateRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
@@ -101788,7 +101855,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;
@@ -101806,9 +101873,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;
@@ -101824,7 +101891,7 @@ class RecordEdgeRepository extends UnidentifiableGraphQLTypeRepository {
             cursor: new BaseScalarFieldDef(false),
         };
     }
-}
+};
 
 let RecordQueryAggregateRepository$1 = class RecordQueryAggregateRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
@@ -101919,7 +101986,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;
@@ -101934,7 +102001,7 @@ class RecordResultRepository extends UnidentifiableGraphQLTypeRepository {
             aggregate: new BaseObjectFieldDef(this.typeRegistry.RecordAggregate, true),
         };
     }
-}
+};
 
 class RecordTypeInfoRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
@@ -102357,15 +102424,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 {
@@ -102376,15 +102445,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 {
@@ -102734,10 +102805,10 @@ class GraphQLTypeRegistry {
         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);
@@ -102767,13 +102838,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 =
@@ -103323,9 +103394,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 {
@@ -103348,15 +103429,26 @@ class RecordRepresentationRepository extends RecordRepresentationRepository$1 {
         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);
@@ -103369,13 +103461,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;
     }
@@ -103468,6 +103565,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 {
@@ -103489,6 +103596,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 {
@@ -103503,16 +103620,14 @@ 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 = {
     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,
@@ -103574,6 +103689,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 {
@@ -103611,6 +103736,16 @@ 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 {
@@ -103621,26 +103756,242 @@ class PolymorphicParentRelationshipRepository extends PolymorphicParentRelations
     }
 }
 
+// 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;
     }
@@ -103650,20 +104001,44 @@ 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 PolymorphicParentRelationship() {
-        return this._PolymorphicParentRelationship;
+    get Setup__SetupRecordResult() {
+        return this._SetupRecordResult;
+    }
+    get Setup__Setup() {
+        return this._Setup;
     }
 }
 
@@ -103815,10 +104190,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;
                         },
@@ -103870,15 +104247,20 @@ function buildCommandClass(baseClass) {
             }
             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) {
@@ -103887,6 +104269,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
@@ -103894,15 +104283,53 @@ function buildCommandClass(baseClass) {
                 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;
+        }
     };
 }
 
@@ -103949,6 +104376,11 @@ const serviceRequirements = {
         type: 'luvioUiapiRecords',
         version: '1.0',
     },
+    instrumentation: {
+        type: 'instrumentation',
+        version: '1.0',
+        optional: true,
+    },
 };
 let provisionedCallback;
 getServices(serviceRequirements).then((services) => {
@@ -103959,7 +104391,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);
@@ -103984,7 +104416,7 @@ function registerCallback(cb) {
         cb(graphql$1, graphql_imperative$1, useOneStoreGraphQL);
     }
 }
-// version: 1.378.0-63d7c07562
+// version: 1.379.1-7ea94edc38
 
 function createFragmentMap(documentNode) {
     const fragments = {};
@@ -130479,7 +130911,7 @@ function refreshGraphQL(data) {
     }
     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.
@@ -130631,7 +131063,7 @@ withDefaultLuvio((luvio) => {
     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,
@@ -131430,7 +131862,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.378.0-0ab3d40d29
+// version: 1.379.1-5350e195b2
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -132746,4 +133178,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.378.0-0ab3d40d29
+// version: 1.379.1-5350e195b2