@salesforce/lds-worker-api 1.382.0 → 1.384.0

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

@@ -4280,7 +4280,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.382.0-8ca71123b0
+    // version: 1.384.0-cb845692ac
 
     // 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.382.0-8ca71123b0
+    // version: 1.384.0-cb845692ac
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -34160,7 +34160,7 @@
         throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
         throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
     });
-    // version: 1.382.0-73d929ea11
+    // version: 1.384.0-835fd13f44
 
     function requestIdleDetectedCallback(_callback) { }
     function declareNotifierTaskSingle(_name) {
@@ -81036,6 +81036,16 @@
         ldsMobileInstrumentation$2.trackValue(GARBAGE_COLLECTION_AGGRESSIVE_TRIM_TOTAL_RECORDS_BEFORE_TRIM, beforeTrimRecordCount);
         ldsMobileInstrumentation$2.trackValue(GARBAGE_COLLECTION_AGGRESSIVE_TRIM_RECORDS_TRIMMED, totalRecordsTrimmed);
     }
+    /** One Store Cache Purge */
+    const ONESTORE_CACHE_PURGING_RECORDS_PURGED = 'onestore-cache-purging-records-purged';
+    const ONESTORE_CACHE_PURGING_RECORDS_ERROR = 'onestore-cache-purging-records-error';
+    function reportOneStoreRecordsPurgedFromCache(recordsPurged) {
+        ldsMobileInstrumentation$2.trackValue(ONESTORE_CACHE_PURGING_RECORDS_PURGED, recordsPurged);
+    }
+    function reportOneStoreCachePurgingError(error) {
+        const errorMessage = normalizeError$1(error);
+        ldsMobileInstrumentation$2.error(errorMessage, ONESTORE_CACHE_PURGING_RECORDS_ERROR);
+    }
 
     const QUICK_ACTION_HANDLER = 'QUICK_ACTION_HANDLER';
     class QuickActionExecutionRepresentationHandler extends AbstractQuickActionHandler {
@@ -94274,7 +94284,7 @@
       }
       requestFromNetwork() {
         const that = this;
-        return async function* () {
+        return (async function* () {
           const result = await that.requestFromNetworkInternal();
           if (result.isErr()) {
             that.networkError = result;
@@ -94282,7 +94292,7 @@
             that.networkData = result;
           }
           yield result;
-        }();
+        })();
       }
       writeToCache(cache, networkResult) {
         return this.writeToCacheInternal(cache, networkResult);
@@ -95887,7 +95897,7 @@
             },
         };
     }
-    // version: 1.382.0-73d929ea11
+    // version: 1.384.0-835fd13f44
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -95913,7 +95923,7 @@
             },
         };
     }
-    // version: 1.382.0-73d929ea11
+    // version: 1.384.0-835fd13f44
 
     /*!
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -96758,7 +96768,7 @@
      * All rights reserved.
      * For full license text, see the LICENSE.txt file
      */
-    function findExecutableOperation$1(input) {
+    function findExecutableOperation$2(input) {
       const operations = input.query.definitions.filter(
         (def) => def.kind === Kind$2.OPERATION_DEFINITION
       );
@@ -96781,7 +96791,7 @@
       return err$1$1(new Error("Multiple operations found in query, and no operation name provided"));
     }
     function buildGraphQLInputExtension$1(input) {
-      const operationResult = findExecutableOperation$1(input);
+      const operationResult = findExecutableOperation$2(input);
       if (operationResult.isErr()) {
         return err$1$1(operationResult.error);
       }
@@ -96796,7 +96806,7 @@
         };
         return prev;
       }, {})) || {};
-      const fragments = input.query.definitions.filter((def) => def.kind === "FragmentDefinition").reduce((prev, fragment) => {
+      const fragments = input.query.definitions.filter(isFragmentDefinition$1).reduce((prev, fragment) => {
         prev[fragment.name.value] = fragment;
         return prev;
       }, {});
@@ -96806,6 +96816,47 @@
         parentFieldSelection: void 0
       });
     }
+    const TYPENAME_FIELD = {
+      kind: Kind$2.FIELD,
+      name: {
+        kind: Kind$2.NAME,
+        value: "__typename"
+      }
+    };
+    function addTypenameToDocument(doc) {
+      return visit(doc, {
+        SelectionSet: {
+          enter(node, _key, parent) {
+            if (isOperationDefinition(parent)) {
+              return;
+            }
+            const { selections } = node;
+            if (!selections || selections.length === 0) {
+              return;
+            }
+            const skip = selections.some((selection) => {
+              return isField$1(selection) && (selection.name.value === "__typename" || selection.name.value.lastIndexOf("__", 0) === 0);
+            });
+            if (skip) {
+              return;
+            }
+            return {
+              ...node,
+              selections: [...selections, TYPENAME_FIELD]
+            };
+          }
+        }
+      });
+    }
+    function isOperationDefinition(parent) {
+      return !!parent && !Array.isArray(parent) && parent.kind === Kind$2.OPERATION_DEFINITION;
+    }
+    function isField$1(node) {
+      return node.kind === Kind$2.FIELD;
+    }
+    function isFragmentDefinition$1(node) {
+      return node.kind === Kind$2.FRAGMENT_DEFINITION;
+    }
 
     /*!
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -96929,7 +96980,7 @@
         if (augmentedQueryResult.isErr()) {
           throw augmentedQueryResult.error;
         }
-        return augmentedQueryResult.value;
+        return addTypenameToDocument(augmentedQueryResult.value);
       }
       buildWriteInput(data) {
         const extensionResult = buildGraphQLInputExtension$1({
@@ -97023,7 +97074,7 @@
         if (augmentedQueryResult.isErr()) {
           throw augmentedQueryResult.error;
         }
-        return augmentedQueryResult.value;
+        return addTypenameToDocument(augmentedQueryResult.value);
       }
       buildWriteInput(data) {
         const extensionResult = buildGraphQLInputExtension$1({
@@ -97777,6 +97828,7 @@
         }
     }
 
+    const PURGE_CACHE_DAYS = 30;
     // TODO[@W-18753648]: These services depend on WebApis that aren't available in the worker.
     // import { buildServiceDescriptor as buildNdJsonServiceDescriptor } from '@luvio/command-ndjson/v1';
     // import { buildServiceDescriptor as buildStreamingCommandServiceDescriptor } from '@luvio/command-streaming/v1';
@@ -97825,6 +97877,48 @@
             // buildSseCommandServiceDescriptor(),
         ];
         setServices(services);
+        purgeDurableCacheByDays(PURGE_CACHE_DAYS, sqliteStore);
+    }
+    /**
+     * Manually purges the OneStore cache by days.
+     * Until we have real cache eviction in one store.
+     *
+     * @param days - The number of days to purge the cache by.
+     * @param sqliteStore - The SqliteStorePlugin to purge the cache from.
+     */
+    async function purgeDurableCacheByDays(days, sqliteStore) {
+        const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
+        const cutoffTimestamp = Date.now() - days * MILLISECONDS_PER_DAY;
+        try {
+            // This has to be ran in a SELECT since the DELETE query may not support return on SQLite version in mobile
+            const countQuery = `
+            SELECT COUNT(*) FROM lds_one_store_data
+            WHERE json_extract(metadata, '$.cacheControl.generatedTime') < ?
+        `;
+            const countResult = await queryAsync(sqliteStore, countQuery, [cutoffTimestamp]);
+            const deleteCount = countResult.rows[0][0];
+            if (deleteCount === 0) {
+                reportOneStoreRecordsPurgedFromCache(0);
+                return;
+            }
+            const deleteQuery = `
+            DELETE FROM lds_one_store_data
+            WHERE json_extract(metadata, '$.cacheControl.generatedTime') < ?
+        `;
+            await queryAsync(sqliteStore, deleteQuery, [cutoffTimestamp]);
+            reportOneStoreRecordsPurgedFromCache(deleteCount);
+        }
+        catch (error) {
+            reportOneStoreCachePurgingError(error);
+        }
+    }
+    /**
+     * Promisified wrapper for SqliteStorePlugin.query
+     */
+    function queryAsync(sqliteStore, sql, params) {
+        return new Promise((resolve, reject) => {
+            sqliteStore.query(sql, params, (result) => resolve(result), (error) => reject(error));
+        });
     }
 
     // so eslint doesn't complain about nimbus
@@ -98029,7 +98123,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$2,
     });
-    // version: 1.382.0-8ca71123b0
+    // version: 1.384.0-cb845692ac
 
     const { create: create$3, keys: keys$3 } = Object;
     const { stringify: stringify$1, parse } = JSON;
@@ -98949,7 +99043,7 @@
       }
       return target;
     }
-    function findExecutableOperation(input) {
+    function findExecutableOperation$1(input) {
       const operations = input.query.definitions.filter(
         (def) => def.kind === Kind.OPERATION_DEFINITION
       );
@@ -98972,7 +99066,7 @@
       return err$3(new Error("Multiple operations found in query, and no operation name provided"));
     }
     function buildGraphQLInputExtension(input) {
-      const operationResult = findExecutableOperation(input);
+      const operationResult = findExecutableOperation$1(input);
       if (operationResult.isErr()) {
         return err$3(operationResult.error);
       }
@@ -98987,7 +99081,7 @@
         };
         return prev;
       }, {})) || {};
-      const fragments = input.query.definitions.filter((def) => def.kind === "FragmentDefinition").reduce((prev, fragment) => {
+      const fragments = input.query.definitions.filter(isFragmentDefinition).reduce((prev, fragment) => {
         prev[fragment.name.value] = fragment;
         return prev;
       }, {});
@@ -98997,14 +99091,24 @@
         parentFieldSelection: void 0
       });
     }
-    function buildUniqueAugmentedFieldSelection(newSelection, selections, fragments) {
+    function buildAugmentedFieldSelection(newSelection, selections, fragments) {
       var _a;
+      if (selectionExists(newSelection, selections)) {
+        return void 0;
+      }
       const baseAlias = ((_a = newSelection.alias) == null ? void 0 : _a.value) || newSelection.name.value;
       const baseInjectedAlias = `framework_augmented_${baseAlias}`;
-      const fieldName = getUniqueSelectionName(baseInjectedAlias, selections, fragments);
-      if (fieldName === newSelection.name.value) {
-        return newSelection;
+      const baseAliasedSelection = {
+        ...newSelection,
+        alias: {
+          kind: Kind.NAME,
+          value: baseInjectedAlias
+        }
+      };
+      if (selectionExists(baseAliasedSelection, selections)) {
+        return void 0;
       }
+      const fieldName = getUniqueSelectionName(baseInjectedAlias, selections, fragments);
       return {
         ...newSelection,
         alias: {
@@ -99013,6 +99117,94 @@
         }
       };
     }
+    function selectionExists(selection, selections) {
+      return selections.some((s) => selectionEquals(selection, s));
+    }
+    function selectionEquals(a, b) {
+      var _a, _b, _c, _d, _e, _f;
+      if (a.kind !== b.kind) {
+        return false;
+      }
+      if (a.kind === Kind.FIELD) {
+        const bField = b;
+        return !!(a.name.value === bField.name.value) && !!(((_a = a.alias) == null ? void 0 : _a.value) === ((_b = bField.alias) == null ? void 0 : _b.value)) && argumentsEqual(a.arguments, bField.arguments) && selectionSetsEqual((_c = a.selectionSet) == null ? void 0 : _c.selections, (_d = bField.selectionSet) == null ? void 0 : _d.selections) && directivesEqual(a.directives, bField.directives);
+      }
+      if (a.kind === Kind.FRAGMENT_SPREAD) {
+        const bFragmentSpread = b;
+        return a.name.value === bFragmentSpread.name.value && directivesEqual(a.directives, bFragmentSpread.directives);
+      }
+      const bInlineFragment = b;
+      return a.typeCondition === bInlineFragment.typeCondition && directivesEqual(a.directives, bInlineFragment.directives) && selectionSetsEqual((_e = a.selectionSet) == null ? void 0 : _e.selections, (_f = bInlineFragment.selectionSet) == null ? void 0 : _f.selections);
+    }
+    function argumentValueEquals(a, b) {
+      if (a.kind !== b.kind) {
+        return false;
+      }
+      switch (a.kind) {
+        case Kind.STRING:
+        case Kind.INT:
+        case Kind.FLOAT:
+        case Kind.BOOLEAN:
+        case Kind.ENUM:
+          return a.value === b.value;
+        case Kind.NULL:
+          return true;
+        case Kind.VARIABLE:
+          return a.name.value === b.name.value;
+        case Kind.LIST:
+          const bList = b;
+          if (a.values.length !== bList.values.length) {
+            return false;
+          }
+          return a.values.every((val, index) => argumentValueEquals(val, bList.values[index]));
+        case Kind.OBJECT:
+          const bObject = b;
+          if (a.fields.length !== bObject.fields.length) {
+            return false;
+          }
+          return a.fields.every((field, index) => {
+            const bField = bObject.fields[index];
+            return field.name.value === bField.name.value && argumentValueEquals(field.value, bField.value);
+          });
+        default:
+          return false;
+      }
+    }
+    function directivesEqual(a, b) {
+      if (a === void 0 && b === void 0) {
+        return true;
+      }
+      if (a === void 0 || b === void 0) {
+        return ((a == null ? void 0 : a.length) || 0) === ((b == null ? void 0 : b.length) || 0);
+      }
+      if (a.length !== b.length) {
+        return false;
+      }
+      return a.every((directive, index) => {
+        const bDirective = b[index];
+        return directive.name.value === bDirective.name.value && argumentsEqual(directive.arguments, bDirective.arguments);
+      });
+    }
+    function argumentsEqual(a, b) {
+      if (a === void 0 && b === void 0) {
+        return true;
+      }
+      if (a === void 0 || b === void 0) {
+        return ((a == null ? void 0 : a.length) || 0) === ((b == null ? void 0 : b.length) || 0);
+      }
+      if (a.length !== b.length) {
+        return false;
+      }
+      return a.every((arg, index) => {
+        const bArg = b[index];
+        return arg.name.value === bArg.name.value && argumentValueEquals(arg.value, bArg.value);
+      });
+    }
+    function selectionSetsEqual(a, b) {
+      return a === void 0 || b === void 0 || !!(a.length === b.length) && !!a.every((selection, index) => {
+        return selectionEquals(selection, b[index]);
+      });
+    }
     function getUniqueSelectionName(fieldName, selections, fragments) {
       const fieldNames = collectFieldNames(selections, fragments);
       if (!fieldNames.includes(fieldName)) {
@@ -99028,14 +99220,14 @@
       var _a;
       const fieldNames = /* @__PURE__ */ new Set();
       for (const selection of selections) {
-        if (selection.kind === Kind.FIELD) {
+        if (isField(selection)) {
           fieldNames.add(((_a = selection.alias) == null ? void 0 : _a.value) || selection.name.value);
-        } else if (selection.kind === Kind.INLINE_FRAGMENT) {
+        } else if (isInlineFragment(selection)) {
           collectFieldNames(
             selection.selectionSet.selections,
             fragments
           ).forEach((name) => fieldNames.add(name));
-        } else if (selection.kind === Kind.FRAGMENT_SPREAD) {
+        } else if (isFragmentSpread(selection)) {
           const fragment = fragments[selection.name.value];
           if (fragment) {
             collectFieldNames(
@@ -99065,6 +99257,25 @@
       }
       return ok$4(`${canonicalFieldName}::${stableJSONStringify$3({ args: formattedArguments })}`);
     }
+    ({
+      kind: Kind.FIELD,
+      name: {
+        kind: Kind.NAME,
+        value: "__typename"
+      }
+    });
+    function isField(node) {
+      return node.kind === Kind.FIELD;
+    }
+    function isFragmentSpread(node) {
+      return node.kind === Kind.FRAGMENT_SPREAD;
+    }
+    function isInlineFragment(node) {
+      return node.kind === Kind.INLINE_FRAGMENT;
+    }
+    function isFragmentDefinition(node) {
+      return node.kind === Kind.FRAGMENT_DEFINITION;
+    }
     function extractIfArgument(directive, variables, directiveName) {
       var _a;
       const ifArg = (_a = directive.arguments) == null ? void 0 : _a.find((arg) => arg.name.value === "if");
@@ -99348,11 +99559,11 @@
         const augmentedSelections = [];
         let augmentedFragments = { ...input.fragments };
         for (const selection of input.selections) {
-          if (selection.kind === Kind.FIELD) {
+          if (isField(selection)) {
             const result = this.augmentFieldSelection(selection, augmentedFragments);
             augmentedSelections.push(...result.selections);
             augmentedFragments = result.fragments;
-          } else if (selection.kind === Kind.INLINE_FRAGMENT) {
+          } else if (isInlineFragment(selection)) {
             const augmentedFragmentSelections = this.augmentInlineFragmentSelection(
               selection,
               augmentedFragments
@@ -99368,19 +99579,20 @@
             augmentedFragments = augmentedFragmentSelections.fragments;
           }
         }
-        augmentedSelections.push(
-          buildUniqueAugmentedFieldSelection(
-            {
-              kind: Kind.FIELD,
-              name: {
-                kind: Kind.NAME,
-                value: "__typename"
-              }
-            },
-            [...augmentedSelections, ...input.selections],
-            augmentedFragments
-          )
+        const newTypenameSelection = buildAugmentedFieldSelection(
+          {
+            kind: Kind.FIELD,
+            name: {
+              kind: Kind.NAME,
+              value: "__typename"
+            }
+          },
+          [...augmentedSelections, ...input.selections],
+          augmentedFragments
         );
+        if (newTypenameSelection) {
+          augmentedSelections.push(newTypenameSelection);
+        }
         return { selections: augmentedSelections, fragments: augmentedFragments };
       }
       augmentFieldSelection(selection, fragments) {
@@ -99443,21 +99655,21 @@
           fragment
         );
         if (satisfiedFragmentTypeConditionResult.isErr() || !satisfiedFragmentTypeConditionResult.value) {
-          return { selections: [], fragments };
+          return { selections: [selection], fragments };
         }
-        const augmentedFragmentSelections = this.augmentSelections({
+        const augmentedFragment = this.augmentSelections({
           selections: ((_a = fragment.selectionSet) == null ? void 0 : _a.selections) || [],
           fragments
         });
         return {
           selections: [selection],
           fragments: {
-            ...fragments,
+            ...augmentedFragment.fragments,
             [fragment.name.value]: {
               ...fragment,
               selectionSet: {
                 kind: Kind.SELECTION_SET,
-                selections: augmentedFragmentSelections.selections
+                selections: augmentedFragment.selections
               }
             }
           }
@@ -99467,14 +99679,14 @@
         const normalized = {};
         const errors = [];
         for (const selection of input.selections) {
-          if (selection.kind === Kind.FIELD) {
+          if (isField(selection)) {
             deepMerge$2(
               normalized,
               this.normalizeFieldSelection(cache, input, selection, errors)
             );
           } else {
             let fragment;
-            if (selection.kind === Kind.INLINE_FRAGMENT) {
+            if (isInlineFragment(selection)) {
               fragment = selection;
             } else {
               const fragmentDefinition = input.request.definitions.fragments[selection.name.value];
@@ -99579,14 +99791,14 @@
         const errors = [];
         const denormalized = {};
         for (const selection of input.selections) {
-          if (selection.kind === Kind.FIELD) {
+          if (isField(selection)) {
             deepMerge$2(
               denormalized,
               this.denormalizeFieldSelection(cache, input, selection, errors)
             );
           } else {
             let fragment;
-            if (selection.kind === Kind.INLINE_FRAGMENT) {
+            if (isInlineFragment(selection)) {
               fragment = selection;
             } else {
               const fragmentDefinition = input.request.definitions.fragments[selection.name.value];
@@ -99776,19 +99988,20 @@
             const result = super.augmentSelections(input);
             const augmentedSelections = result.selections;
             let augmentedFragments = result.fragments;
-            augmentedSelections.push(
-              buildUniqueAugmentedFieldSelection(
-                {
-                  kind: Kind.FIELD,
-                  name: {
-                    kind: Kind.NAME,
-                    value: this.idField
-                  }
-                },
-                [...augmentedSelections, ...input.selections],
-                augmentedFragments
-              )
+            const newSelection = buildAugmentedFieldSelection(
+              {
+                kind: Kind.FIELD,
+                name: {
+                  kind: Kind.NAME,
+                  value: this.idField
+                }
+              },
+              [...augmentedSelections, ...input.selections],
+              augmentedFragments
             );
+            if (newSelection) {
+              augmentedSelections.push(newSelection);
+            }
             return { selections: augmentedSelections, fragments: augmentedFragments };
           }
         };
@@ -99844,6 +100057,19 @@
       buildFieldKey(selection, variables) {
         return this.graphqlRepository.buildFieldKey(selection, variables);
       }
+      buildKeyParams(input) {
+        var _a;
+        const idField = input.selections.find(
+          (selection) => selection.kind === Kind.FIELD && selection.name.value === this.idField
+        );
+        if (!idField) {
+          throw new Error(`Id field ${this.idField} not found in selections`);
+        }
+        const idFieldDataProperty = ((_a = idField.alias) == null ? void 0 : _a.value) || idField.name.value;
+        return {
+          [this.idField]: input.data[idFieldDataProperty]
+        };
+      }
     }
     class GraphQLDocumentRootTypeRepository extends IdentifiableGraphQLTypeRepository {
       constructor() {
@@ -99890,7 +100116,7 @@
       }
       buildAugmentedQuery(input) {
         var _a;
-        const operationResult = findExecutableOperation(input);
+        const operationResult = findExecutableOperation$1(input);
         if (operationResult.isErr()) {
           return err$3(operationResult.error);
         }
@@ -100035,13 +100261,14 @@
         );
         augmentedSelections.push(...result.selections);
         augmentedFragments = result.fragments;
-        augmentedSelections.push(
-          buildUniqueAugmentedFieldSelection(
-            { kind: Kind.FIELD, name: { kind: Kind.NAME, value: "__typename" } },
-            augmentedSelections,
-            input.fragments
-          )
+        const newSelection = buildAugmentedFieldSelection(
+          { kind: Kind.FIELD, name: { kind: Kind.NAME, value: "__typename" } },
+          augmentedSelections,
+          input.fragments
         );
+        if (newSelection) {
+          augmentedSelections.push(newSelection);
+        }
         return { selections: augmentedSelections, fragments: augmentedFragments };
       }
       getTypeDiscriminator(data, _selections) {
@@ -100389,6 +100616,56 @@
         (validationError) => validationError instanceof MissingRequiredPropertyError
       ) !== void 0;
     }
+    function findExecutableOperation(document, operationName) {
+      const operations = document.definitions.filter(
+        (def) => def.kind === Kind$1.OPERATION_DEFINITION
+      );
+      if (operations.length === 0) {
+        return void 0;
+      }
+      if (operations.length === 1 && !operationName) {
+        return operations[0];
+      }
+      if (operationName) {
+        return operations.find((op) => {
+          var _a;
+          return ((_a = op.name) == null ? void 0 : _a.value) === operationName;
+        });
+      }
+      return void 0;
+    }
+    function validateGraphQLOperations(config, options) {
+      const executableOperation = findExecutableOperation(config.query, config.operationName);
+      if (executableOperation) {
+        const operationType = executableOperation.operation;
+        if (!options.acceptedOperations.includes(operationType)) {
+          const operationTypeCapitalized = operationType.charAt(0).toUpperCase() + operationType.slice(1);
+          throw new Error(
+            `${operationTypeCapitalized} operations are not supported in this context`
+          );
+        }
+      }
+    }
+    function resolveAst(ast) {
+      if (ast === null) {
+        return;
+      }
+      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 wrapConfigAndVerify(config) {
+      if (config == null ? void 0 : config.query) {
+        config = { ...config, query: resolveAst(config.query) };
+        if (config.query === void 0) {
+          throw new Error("Internal error in GraphQL adapter occurred: Unable to resolve query");
+        }
+        validateGraphQLOperations(config, { acceptedOperations: ["query"] });
+      }
+      return config;
+    }
     class GraphQLCommandWireAdapterConstructor extends CommandWireAdapterConstructor {
       emit(result) {
         try {
@@ -100457,15 +100734,110 @@
       }
       update(config, _context) {
         this.unsubscribe();
+        const resolvedQuery = resolveAst(config.query);
+        if (resolvedQuery) {
+          validateGraphQLOperations(
+            { query: resolvedQuery, operationName: config == null ? void 0 : config.operationName },
+            { acceptedOperations: ["query"] }
+          );
+        }
         this.config = {
           ...sanitize(config),
-          query: config.query
+          query: resolvedQuery
         };
         this.invokeAdapter();
       }
     }
+    function buildAsyncGraphQLImperativeInvoker(getCommand, exposeRefresh = false) {
+      return async (...params) => {
+        try {
+          if (params.length) {
+            params[0] = wrapConfigAndVerify(params[0]);
+          }
+          const command = getCommand({ params, assertIsValid });
+          const result = await command.execute();
+          const consumerEmittedData = {
+            data: void 0,
+            errors: void 0
+          };
+          if (result.isOk()) {
+            deepFreeze(result.value);
+            consumerEmittedData.data = result.value.data.data;
+            consumerEmittedData.subscribe = (cb) => {
+              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: []
+                      }
+                    ];
+                  }
+                }
+                cb(consumerEmittedData2);
+              });
+            };
+            if (exposeRefresh) {
+              consumerEmittedData.refresh = () => {
+                return new Promise((resolve, reject) => {
+                  try {
+                    result.value.refresh().then((res) => {
+                      if (res.isOk()) {
+                        resolve();
+                      } else {
+                        reject(
+                          new Error(
+                            "Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data"
+                          )
+                        );
+                      }
+                    });
+                  } catch (error) {
+                    logError(error);
+                    reject(
+                      new Error(
+                        "Internal error in GraphQL adapter occurred: Failed to refresh GraphQL 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: [] }
+              ];
+            }
+          }
+          return consumerEmittedData;
+        } catch (error) {
+          logError(error);
+          return {
+            data: void 0,
+            errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+          };
+        }
+      };
+    }
     function buildAsyncGraphQLImperativeLegacyInvoker(getCommand) {
       const invoke = async (config, requestContext, callback) => {
+        config = wrapConfigAndVerify(config);
         const command = getCommand({ config, assertIsValid });
         try {
           const overrides = requestContextIsCachePolicy(requestContext) ? { cacheControlConfig: { type: "no-cache" } } : {};
@@ -100498,6 +100870,7 @@
         }
       };
       const subscribe = (config, requestContext, callback) => {
+        config = wrapConfigAndVerify(config);
         const command = getCommand({ config, assertIsValid });
         let unsubscribe = () => {
         };
@@ -100558,14 +100931,7 @@
     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.382.0-73d929ea11
+    // version: 1.384.0-835fd13f44
 
     class Analytics__AnalyticsBrowseRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
@@ -100630,6 +100996,7 @@
             this.namespace = "oas";
             this.typeName = "Analytics__AnalyticsRepresentation";
             this.implementedInterfaces = ["Analytics__AnalyticsRepresentationInterface"];
+            this.idField = "Id";
         }
         get fields() {
             return {
@@ -100648,9 +101015,6 @@
                 Dataspaces: new BaseArrayFieldDef(new BaseObjectFieldDef(this.typeRegistry.Analytics__DataspaceRepresentation, true), true),
             };
         }
-        buildKeyParams(input) {
-            return { Id: input.data.Id };
-        }
         get cacheControl() {
             return { type: "max-age", maxAge: 60 };
         }
@@ -100721,6 +101085,7 @@
             this.namespace = "oas";
             this.typeName = "Analytics__AnalyticsWorkspace";
             this.implementedInterfaces = [];
+            this.idField = "Id";
         }
         get fields() {
             return {
@@ -100735,9 +101100,6 @@
                 ApiName: new BaseScalarFieldDef(false),
             };
         }
-        buildKeyParams(input) {
-            return { Id: input.data.Id };
-        }
         get cacheControl() {
             return { type: "max-age", maxAge: 60 };
         }
@@ -100751,6 +101113,7 @@
             this.namespace = "oas";
             this.typeName = "Analytics__DataspaceRepresentation";
             this.implementedInterfaces = [];
+            this.idField = "Id";
         }
         get fields() {
             return {
@@ -100761,9 +101124,6 @@
                 DeveloperName: new BaseScalarFieldDef(true),
             };
         }
-        buildKeyParams(input) {
-            return { Id: input.data.Id };
-        }
         get cacheControl() {
             return { type: "max-age", maxAge: 60 };
         }
@@ -101941,6 +102301,7 @@
             this.namespace = "oas";
             this.typeName = "RecordRepresentation";
             this.implementedInterfaces = ["Record"];
+            this.idField = "Id";
         }
         get fields() {
             return {
@@ -101984,9 +102345,6 @@
                 AnyType: new BaseObjectFieldDef(this.typeRegistry.AnyType, true),
             };
         }
-        buildKeyParams(input) {
-            return { Id: input.data.Id };
-        }
         get cacheControl() {
             return { type: "max-age", maxAge: 60 };
         }
@@ -102116,6 +102474,7 @@
             this.namespace = "oas";
             this.typeName = "Setup__EntityRepresentation";
             this.implementedInterfaces = [];
+            this.idField = "Id";
         }
         get fields() {
             return {
@@ -102154,9 +102513,6 @@
                 AnyType: new BaseObjectFieldDef(this.typeRegistry.AnyType, true),
             };
         }
-        buildKeyParams(input) {
-            return { Id: input.data.Id };
-        }
         get cacheControl() {
             return { type: "max-age", maxAge: 60 };
         }
@@ -102331,6 +102687,7 @@
             this.namespace = "oas";
             this.typeName = "Setup__ListViewRow";
             this.implementedInterfaces = [];
+            this.idField = "id";
         }
         get fields() {
             return {
@@ -102339,9 +102696,6 @@
                 columns: new BaseArrayFieldDef(new BaseObjectFieldDef(this.typeRegistry.Setup__ListScalarField, true), false),
             };
         }
-        buildKeyParams(input) {
-            return { id: input.data.id };
-        }
         get cacheControl() {
             return { type: "max-age", maxAge: 60 };
         }
@@ -103377,6 +103731,61 @@
         return data.__genericTypename || data.__typename;
     }
 
+    /**
+     * Finds the typename field name from GraphQL selections, looking for __typename or aliased fields.
+     *
+     * @param input - The normalize/denormalize data input containing selections
+     * @returns The field name to use for typename lookup, or '__typename' as fallback
+     */
+    function findTypenameFieldFromSelections(input) {
+        // For normalize inputs, check if selections exist and find __typename field
+        if (input && 'selections' in input && Array.isArray(input.selections)) {
+            const typenameSelection = input.selections.find((selection) => selection.kind === 'Field' && selection.name?.value === '__typename');
+            if (typenameSelection) {
+                // If there's an alias, use the alias name, otherwise use the field name
+                return typenameSelection.alias?.value || typenameSelection.name.value;
+            }
+        }
+        // Fallback to standard __typename field name
+        return '__typename';
+    }
+    /**
+     * Checks if the input data satisfies a fragment type condition by comparing the typename
+     * from the input data with the fragment's conditional type name.
+     *
+     * @param input - The normalize/denormalize data input containing the typename
+     * @param fragment - The fragment containing the type condition
+     * @returns Result<boolean, Error> - true if the type condition is satisfied
+     */
+    function dataSatisfiesFragmentTypeCondition(input, fragment) {
+        const conditionalTypeName = fragment?.typeCondition?.name.value;
+        const typename = input?.data?.[findTypenameFieldFromSelections(input)] ||
+            input?.normalizedData?.__typename?.data;
+        if (conditionalTypeName && typename === conditionalTypeName) {
+            return ok(true);
+        }
+        return ok(false);
+    }
+    /**
+     * Generic implementation of satisfiesFragmentTypeCondition for repositories.
+     * Combines the base class type condition check with custom typename validation.
+     *
+     * @param superSatisfiesFragmentTypeCondition - The super class method to call first
+     * @param input - The normalize/denormalize data input
+     * @param fragment - The fragment containing the type condition
+     * @param typeName - The repository type name for error messages
+     * @returns Result<boolean, Error> - true if the fragment type condition is satisfied
+     */
+    function genericSatisfiesFragmentTypeCondition(superSatisfiesFragmentTypeCondition, input, fragment, typeName) {
+        // First try the base class implementation
+        const result = superSatisfiesFragmentTypeCondition(input, fragment);
+        if (result.isErr() || result.value) {
+            return result;
+        }
+        // Then try our custom typename checking
+        return dataSatisfiesFragmentTypeCondition(input, fragment);
+    }
+
     class RecordRepresentationBaseRepository extends BaseGraphQLTypeRepository {
         constructor(namespace, typeName, implementedInterfaces, fields, idField, services) {
             super();
@@ -103403,15 +103812,8 @@
         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}`));
+        satisfiesFragmentTypeCondition(input, fragment) {
+            return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), input, fragment, this.typeName);
         }
     }
 
@@ -103420,7 +103822,7 @@
             super(services, typeRegistry);
             this.services = services;
             this.typeRegistry = typeRegistry;
-            this.namespace = 'oas';
+            this.namespace = 'uiapi';
             this.typeName = 'RecordRepresentation';
             this.implementedInterfaces = ['Record'];
             this._graphqlRepositoryOverride = undefined;
@@ -103572,14 +103974,7 @@
             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}`));
+            return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
         }
     }
 
@@ -103603,14 +103998,7 @@
             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}`));
+            return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
         }
     }
 
@@ -103646,7 +104034,7 @@
             super(services);
             this.services = services;
             this.typeRegistry = typeRegistry;
-            this.namespace = 'oas';
+            this.namespace = 'uiapi';
             this.typeName = 'Setup__EntityRepresentation';
             this.implementedInterfaces = [];
         }
@@ -103696,14 +104084,7 @@
             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}`));
+            return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), input, fragment, this.typeName);
         }
     }
 
@@ -103743,14 +104124,7 @@
             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}`));
+            return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
         }
     }
 
@@ -103769,7 +104143,7 @@
         constructor(services, typeRegistry) {
             super(services);
             this.typeRegistry = typeRegistry;
-            this.namespace = 'oas';
+            this.namespace = 'uiapi';
             this.typeName = 'Setup__Setup';
             this.implementedInterfaces = [];
             this.cacheControl = {
@@ -103790,14 +104164,7 @@
 
     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}`));
+            return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
         }
     }
 
@@ -103811,118 +104178,55 @@
 
     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}`));
+            return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
         }
     }
 
     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}`));
+            return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
         }
     }
 
     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}`));
+            return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
         }
     }
 
     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}`));
+            return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
         }
     }
 
     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}`));
+            return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
         }
     }
 
     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}`));
+            return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
         }
     }
 
     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}`));
+            return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
         }
     }
 
     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}`));
+            return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
         }
     }
 
     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}`));
+            return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
         }
     }
 
@@ -104341,6 +104645,7 @@
 
     let graphql$1;
     let graphql_imperative$1;
+    let graphql_imperative_legacy;
     let useOneStoreGraphQL = false;
     const serviceRequirements = {
         instrumentCommand: {
@@ -104400,18 +104705,24 @@
                 this.exposeRefresh = true;
             }
             getCommand() {
-                return new graphql_ctor({ ...this.config, query: resolveAst(this.config.query) }, documentRootType, services);
+                return new graphql_ctor(this.config, documentRootType, services);
             }
         };
         const graphql_imperative_ctor = services.instrumentCommand(buildCommandClass(services.auraGraphQLNormalizedCacheControlCommand), 'graphql_imperative');
-        graphql_imperative$1 = buildAsyncGraphQLImperativeLegacyInvoker(({ config, assertIsValid }) => {
+        graphql_imperative$1 = buildAsyncGraphQLImperativeInvoker(({ params, assertIsValid }) => {
+            const config = params[0];
+            const _ = assertIsValid;
+            _(config, CONFIG_SCHEMA);
+            return new graphql_imperative_ctor(config, documentRootType, services);
+        }, true);
+        graphql_imperative_legacy = buildAsyncGraphQLImperativeLegacyInvoker(({ config, assertIsValid }) => {
             const _ = assertIsValid;
             _(config, CONFIG_SCHEMA);
-            return new graphql_imperative_ctor({ ...config, query: resolveAst(config.query) }, documentRootType, services);
+            return new graphql_imperative_ctor(config, documentRootType, services);
         });
         useOneStoreGraphQL = services.featureFlags?.get('useOneStoreGraphQL') ?? false;
         if (provisionedCallback) {
-            provisionedCallback(graphql$1, graphql_imperative$1, useOneStoreGraphQL);
+            provisionedCallback(graphql$1, graphql_imperative$1, graphql_imperative_legacy, useOneStoreGraphQL);
         }
     }, (_err) => { });
     function registerCallback(cb) {
@@ -104419,10 +104730,10 @@
             provisionedCallback = cb;
         }
         else {
-            cb(graphql$1, graphql_imperative$1, useOneStoreGraphQL);
+            cb(graphql$1, graphql_imperative$1, graphql_imperative_legacy, useOneStoreGraphQL);
         }
     }
-    // version: 1.382.0-73d929ea11
+    // version: 1.384.0-835fd13f44
 
     function createFragmentMap(documentNode) {
         const fragments = {};
@@ -130374,11 +130685,15 @@
         return cacheSnapshot;
     }
 
+    // Wire Adapters
     let graphql;
     let graphqlBatch;
     // Imperative GET Adapters
     let graphql_imperative;
     let graphqlBatch_imperative;
+    let refreshGraphQL = (data) => {
+        return refresh$3(data, 'refreshUiApi');
+    };
     // Adapter Metadata
     const graphqlMetadata = { apiFamily: keyPrefix$1, name: 'graphql', ttl: 900000 };
     const graphqlBatchMetadata = { apiFamily: keyPrefix$1, name: 'graphqlBatch' };
@@ -130400,10 +130715,16 @@
         ({ graphql, graphqlBatch, graphql_imperative, graphqlBatch_imperative } = bindExportsTo(luvio));
         // We register the callback here rather than above withDefaultLuvio because we want environments
         // that don't have onestore bootstrapped with the required services to default to the luvio versions of the adapters
-        registerCallback((oneStoreGraphql, oneStoreGraphql_imperative, useOneStoreGraphQL) => {
+        registerCallback((oneStoreGraphql, oneStoreGraphql_imperative, oneStoreGraphql_imperative_legacy, useOneStoreGraphQL) => {
             if (useOneStoreGraphQL) {
                 graphql = oneStoreGraphql;
-                graphql_imperative = oneStoreGraphql_imperative;
+                graphql_imperative = oneStoreGraphql_imperative_legacy;
+                refreshGraphQL = (data) => {
+                    if (typeof data?.refresh === 'function') {
+                        return data.refresh();
+                    }
+                    throw new Error('Component attempted to refresh a GraphQL result that is not refreshable');
+                };
             }
         });
     });
@@ -130910,14 +131231,7 @@
         configuration: { ...configurationForGraphQLAdapters$1 },
         instrument: instrument$1,
     });
-    function refreshGraphQL(data) {
-        // If OneStore data, call its refresh instead
-        if (typeof data?.refresh === 'function') {
-            return data.refresh();
-        }
-        return refresh$3(data, 'refreshUiApi');
-    }
-    // version: 1.382.0-73d929ea11
+    // version: 1.384.0-835fd13f44
 
     // On core the unstable adapters are re-exported with different names,
     // we want to match them here.
@@ -130929,7 +131243,7 @@
         gql: gql,
         get graphql () { return graphql; },
         get graphqlBatch () { return graphqlBatch; },
-        refreshGraphQL: refreshGraphQL,
+        get refreshGraphQL () { return refreshGraphQL; },
         get unstable_getActionOverrides_imperative () { return unstable_getActionOverrides_imperative; },
         get unstable_getFlexipageFormulaOverrides_imperative () { return unstable_getFlexipageFormulaOverrides_imperative; },
         get unstable_getGlobalActions_imperative () { return unstable_getGlobalActions_imperative; },
@@ -131069,7 +131383,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.382.0-73d929ea11
+    // version: 1.384.0-835fd13f44
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -131868,7 +132182,7 @@
     function register(r) {
         callbacks$1.forEach((callback) => callback(r));
     }
-    // version: 1.382.0-8ca71123b0
+    // version: 1.384.0-cb845692ac
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -133205,4 +133519,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.382.0-8ca71123b0
+// version: 1.384.0-cb845692ac