@salesforce/lds-runtime-webruntime 1.401.0 → 1.402.0

package/dist/ldsWebruntimeOneStoreInit.js

@@ -16,6 +16,7 @@ import { getInstrumentation } from 'o11y/client';
 import 'force/luvioTypeNormalization1';
 import { setServices } from 'force/luvioServiceProvisioner1';
 export { default, resolve, setServices } from 'force/luvioServiceProvisioner1';
+import { withDefaultLuvio } from 'force/ldsEngine';
 import { getSfapJwt } from 'force/clwrSfapExchange';
 import language from '@salesforce/i18n/lang';
 import isDesignMode from '@app/isDesignMode';
@@ -31,14 +32,15 @@ import apiBasePath from '@app/apiBasePath';
 const { create, freeze, keys, entries } = Object;
 const { isArray: isArray$1 } = Array;
 const { stringify: stringify$1, parse: parse$1 } = JSON;
-const LogLevelMap$1 = {
+const WeakSetConstructor = WeakSet;
+const LogLevelMap = {
   TRACE: 4,
   DEBUG: 3,
   INFO: 2,
   WARN: 1,
   ERROR: 0
 };
-let ConsoleLogger$1 = class ConsoleLogger {
+class ConsoleLogger {
   constructor(level = "WARN", printer = console.log, formatter = (level2, message) => `${level2}: ${message}`) {
     this.level = level;
     this.printer = printer;
@@ -61,12 +63,15 @@ let ConsoleLogger$1 = class ConsoleLogger {
     this.log("ERROR", message);
   }
   log(level, message) {
-    if (LogLevelMap$1[level] > LogLevelMap$1[this.level]) {
+    if (LogLevelMap[level] > LogLevelMap[this.level]) {
       return;
     }
     this.printer(this.formatter(level, message));
   }
-};
+}
+function loggerService$1(level, printer, formatter) {
+  return new ConsoleLogger(level, printer, formatter);
+}
 let Ok$2 = class Ok {
   constructor(value) {
     this.value = value;
@@ -110,43 +115,79 @@ function buildSubscribableResult$1(result, subscribe, refresh) {
     return err$1({ failure: result.error, subscribe, refresh });
   }
 }
-function resolvedPromiseLike$3(result) {
-  if (isPromiseLike$3(result)) {
+function resolvedPromiseLike$2(result) {
+  if (isPromiseLike$2(result)) {
     return result.then((nextResult) => nextResult);
   }
   return {
     then: (onFulfilled, _onRejected) => {
       try {
-        return resolvedPromiseLike$3(onFulfilled(result));
+        return resolvedPromiseLike$2(onFulfilled(result));
       } catch (e) {
         if (onFulfilled === void 0) {
-          return resolvedPromiseLike$3(result);
+          return resolvedPromiseLike$2(result);
         }
-        return rejectedPromiseLike$3(e);
+        return rejectedPromiseLike$2(e);
       }
     }
   };
 }
-function rejectedPromiseLike$3(reason) {
-  if (isPromiseLike$3(reason)) {
+function rejectedPromiseLike$2(reason) {
+  if (isPromiseLike$2(reason)) {
     return reason.then((nextResult) => nextResult);
   }
   return {
     then: (_onFulfilled, onRejected) => {
       if (typeof onRejected === "function") {
         try {
-          return resolvedPromiseLike$3(onRejected(reason));
+          return resolvedPromiseLike$2(onRejected(reason));
         } catch (e) {
-          return rejectedPromiseLike$3(e);
+          return rejectedPromiseLike$2(e);
         }
       }
-      return rejectedPromiseLike$3(reason);
+      return rejectedPromiseLike$2(reason);
     }
   };
 }
-function isPromiseLike$3(x) {
+function isPromiseLike$2(x) {
   return typeof (x == null ? void 0 : x.then) === "function";
 }
+function deepEquals$1(x, y) {
+  if (x === void 0) {
+    return y === void 0;
+  } else if (x === null) {
+    return y === null;
+  } else if (y === null) {
+    return x === null;
+  } else if (isArray$1(x)) {
+    if (!isArray$1(y) || x.length !== y.length) {
+      return false;
+    }
+    for (let i = 0; i < x.length; ++i) {
+      if (!deepEquals$1(x[i], y[i])) {
+        return false;
+      }
+    }
+    return true;
+  } else if (typeof x === "object") {
+    if (typeof y !== "object") {
+      return false;
+    }
+    const xkeys = Object.keys(x);
+    const ykeys = Object.keys(y);
+    if (xkeys.length !== ykeys.length) {
+      return false;
+    }
+    for (let i = 0; i < xkeys.length; ++i) {
+      const key = xkeys[i];
+      if (!deepEquals$1(x[key], y[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return x === y;
+}
 function stableJSONStringify(node) {
   if (node && node.toJSON && typeof node.toJSON === "function") {
     node = node.toJSON();
@@ -237,6 +278,24 @@ class FetchResponse extends Error {
     this.statusText = getStatusText(status);
   }
 }
+const deeplyFrozen = new WeakSetConstructor();
+function deepFreeze(value) {
+  if (typeof value !== "object" || value === null || deeplyFrozen.has(value)) {
+    return;
+  }
+  deeplyFrozen.add(value);
+  if (isArray$1(value)) {
+    for (let i = 0, len = value.length; i < len; i += 1) {
+      deepFreeze(value[i]);
+    }
+  } else {
+    const keys$1 = keys(value);
+    for (let i = 0, len = keys$1.length; i < len; i += 1) {
+      deepFreeze(value[keys$1[i]]);
+    }
+  }
+  freeze(value);
+}
 class InternalError extends Error {
   constructor(data) {
     super();
@@ -251,6 +310,15 @@ class UserVisibleError extends Error {
     this.type = "user-visible";
   }
 }
+function isUserVisibleError$1(error) {
+  return error instanceof Error && "type" in error && error.type === "user-visible";
+}
+function logError$1(error) {
+  if (isUserVisibleError$1(error)) {
+    return;
+  }
+  console.error("OneStore Command threw an error that we did not expect", error);
+}
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -307,7 +375,7 @@ let NetworkCommand$1 = class NetworkCommand extends BaseCommand {
   async afterRequestHooks(_options) {
   }
 };
-function buildServiceDescriptor$j() {
+function buildServiceDescriptor$q() {
   return {
     type: "networkCommandBaseClass",
     version: "1.0",
@@ -406,10 +474,10 @@ class AuraNetworkCommand extends NetworkCommand$1 {
     } else if (this.shouldUseFetch()) {
       return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
     }
-    return resolvedPromiseLike$3(err$1(toError("Aura/Fetch network services not found")));
+    return resolvedPromiseLike$2(err$1(toError("Aura/Fetch network services not found")));
   }
 }
-function buildServiceDescriptor$i() {
+function buildServiceDescriptor$p() {
   return {
     type: "auraNetworkCommandBaseClass",
     version: "1.0",
@@ -459,41 +527,41 @@ function buildSubscribableResult(result, subscribe, refresh) {
     return err({ failure: result.error, subscribe, refresh });
   }
 }
-function resolvedPromiseLike$2(result) {
-  if (isPromiseLike$2(result)) {
+function resolvedPromiseLike$1(result) {
+  if (isPromiseLike$1(result)) {
     return result.then((nextResult) => nextResult);
   }
   return {
     then: (onFulfilled, _onRejected) => {
       try {
-        return resolvedPromiseLike$2(onFulfilled(result));
+        return resolvedPromiseLike$1(onFulfilled(result));
       } catch (e) {
         if (onFulfilled === void 0) {
-          return resolvedPromiseLike$2(result);
+          return resolvedPromiseLike$1(result);
         }
-        return rejectedPromiseLike$2(e);
+        return rejectedPromiseLike$1(e);
       }
     }
   };
 }
-function rejectedPromiseLike$2(reason) {
-  if (isPromiseLike$2(reason)) {
+function rejectedPromiseLike$1(reason) {
+  if (isPromiseLike$1(reason)) {
     return reason.then((nextResult) => nextResult);
   }
   return {
     then: (_onFulfilled, onRejected) => {
       if (typeof onRejected === "function") {
         try {
-          return resolvedPromiseLike$2(onRejected(reason));
+          return resolvedPromiseLike$1(onRejected(reason));
         } catch (e) {
-          return rejectedPromiseLike$2(e);
+          return rejectedPromiseLike$1(e);
         }
       }
-      return rejectedPromiseLike$2(reason);
+      return rejectedPromiseLike$1(reason);
     }
   };
 }
-function isPromiseLike$2(x) {
+function isPromiseLike$1(x) {
   return typeof (x == null ? void 0 : x.then) === "function";
 }
 function deepEquals(x, y) {
@@ -728,7 +796,7 @@ class CacheControlCommand extends BaseCommand {
         });
       }
     }
-    return resolvedPromiseLike$2(void 0);
+    return resolvedPromiseLike$1(void 0);
   }
   get operationType() {
     return "query";
@@ -1004,7 +1072,7 @@ let AuraCacheControlCommand$1 = class AuraCacheControlCommand extends CacheContr
     } else if (this.shouldUseFetch()) {
       return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
     }
-    return resolvedPromiseLike$3(err$1(toError("Aura/Fetch network services not found")));
+    return resolvedPromiseLike$2(err$1(toError("Aura/Fetch network services not found")));
   }
   coerceAuraErrors(auraErrors) {
     return toError(auraErrors[0]);
@@ -1078,9 +1146,9 @@ class AuraResourceCacheControlCommand extends AuraCacheControlCommand$1 {
     var _a;
     const data = (_a = cache.get(this.buildKey())) == null ? void 0 : _a.value;
     if (data === void 0) {
-      return resolvedPromiseLike$3(err$1(new Error("Failed to find data in cache")));
+      return resolvedPromiseLike$2(err$1(new Error("Failed to find data in cache")));
     }
-    return resolvedPromiseLike$3(ok$2(data));
+    return resolvedPromiseLike$2(ok$2(data));
   }
   writeToCache(cache, networkResult) {
     if (networkResult.isOk()) {
@@ -1091,13 +1159,13 @@ class AuraResourceCacheControlCommand extends AuraCacheControlCommand$1 {
         }
       });
     }
-    return resolvedPromiseLike$3(void 0);
+    return resolvedPromiseLike$2(void 0);
   }
   buildKey() {
     return `{"endpoint":${this.endpoint},"params":${stableJSONStringify(this.auraParams)}}`;
   }
 }
-function buildServiceDescriptor$h() {
+function buildServiceDescriptor$o() {
   return {
     type: "auraResourceCacheControlCommand",
     version: "1.0",
@@ -1147,7 +1215,7 @@ class AuraCacheControlCommand extends CacheControlCommand {
     } else if (this.shouldUseFetch()) {
       return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
     }
-    return resolvedPromiseLike$3(err$1(toError("Aura/Fetch network services not found")));
+    return resolvedPromiseLike$2(err$1(toError("Aura/Fetch network services not found")));
   }
   coerceAuraErrors(auraErrors) {
     return toError(auraErrors[0]);
@@ -1220,11 +1288,11 @@ class AuraNormalizedCacheControlCommand extends AuraCacheControlCommand {
   readFromCache(cache) {
     const data = this.buildResultType().query(cache, this.buildQuery());
     if (data.isErr()) {
-      return resolvedPromiseLike$3(
+      return resolvedPromiseLike$2(
         err$1(new Error(`Failed to build data from type: ${stringify$1(data.error)}`))
       );
     }
-    return resolvedPromiseLike$3(ok$2(data.value));
+    return resolvedPromiseLike$2(ok$2(data.value));
   }
   writeToCache(cache, networkResult) {
     if (networkResult.isOk()) {
@@ -1233,10 +1301,10 @@ class AuraNormalizedCacheControlCommand extends AuraCacheControlCommand {
         this.buildWriteInput(networkResult.value)
       );
     }
-    return resolvedPromiseLike$3(void 0);
+    return resolvedPromiseLike$2(void 0);
   }
 }
-function buildServiceDescriptor$g() {
+function buildServiceDescriptor$n() {
   return {
     type: "auraNormalizedCacheControlCommand",
     version: "1.0",
@@ -1309,11 +1377,11 @@ class HttpNormalizedCacheControlCommand extends HttpCacheControlCommand {
   readFromCache(cache) {
     const data = this.buildResultType().query(cache, this.buildQuery());
     if (data.isErr()) {
-      return resolvedPromiseLike$3(
+      return resolvedPromiseLike$2(
         err$1(new Error(`Failed to build data from type: ${stringify$1(data.error)}`))
       );
     }
-    return resolvedPromiseLike$3(ok$2(data.value));
+    return resolvedPromiseLike$2(ok$2(data.value));
   }
   writeToCache(cache, networkResult) {
     if (networkResult.isOk()) {
@@ -1322,10 +1390,10 @@ class HttpNormalizedCacheControlCommand extends HttpCacheControlCommand {
         this.buildWriteInput(networkResult.value)
       );
     }
-    return resolvedPromiseLike$3(void 0);
+    return resolvedPromiseLike$2(void 0);
   }
 }
-function buildServiceDescriptor$f() {
+function buildServiceDescriptor$m() {
   return {
     type: "httpNormalizedCacheControlCommand",
     version: "1.0",
@@ -1503,7 +1571,7 @@ _FetchNetworkCommand.availableDecorators = {
   abortable: createAbortableDecorator
 };
 let FetchNetworkCommand = _FetchNetworkCommand;
-function buildServiceDescriptor$e() {
+function buildServiceDescriptor$l() {
   return {
     type: "fetchNetworkCommandBaseClass",
     version: "1.0",
@@ -1539,7 +1607,7 @@ class StreamingCommand extends BaseCommand {
     );
   }
 }
-function buildServiceDescriptor$d() {
+function buildServiceDescriptor$k() {
   return {
     type: "streamingCommandBaseClass",
     version: "1.0",
@@ -1622,7 +1690,7 @@ class SSEParsingStream extends TransformStream {
     });
   }
 }
-function buildServiceDescriptor$c() {
+function buildServiceDescriptor$j() {
   return {
     type: "SSECommandBaseClass",
     version: "1.0",
@@ -1673,7 +1741,7 @@ function buildInstrumentCommand(services) {
     };
   };
 }
-function buildServiceDescriptor$b(instrumentation) {
+function buildServiceDescriptor$i(instrumentation) {
   return {
     type: "instrumentCommand",
     version: "1.0",
@@ -1943,7 +2011,7 @@ class O11yInstrumentation {
     this.metrics = new O11yOTelMetricsAPI(this.services);
   }
 }
-function buildServiceDescriptor$a(logger) {
+function buildServiceDescriptor$h(logger) {
   return {
     type: "instrumentation",
     version: "1.0",
@@ -2196,7 +2264,7 @@ class DefaultCache {
     return new FixedTimeWritableCache(this, generatedTime);
   }
 }
-function buildServiceDescriptor$9() {
+function buildServiceDescriptor$g() {
   return {
     type: "cache",
     version: "1.0",
@@ -2419,7 +2487,7 @@ class CacheController {
     yield* this.services.cacheInclusionPolicy.findAndModify(query, cacheUpdate);
   }
 }
-function buildServiceDescriptor$8(cache, cacheInclusionPolicy, instrumentation) {
+function buildServiceDescriptor$f(cache, cacheInclusionPolicy, instrumentation) {
   return {
     type: "cacheController",
     version: "1.0",
@@ -2432,48 +2500,6 @@ function buildServiceDescriptor$8(cache, cacheInclusionPolicy, instrumentation)
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-/*!
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-function resolvedPromiseLike$1(result) {
-  if (isPromiseLike$1(result)) {
-    return result.then((nextResult) => nextResult);
-  }
-  return {
-    then: (onFulfilled, _onRejected) => {
-      try {
-        return resolvedPromiseLike$1(onFulfilled(result));
-      } catch (e) {
-        if (onFulfilled === void 0) {
-          return resolvedPromiseLike$1(result);
-        }
-        return rejectedPromiseLike$1(e);
-      }
-    }
-  };
-}
-function rejectedPromiseLike$1(reason) {
-  if (isPromiseLike$1(reason)) {
-    return reason.then((nextResult) => nextResult);
-  }
-  return {
-    then: (_onFulfilled, onRejected) => {
-      if (typeof onRejected === "function") {
-        try {
-          return resolvedPromiseLike$1(onRejected(reason));
-        } catch (e) {
-          return rejectedPromiseLike$1(e);
-        }
-      }
-      return rejectedPromiseLike$1(reason);
-    }
-  };
-}
-function isPromiseLike$1(x) {
-  return typeof (x == null ? void 0 : x.then) === "function";
-}
 const EventTypeWildcard = Symbol("EventTypeWildcard");
 class DefaultPubSubService {
   constructor() {
@@ -2501,14 +2527,14 @@ class DefaultPubSubService {
         return;
       }
       const returnVal = subscription.callback.call(subscription, event);
-      if (isPromiseLike$1(returnVal)) {
+      if (isPromiseLike$2(returnVal)) {
         promises.push(returnVal);
       }
     });
     if (promises.length > 0) {
       return Promise.all(promises).then(() => void 0);
     }
-    return resolvedPromiseLike$1(void 0);
+    return resolvedPromiseLike$2(void 0);
   }
   getSubscriptions(event) {
     const eventTypeSubscriptions = this.subscriptions.get(event.type);
@@ -2529,7 +2555,7 @@ class DefaultPubSubService {
     return matchingSubscriptions;
   }
 }
-function buildServiceDescriptor$7() {
+function buildServiceDescriptor$e() {
   return {
     type: "pubSub",
     version: "1.0",
@@ -2740,7 +2766,7 @@ class FeatureFlagsService {
     return this.flags.get(flagName) || defaultValue;
   }
 }
-function buildServiceDescriptor$6() {
+function buildServiceDescriptor$d() {
   return {
     version: "1.0",
     service: new FeatureFlagsService(),
@@ -3587,6 +3613,62 @@ function hasMultilineItems(maybeArray) {
   var _maybeArray$some;
   return (_maybeArray$some = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.some((str) => str.includes("\n"))) !== null && _maybeArray$some !== void 0 ? _maybeArray$some : false;
 }
+const referenceMap = /* @__PURE__ */ new WeakMap();
+const astResolver = function(astReference) {
+  return referenceMap.get(astReference);
+};
+function findExecutableOperation$1(document, operationName) {
+  const operations = document.definitions.filter(
+    (def) => def.kind === Kind.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$1(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 || ast === void 0) {
+    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, options) {
+  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: (options == null ? void 0 : options.acceptedOperations) ?? ["query"]
+    });
+  }
+  return config;
+}
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -3803,7 +3885,7 @@ class AuraGraphQLNormalizedCacheControlCommand extends AuraNormalizedCacheContro
         return buildSubscribableResult$1(result, this.buildSubscribe(), () => this.refresh());
       });
     }
-    return resolvedPromiseLike$3(
+    return resolvedPromiseLike$2(
       buildSubscribableResult$1(
         err$1(toError("Aura/Fetch network services not found")),
         this.buildSubscribe(),
@@ -3845,7 +3927,7 @@ class AuraGraphQLNormalizedCacheControlCommand extends AuraNormalizedCacheContro
     });
   }
 }
-function buildServiceDescriptor$5() {
+function buildServiceDescriptor$c() {
   return {
     type: "auraGraphQLNormalizedCacheControlCommand",
     version: "1.0",
@@ -3963,7 +4045,7 @@ class HttpGraphQLNormalizedCacheControlCommand extends HttpNormalizedCacheContro
     });
   }
 }
-function buildServiceDescriptor$4() {
+function buildServiceDescriptor$b() {
   return {
     type: "httpGraphQLNormalizedCacheControlCommand",
     version: "1.0",
@@ -4026,7 +4108,7 @@ class NDJSONParsingStream extends TransformStream {
     });
   }
 }
-function buildServiceDescriptor$3() {
+function buildServiceDescriptor$a() {
   return {
     type: "NDJSONCommandBaseClass",
     version: "1.0",
@@ -4067,7 +4149,7 @@ function buildServiceDescriptor$3() {
  * };
  * ```
  */
-function buildServiceDescriptor$2(luvio) {
+function buildServiceDescriptor$9(luvio) {
     return {
         type: 'luvio',
         version: '1.0',
@@ -4076,7 +4158,7 @@ function buildServiceDescriptor$2(luvio) {
         },
     };
 }
-// version: 1.401.0-c620f9ffed
+// version: 1.402.0-566b6c5389
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -4092,7 +4174,7 @@ function buildServiceDescriptor$2(luvio) {
  *  *******************************************************************************************
  */
 /* proxy-compat-disable */
-function buildServiceDescriptor$1(notifyRecordUpdateAvailable, getNormalizedLuvioRecord) {
+function buildServiceDescriptor$8(notifyRecordUpdateAvailable, getNormalizedLuvioRecord) {
     return {
         type: 'luvioUiapiRecords',
         version: '1.0',
@@ -4102,105 +4184,1201 @@ function buildServiceDescriptor$1(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.401.0-c620f9ffed
+// version: 1.402.0-566b6c5389
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-function e(e2) {
-  this.message = e2;
-}
-e.prototype = new Error(), e.prototype.name = "InvalidCharacterError";
-var r = "undefined" != typeof window && window.atob && window.atob.bind(window) || function(r2) {
-  var t2 = String(r2).replace(/=+$/, "");
-  if (t2.length % 4 == 1) throw new e("'atob' failed: The string to be decoded is not correctly encoded.");
-  for (var n2, o2, a = 0, i = 0, c = ""; o2 = t2.charAt(i++); ~o2 && (n2 = a % 4 ? 64 * n2 + o2 : o2, a++ % 4) ? c += String.fromCharCode(255 & n2 >> (-2 * a & 6)) : 0) o2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(o2);
-  return c;
-};
-function t(e2) {
-  var t2 = e2.replace(/-/g, "+").replace(/_/g, "/");
-  switch (t2.length % 4) {
-    case 0:
-      break;
-    case 2:
-      t2 += "==";
-      break;
-    case 3:
-      t2 += "=";
-      break;
-    default:
-      throw "Illegal base64url string!";
-  }
-  try {
-    return (function(e3) {
-      return decodeURIComponent(r(e3).replace(/(.)/g, (function(e4, r2) {
-        var t3 = r2.charCodeAt(0).toString(16).toUpperCase();
-        return t3.length < 2 && (t3 = "0" + t3), "%" + t3;
-      })));
-    })(t2);
-  } catch (e3) {
-    return r(t2);
+class JsonSchemaViolationError extends Error {
+  constructor(message, validationErrors) {
+    super(message);
+    this.validationErrors = [];
+    this.validationErrors = validationErrors || [];
   }
 }
-function n(e2) {
-  this.message = e2;
+class MinItemsViolationError extends JsonSchemaViolationError {
 }
-function o(e2, r2) {
-  if ("string" != typeof e2) throw new n("Invalid token specified");
-  var o2 = true === (r2 = r2 || {}).header ? 0 : 1;
-  try {
-    return JSON.parse(t(e2.split(".")[o2]));
-  } catch (e3) {
-    throw new n("Invalid token specified: " + e3.message);
-  }
+class MaxItemsViolationError extends JsonSchemaViolationError {
 }
-n.prototype = new Error(), n.prototype.name = "InvalidTokenError";
-/*!
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-const LogLevelMap = {
-  TRACE: 4,
-  DEBUG: 3,
-  INFO: 2,
-  WARN: 1,
-  ERROR: 0
-};
-class ConsoleLogger {
-  constructor(level = "WARN", printer = console.log, formatter = (level2, message) => `${level2}: ${message}`) {
-    this.level = level;
-    this.printer = printer;
-    this.formatter = formatter;
-    this.messages = [];
-  }
-  trace(message) {
-    this.log("TRACE", message);
+class IncorrectTypeError extends JsonSchemaViolationError {
+}
+class AdditionalPropertiesError extends JsonSchemaViolationError {
+}
+class MissingRequiredPropertyError extends JsonSchemaViolationError {
+}
+class InvalidRefError extends JsonSchemaViolationError {
+}
+class JsonSchemaErrorCollector {
+  constructor() {
+    this.errors = [];
   }
-  debug(message) {
-    this.log("DEBUG", message);
+  add(error) {
+    this.errors.push(error);
   }
-  info(message) {
-    this.log("INFO", message);
+  append(response) {
+    if (response.isErr()) {
+      this.errors.push(...response.error);
+    }
   }
-  warn(message) {
-    this.log("WARN", message);
+  hasErrors() {
+    return this.errors.length > 0;
   }
-  error(message) {
-    this.log("ERROR", message);
+  prepend(error) {
+    this.errors.unshift(error);
   }
-  log(level, message) {
-    if (LogLevelMap[level] > LogLevelMap[this.level]) {
-      return;
-    }
-    this.printer(this.formatter(level, message));
+  toValidationResponse() {
+    return !this.hasErrors() ? ok$2(true) : err$1(this.errors);
   }
 }
-function loggerService$1(level, printer, formatter) {
-  return new ConsoleLogger(level, printer, formatter);
+function createThrowableError(errors) {
+  if (errors[0] instanceof MinItemsViolationError) {
+    return new MinItemsViolationError(errors[0].message, errors);
+  }
+  if (errors[0] instanceof MaxItemsViolationError) {
+    return new MaxItemsViolationError(errors[0].message, errors);
+  }
+  if (errors[0] instanceof IncorrectTypeError) {
+    return new IncorrectTypeError(errors[0].message, errors);
+  }
+  if (errors[0] instanceof AdditionalPropertiesError) {
+    return new AdditionalPropertiesError(errors[0].message, errors);
+  }
+  if (errors[0] instanceof MissingRequiredPropertyError) {
+    return new MissingRequiredPropertyError(errors[0].message, errors);
+  }
+  if (errors[0] instanceof InvalidRefError) {
+    return new InvalidRefError(errors[0].message, errors);
+  }
+  return new JsonSchemaViolationError(errors[0].message, errors);
+}
+function assertIsValid(data, schema) {
+  const validationResponse = validateJsonSchema(data, schema);
+  if (validationResponse.isErr()) {
+    throw createThrowableError(validationResponse.error);
+  }
+}
+function incorrectTypeError(expected, actual, path) {
+  return new IncorrectTypeError(
+    `Expected type ${expected} at path '${path}', found type ${actual}.`
+  );
+}
+function validSchemaResponse() {
+  return ok$2(true);
+}
+function invalidSchemaResponseWithError(error) {
+  return err$1([error]);
+}
+function validateJsonSchema(data, schema, path = "$", document = schema) {
+  if (schema === true) return validSchemaResponse();
+  if (schema === false)
+    return invalidSchemaResponseWithError(
+      new JsonSchemaViolationError(`Data at ${path} has schema 'false'`)
+    );
+  const dataType = data === null ? "null" : Array.isArray(data) ? "array" : typeof data;
+  const errorCollector = new JsonSchemaErrorCollector();
+  if ("anyOf" in schema) {
+    errorCollector.append(validateAnyOf(data, schema, path, document));
+  } else if ("oneOf" in schema) {
+    errorCollector.append(validateOneOf(data, schema, path, document));
+  } else if ("allOf" in schema) {
+    errorCollector.append(validateAllOf(data, schema, path, document));
+  } else if ("not" in schema) {
+    errorCollector.append(validateNot(data, schema, path, document));
+  } else if ("$ref" in schema) {
+    errorCollector.append(validateRef(data, schema, path, document));
+  } else if ("type" in schema) {
+    if (schema.type === "object") {
+      if (dataType !== "object") {
+        errorCollector.add(incorrectTypeError("object", dataType, path));
+      } else {
+        errorCollector.append(
+          validateObject(data, schema, path, document)
+        );
+      }
+    } else if (schema.type === "array") {
+      if (dataType !== "array") {
+        errorCollector.add(incorrectTypeError("array", dataType, path));
+      } else {
+        errorCollector.append(
+          validateArray(data, schema, path, document)
+        );
+      }
+    } else {
+      errorCollector.append(
+        validateScalar(data, schema, path)
+      );
+    }
+  }
+  if (schema.enum) {
+    errorCollector.append(validateEnum(data, schema.enum, path));
+  }
+  if (schema.const) {
+    errorCollector.append(validateConst(data, schema.const, path));
+  }
+  return errorCollector.toValidationResponse();
+}
+function validateAnyOf(data, schema, path, document) {
+  let isValid = false;
+  const errorCollector = new JsonSchemaErrorCollector();
+  for (let i = 0, { length } = schema.anyOf; i < length; i++) {
+    const element = schema.anyOf[i];
+    const validationResponse = validateJsonSchema(
+      data,
+      element,
+      `${path}.anyOf[${i}]`,
+      document
+    );
+    if (validationResponse.isOk()) {
+      isValid = true;
+      break;
+    } else {
+      errorCollector.append(validationResponse);
+    }
+  }
+  if (!isValid) {
+    errorCollector.prepend(
+      new JsonSchemaViolationError(`Data at ${path} did not match any subschema in anyOf.`)
+    );
+    return errorCollector.toValidationResponse();
+  }
+  return validSchemaResponse();
+}
+function validateOneOf(data, schema, path, document) {
+  let validSubShemaPaths = [];
+  const errorCollector = new JsonSchemaErrorCollector();
+  for (let i = 0, { length } = schema.oneOf; i < length; i++) {
+    const element = schema.oneOf[i];
+    const oneOfPath = `${path}.oneOf[${i}]`;
+    const validationResponse = validateJsonSchema(data, element, oneOfPath, document);
+    if (validationResponse.isOk()) {
+      validSubShemaPaths.push(oneOfPath);
+    } else {
+      errorCollector.append(validationResponse);
+    }
+  }
+  if (validSubShemaPaths.length === 0) {
+    errorCollector.prepend(
+      new JsonSchemaViolationError(`Data at ${path} did not match any subschema in oneOf.`)
+    );
+    return errorCollector.toValidationResponse();
+  } else if (validSubShemaPaths.length > 1) {
+    errorCollector.prepend(
+      new JsonSchemaViolationError(
+        `Data at ${path} matched multiple subschemas: [${validSubShemaPaths.join(", ")}].`
+      )
+    );
+    return errorCollector.toValidationResponse();
+  }
+  return validSchemaResponse();
+}
+function validateAllOf(data, schema, path, document) {
+  let isValid = true;
+  const errorCollector = new JsonSchemaErrorCollector();
+  for (let i = 0, { length } = schema.allOf; i < length; i++) {
+    const element = schema.allOf[i];
+    const validationResponse = validateJsonSchema(
+      data,
+      element,
+      `${path}.allOf[${i}]`,
+      document
+    );
+    if (!validationResponse.isOk()) {
+      errorCollector.append(validationResponse);
+      isValid = false;
+    }
+  }
+  if (!isValid) {
+    errorCollector.prepend(
+      new JsonSchemaViolationError(`Data at ${path} did not match some subschemas in allOf.`)
+    );
+  }
+  return errorCollector.toValidationResponse();
+}
+function validateNot(data, schema, path, document) {
+  const validationResponse = validateJsonSchema(data, schema.not, path, document);
+  if (validationResponse.isOk()) {
+    return invalidSchemaResponseWithError(
+      new JsonSchemaViolationError(
+        `Data at ${path} validated against the schema of a not clause.`
+      )
+    );
+  }
+  return validSchemaResponse();
+}
+function validateObject(data, schema, path, document) {
+  const schemaKeys = Object.keys(schema.properties);
+  const requiredKeys = new Set(schema.required);
+  const schemaKeySet = new Set(schemaKeys);
+  const errorCollector = new JsonSchemaErrorCollector();
+  Object.keys(data).forEach((key) => {
+    if (!schemaKeySet.has(key)) {
+      errorCollector.append(
+        validateJsonSchema(
+          data[key],
+          schema.additionalProperties,
+          `${path}.additionalProperties[${key}]`,
+          document
+        )
+      );
+    }
+  });
+  for (let i = 0, length = schemaKeys.length; i < length; i++) {
+    const key = schemaKeys[i];
+    const keyInData = key in data && data[key] !== void 0;
+    if (requiredKeys.has(key) && !keyInData) {
+      errorCollector.add(
+        new MissingRequiredPropertyError(
+          `Object at path '${path}' is missing required property '${key}'.`
+        )
+      );
+    }
+    if (keyInData) {
+      errorCollector.append(
+        validateJsonSchema(
+          data[key],
+          schema.properties[key],
+          `${path}.${key}`,
+          document
+        )
+      );
+    }
+  }
+  return errorCollector.toValidationResponse();
+}
+function validateArray(data, schema, path, document) {
+  if (schema.minItems !== void 0 && data.length < schema.minItems) {
+    return invalidSchemaResponseWithError(
+      new MinItemsViolationError(
+        `Array at path '${path}' fails minItems constraint. Has ${data.length} items, needs at least ${schema.minItems}.`
+      )
+    );
+  }
+  if (schema.maxItems !== void 0 && data.length > schema.maxItems) {
+    return invalidSchemaResponseWithError(
+      new MaxItemsViolationError(
+        `Array at path '${path}' fails maxItems constraint. Has ${data.length} items, needs at most ${schema.maxItems}.`
+      )
+    );
+  }
+  const errorCollector = new JsonSchemaErrorCollector();
+  data.forEach(
+    (element, index) => errorCollector.append(
+      validateJsonSchema(element, schema.items, `${path}[${index}]`, document)
+    )
+  );
+  return errorCollector.toValidationResponse();
+}
+function validateScalar(data, schema, path) {
+  const schemaDataType = schema.type;
+  const dataType = typeof data;
+  if (schemaDataType === "integer") {
+    if (dataType !== "number" || !Number.isInteger(data)) {
+      return invalidSchemaResponseWithError(incorrectTypeError("integer", dataType, path));
+    }
+  } else if (schemaDataType === "number") {
+    if (dataType !== "number") {
+      return invalidSchemaResponseWithError(incorrectTypeError("number", dataType, path));
+    }
+  } else if (schemaDataType === "string") {
+    if (dataType !== "string") {
+      return invalidSchemaResponseWithError(incorrectTypeError("string", dataType, path));
+    }
+  } else if (schemaDataType === "boolean") {
+    if (dataType !== "boolean") {
+      return invalidSchemaResponseWithError(incorrectTypeError("boolean", dataType, path));
+    }
+  } else if (schemaDataType === "null") {
+    if (data !== null) {
+      return invalidSchemaResponseWithError(incorrectTypeError("null", dataType, path));
+    }
+  } else {
+    return invalidSchemaResponseWithError(
+      new IncorrectTypeError(`Unknown schema data type: ${schemaDataType}.`)
+    );
+  }
+  return validSchemaResponse();
+}
+function validateRef(data, schema, path, document) {
+  if (!schema.$ref.startsWith("#")) {
+    return invalidSchemaResponseWithError(
+      new InvalidRefError(
+        `$ref values that do not refer to the current document are unsupported (must start with '#')`
+      )
+    );
+  }
+  try {
+    const schemaToValidate = findSchemaAtPath(document, schema.$ref);
+    return validateJsonSchema(data, schemaToValidate, path, document);
+  } catch (e) {
+    return invalidSchemaResponseWithError(e);
+  }
+}
+function validateEnum(data, enumValue, path) {
+  if (!enumValue.some((value) => deepEquals$1(value, data))) {
+    return invalidSchemaResponseWithError(
+      new JsonSchemaViolationError(
+        `Data at ${path} did not match any values in enum. Expected value in: [${enumValue.map((value) => stringify$1(value)).join()}]`
+      )
+    );
+  }
+  return validSchemaResponse();
+}
+function validateConst(data, constValue, path) {
+  if (!deepEquals$1(constValue, data)) {
+    return invalidSchemaResponseWithError(
+      new JsonSchemaViolationError(
+        `Data at ${path} did not match const. Expected: ${stringify$1(constValue)}`
+      )
+    );
+  }
+  return validSchemaResponse();
+}
+function findSchemaAtPath(document, ref) {
+  if (ref === "#") return document;
+  const keys = ref.replace(/^#\//, "").split("/");
+  let current = document;
+  let path = "#";
+  for (const key of keys) {
+    path = `${path}/${key}`;
+    if (current[key] === void 0) {
+      throw new InvalidRefError(
+        `Invalid $ref value '${ref}'. Cannot find target schema at '${path}'`
+      );
+    }
+    current = current[key];
+  }
+  return current;
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+function isUserVisibleError(error) {
+  return error instanceof Error && "type" in error && error.type === "user-visible";
+}
+function throwUserlandError(error) {
+  logError(error);
+  throw buildUserlandError(error);
+}
+function emitError(callback, error) {
+  logError(error);
+  callback({ data: void 0, error: buildUserlandError(error) });
+}
+function buildUserlandError(error) {
+  if (isUserVisibleError(error)) {
+    return error.data;
+  }
+  return new Error("Internal error in Lightning Data Service adapter occurred.");
+}
+function logError(error) {
+  if (isUserVisibleError(error)) {
+    return;
+  }
+  console.error("OneStore Command threw an error that we did not expect", error);
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+function buildBaseImperativeInvoker(getCommand, transformResult) {
+  return async (...params) => {
+    const command = getCommand({ params, assertIsValid });
+    try {
+      return command.execute().then((result) => transformResult(result));
+    } catch (error) {
+      throwUserlandError(error);
+    }
+  };
+}
+const supportedCachePolicyTypes = ["no-cache", "only-if-cached"];
+function requestContextIsSupportedCachePolicy(requestContext) {
+  return typeof requestContext === "object" && requestContext !== null && "cachePolicy" in requestContext && typeof requestContext.cachePolicy === "object" && requestContext.cachePolicy !== null && "type" in requestContext.cachePolicy && typeof requestContext.cachePolicy.type === "string" && supportedCachePolicyTypes.includes(
+    requestContext.cachePolicy.type
+  );
+}
+function getOverridesForLegacyRequestContext(requestContext) {
+  if (requestContextIsSupportedCachePolicy(requestContext)) {
+    return { cacheControlConfig: { type: requestContext.cachePolicy.type } };
+  }
+  return {};
+}
+function handleEmit(res, callback) {
+  const consumerEmittedData = {
+    data: void 0,
+    errors: void 0
+  };
+  if (res.isOk()) {
+    consumerEmittedData.data = res.value.data;
+  } else {
+    const { data, errors } = toGraphQLResponseFromFailure$1(res.error);
+    consumerEmittedData.data = data;
+    consumerEmittedData.errors = errors;
+  }
+  callback(consumerEmittedData);
+}
+function toGraphQLResponseFromFailure$1(failure) {
+  if (isUserVisibleError$1(failure)) {
+    return {
+      data: failure.data.data,
+      errors: failure.data.errors
+    };
+  }
+  logError$1(failure);
+  return {
+    data: void 0,
+    errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+  };
+}
+class DefaultImperativeBindingsService {
+  bind(getCommand) {
+    return buildBaseImperativeInvoker(getCommand, (result) => {
+      if (result.isOk()) {
+        deepFreeze(result.value);
+        return isSubscribableResult(result) ? result.value.data : result.value;
+      }
+      throw toError(isSubscribableResult(result) ? result.error.failure : result.error);
+    });
+  }
+}
+function buildServiceDescriptor$6() {
+  return {
+    type: "defaultImperativeBindings",
+    version: "1.0",
+    service: new DefaultImperativeBindingsService()
+  };
+}
+class QueryImperativeBindingsService {
+  bind(getCommand) {
+    return buildBaseImperativeInvoker(getCommand, (result) => {
+      if (result.isOk()) {
+        deepFreeze(result.value);
+        return isSubscribableResult(result) ? { data: result.value.data } : { data: result.value };
+      }
+      throw toError(isSubscribableResult(result) ? result.error.failure : result.error);
+    });
+  }
+}
+function buildServiceDescriptor$5() {
+  return {
+    type: "queryImperativeBindings",
+    version: "1.0",
+    service: new QueryImperativeBindingsService()
+  };
+}
+class SubscribableImperativeBindingsService {
+  bind(getCommand, exposeRefresh = false) {
+    return buildBaseImperativeInvoker(
+      getCommand,
+      (result) => this.transformResult(result, exposeRefresh)
+    );
+  }
+  transformResult(result, exposeRefresh = false) {
+    if (!isSubscribableResult(result)) {
+      console.error(
+        "Non-subscribable result encountered - please use correct operation type"
+      );
+      throw new Error("Internal error in Lightning Data Service adapter occurred");
+    }
+    if (result.isOk()) {
+      deepFreeze(result.value.data);
+      const api = {
+        data: result.value.data,
+        subscribe: (cb) => {
+          result.value.subscribe((result2) => {
+            if (result2.isErr()) {
+              return cb({ data: void 0, error: toError(result2.error) });
+            }
+            return cb({ data: result2.value, error: void 0 });
+          });
+        }
+      };
+      if (exposeRefresh) {
+        return {
+          ...api,
+          refresh: () => {
+            return result.value.refresh().then((res) => {
+              if (res.isOk()) {
+                return void 0;
+              }
+              throw res.error;
+            });
+          }
+        };
+      } else {
+        return api;
+      }
+    } else {
+      throw toError(result.error.failure);
+    }
+  }
+}
+function buildServiceDescriptor$4() {
+  return {
+    type: "subscribableImperativeBindings",
+    version: "1.0",
+    service: new SubscribableImperativeBindingsService()
+  };
+}
+class LegacyImperativeBindingsService {
+  bind(getCommand) {
+    const invoke = async (config, requestContext, callback) => {
+      const command = getCommand({ config, assertIsValid });
+      try {
+        const overrides = getOverridesForLegacyRequestContext(requestContext);
+        const result = await command.execute(overrides);
+        if (result.isOk()) {
+          deepFreeze(result.value);
+          callback({ data: result.value.data, error: void 0 });
+        } else {
+          callback({ data: void 0, error: toError(result.error.failure) });
+        }
+      } catch (error) {
+        emitError(callback, error);
+      }
+    };
+    const subscribe = (config, requestContext, callback) => {
+      const command = getCommand({ config, assertIsValid });
+      let unsubscribe = () => {
+      };
+      try {
+        const overrides = getOverridesForLegacyRequestContext(requestContext);
+        command.execute(overrides).then(
+          (result) => {
+            if (!result.isOk()) {
+              callback({ data: void 0, error: toError(result.error.failure) });
+              return;
+            }
+            unsubscribe = result.value.subscribe((res) => {
+              if (res.isOk()) {
+                callback({ data: res.value, error: void 0 });
+              } else {
+                callback({ data: void 0, error: toError(res.error) });
+              }
+            });
+            callback({ data: result.value.data, error: void 0 });
+          },
+          (e) => {
+            emitError(callback, e);
+          }
+        );
+      } catch (e) {
+        emitError(callback, e);
+      }
+      return () => {
+        unsubscribe();
+      };
+    };
+    return { invoke, subscribe };
+  }
+}
+function buildServiceDescriptor$3() {
+  return {
+    type: "legacyImperativeBindings",
+    version: "1.0",
+    service: new LegacyImperativeBindingsService()
+  };
+}
+class GraphQLImperativeBindingsService {
+  bind(getCommand, exposeRefresh = false) {
+    return async (...params) => {
+      try {
+        if (params.length) {
+          params[0] = wrapConfigAndVerify(params[0]);
+        }
+        return await buildBaseImperativeInvoker(getCommand, (result) => this.transformResult(result, exposeRefresh))(...params);
+      } catch (error) {
+        logError$1(error);
+        return {
+          data: void 0,
+          errors: [
+            { message: "Internal error in GraphQL adapter occurred", locations: [] }
+          ]
+        };
+      }
+    };
+  }
+  transformResult(result, exposeRefresh = false) {
+    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$1(res.error)) {
+              consumerEmittedData2.data = res.error.data.data;
+              consumerEmittedData2.errors = res.error.data.errors;
+            } else {
+              logError$1(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$1(error);
+              reject(
+                new Error(
+                  "Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data"
+                )
+              );
+            }
+          });
+        };
+      }
+    } else {
+      const resp = toGraphQLResponseFromFailure$1(result.error.failure);
+      consumerEmittedData.data = resp.data;
+      consumerEmittedData.errors = resp.errors;
+    }
+    return consumerEmittedData;
+  }
+}
+function buildServiceDescriptor$2$1() {
+  return {
+    type: "graphQLImperativeBindings",
+    version: "1.0",
+    service: new GraphQLImperativeBindingsService()
+  };
+}
+class GraphQLLegacyImperativeBindingsService {
+  bind(getCommand) {
+    const invoke = async (config, requestContext, callback) => {
+      config = wrapConfigAndVerify(config);
+      const command = getCommand({ config, assertIsValid });
+      try {
+        const overrides = getOverridesForLegacyRequestContext(requestContext);
+        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 {
+          const { data, errors } = toGraphQLResponseFromFailure$1(result.error.failure);
+          consumerEmittedData.data = data;
+          consumerEmittedData.errors = errors;
+        }
+        callback(consumerEmittedData);
+      } catch (error) {
+        logError$1(error);
+        callback({
+          data: void 0,
+          errors: [
+            { message: "Internal error in GraphQL adapter occurred", locations: [] }
+          ]
+        });
+      }
+    };
+    const subscribe = (config, requestContext, callback) => {
+      config = wrapConfigAndVerify(config);
+      const command = getCommand({ config, assertIsValid });
+      let unsubscribe = () => {
+      };
+      const overrides = getOverridesForLegacyRequestContext(requestContext);
+      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) => {
+              handleEmit(res, callback);
+            }
+          );
+        } else {
+          const { data, errors } = toGraphQLResponseFromFailure$1(result.error.failure);
+          consumerEmittedData.data = data;
+          consumerEmittedData.errors = errors;
+          unsubscribe = result.error.subscribe(
+            (res) => {
+              handleEmit(res, callback);
+            }
+          );
+        }
+        callback(consumerEmittedData);
+      });
+      return () => {
+        unsubscribe();
+      };
+    };
+    return { invoke, subscribe };
+  }
+}
+function buildServiceDescriptor$1$1() {
+  return {
+    type: "graphQLLegacyImperativeBindings",
+    version: "1.0",
+    service: new GraphQLLegacyImperativeBindingsService()
+  };
+}
+class GraphQLMutationBindingsService {
+  bind(getCommand) {
+    return async (...params) => {
+      try {
+        if (params.length) {
+          params[0] = wrapConfigAndVerify(params[0], {
+            acceptedOperations: ["mutation"]
+          });
+        }
+        const command = getCommand({ params, assertIsValid });
+        const result = await command.execute({ cacheControlConfig: { type: "no-cache" } });
+        if (result.isOk()) {
+          deepFreeze(result.value);
+          return result.value.data;
+        } else {
+          return toGraphQLResponseFromFailure$1(result.error.failure);
+        }
+      } catch (error) {
+        logError$1(error);
+        return {
+          data: void 0,
+          errors: [
+            { message: "Internal error in GraphQL adapter occurred", locations: [] }
+          ]
+        };
+      }
+    };
+  }
+}
+function buildServiceDescriptor$7() {
+  return {
+    type: "graphQLMutationBindings",
+    version: "1.0",
+    service: new GraphQLMutationBindingsService()
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+class Sanitizer {
+  constructor(obj) {
+    this.obj = obj;
+    this.copy = {};
+    this.currentPath = {
+      key: "",
+      value: obj,
+      parent: null,
+      data: this.copy
+    };
+  }
+  sanitize() {
+    const sanitizer = this;
+    JSON.stringify(this.obj, function(key, value) {
+      if (key === "") {
+        return value;
+      }
+      const parent = this;
+      if (parent !== sanitizer.currentPath.value) {
+        sanitizer.exit(parent);
+      }
+      if (typeof value === "object" && value !== null) {
+        sanitizer.enter(key, value);
+        return value;
+      }
+      sanitizer.currentPath.data[key] = value;
+      return value;
+    });
+    return this.copy;
+  }
+  enter(key, value) {
+    const { currentPath: parentPath } = this;
+    const data = parentPath.data[key] = Array.isArray(value) ? [] : {};
+    this.currentPath = {
+      key,
+      value,
+      parent: parentPath,
+      data
+    };
+  }
+  exit(parent) {
+    while (this.currentPath.value !== parent) {
+      this.currentPath = this.currentPath.parent || this.currentPath;
+    }
+  }
+}
+function sanitize(obj) {
+  return new Sanitizer(obj).sanitize();
+}
+function isIncompleteConfigError(err) {
+  return err instanceof MissingRequiredPropertyError || err instanceof JsonSchemaViolationError && err.validationErrors.find(
+    (validationError) => validationError instanceof MissingRequiredPropertyError
+  ) !== void 0;
 }
+class CommandWireAdapterConstructor {
+  constructor(callback, sourceContext, options) {
+    this.callback = callback;
+    this.connected = false;
+    this.exposeRefresh = false;
+    if (!(options == null ? void 0 : options.skipEmptyEmit)) {
+      this.emit();
+    }
+  }
+  connect() {
+    this.connected = true;
+    this.invokeAdapter();
+  }
+  disconnect() {
+    this.unsubscribe();
+    this.connected = false;
+  }
+  update(config, _context) {
+    this.unsubscribe();
+    this.config = sanitize(config);
+    this.invokeAdapter();
+  }
+  emit(result) {
+    try {
+      if (result === void 0) {
+        this.callback({ data: void 0, error: void 0 });
+      } else {
+        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()) {
+          if (isSubscribableResult(result)) {
+            consumerEmittedData.error = result.error.failure;
+          } else {
+            consumerEmittedData.error = result.error;
+          }
+        } else {
+          if (isSubscribableResult(result)) {
+            deepFreeze(result.value.data);
+            consumerEmittedData.data = result.value.data;
+          } else {
+            deepFreeze(result.value);
+            consumerEmittedData.data = result.value;
+          }
+        }
+        this.callback(consumerEmittedData);
+      }
+    } catch (e) {
+      this.handleExecutionThrow(e);
+    }
+  }
+  invokeAdapter() {
+    if (!this.connected || this.config === void 0) {
+      return;
+    }
+    if (this.configSchema) {
+      try {
+        assertIsValid(this.config, this.configSchema);
+      } catch (err) {
+        if (isIncompleteConfigError(err)) {
+          return;
+        }
+        throw err;
+      }
+    }
+    const initialConfig = this.config;
+    const command = this.getCommand();
+    try {
+      command.execute().then((result) => {
+        if (!this.connected || this.config !== initialConfig) {
+          return;
+        }
+        this.refresh = void 0;
+        if (result.isOk()) {
+          if (isSubscribableResult(result)) {
+            const value = result.value;
+            this.unsubscriber = value.subscribe((updatedResult) => {
+              if (!this.connected || this.config !== initialConfig) {
+                this.unsubscribe();
+                return;
+              }
+              this.emit(updatedResult);
+            });
+            this.refresh = value.refresh;
+            this.emit(ok$2(value.data));
+          } else {
+            this.emit(result);
+          }
+        } else {
+          if (isSubscribableResult(result)) {
+            const value = result.error;
+            this.unsubscriber = value.subscribe((updatedResult) => {
+              if (!this.connected || this.config !== initialConfig) {
+                this.unsubscribe();
+                return;
+              }
+              this.emit(updatedResult);
+            });
+            this.refresh = value.refresh;
+            this.emit(result);
+          } else {
+            this.unsubscriber = () => {
+            };
+            this.emit(result);
+          }
+        }
+      });
+    } catch (e) {
+      this.handleExecutionThrow(e);
+    }
+  }
+  handleExecutionThrow(error) {
+    emitError(this.callback, error);
+  }
+  unsubscribe() {
+    if (this.unsubscriber) {
+      this.unsubscriber();
+      delete this.unsubscriber;
+    }
+  }
+}
+function toGraphQLResponseFromFailure(failure) {
+  if (isUserVisibleError$1(failure)) {
+    return {
+      data: failure.data.data,
+      errors: failure.data.errors
+    };
+  }
+  logError$1(failure);
+  return {
+    data: void 0,
+    errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+  };
+}
+class LWCWireBindingsService {
+  bind(getCommand, configSchema, exposeRefresh = false) {
+    return class extends CommandWireAdapterConstructor {
+      constructor() {
+        super(...arguments);
+        this.configSchema = configSchema;
+        this.exposeRefresh = exposeRefresh;
+      }
+      getCommand() {
+        return getCommand(this.config);
+      }
+    };
+  }
+}
+function buildServiceDescriptor$1() {
+  return {
+    type: "lwcWireBindings",
+    version: "1.0",
+    service: new LWCWireBindingsService()
+  };
+}
+class GraphQLCommandWireAdapterConstructor extends CommandWireAdapterConstructor {
+  emit(result) {
+    try {
+      if (result === void 0) {
+        this.callback({ data: void 0, errors: void 0 });
+      } else {
+        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 GraphQL adapter occurred: Failed to refresh GraphQL data"
+                  )
+                );
+              }
+            });
+          });
+        };
+        let consumerEmittedData = {
+          data: void 0,
+          errors: void 0
+        };
+        if (this.exposeRefresh && this.refresh) {
+          consumerEmittedData.refresh = consumerEmittedRefresh;
+        }
+        if (result.isErr()) {
+          const failure = isSubscribableResult(result) ? result.error.failure : result.error;
+          const resp = toGraphQLResponseFromFailure(failure);
+          consumerEmittedData.data = resp.data;
+          consumerEmittedData.errors = resp.errors;
+        } else {
+          consumerEmittedData.data = result.value.data;
+        }
+        deepFreeze(consumerEmittedData);
+        this.callback(consumerEmittedData);
+      }
+    } catch (e) {
+      logError$1(e);
+      this.handleExecutionThrow(e);
+    }
+  }
+  handleExecutionThrow(e) {
+    logError$1(e);
+    this.callback({
+      data: void 0,
+      errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+    });
+  }
+  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: resolvedQuery
+    };
+    this.invokeAdapter();
+  }
+}
+class LWCGraphQLWireBindingsService {
+  bind(getCommand, configSchema, exposeRefresh = false) {
+    return class extends GraphQLCommandWireAdapterConstructor {
+      constructor() {
+        super(...arguments);
+        this.configSchema = configSchema;
+        this.exposeRefresh = exposeRefresh;
+      }
+      getCommand() {
+        return getCommand(this.config);
+      }
+    };
+  }
+}
+function buildServiceDescriptor$2() {
+  return {
+    type: "lwcGraphQLWireBindings",
+    version: "1.0",
+    service: new LWCGraphQLWireBindingsService()
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+function e(e2) {
+  this.message = e2;
+}
+e.prototype = new Error(), e.prototype.name = "InvalidCharacterError";
+var r = "undefined" != typeof window && window.atob && window.atob.bind(window) || function(r2) {
+  var t2 = String(r2).replace(/=+$/, "");
+  if (t2.length % 4 == 1) throw new e("'atob' failed: The string to be decoded is not correctly encoded.");
+  for (var n2, o2, a = 0, i = 0, c = ""; o2 = t2.charAt(i++); ~o2 && (n2 = a % 4 ? 64 * n2 + o2 : o2, a++ % 4) ? c += String.fromCharCode(255 & n2 >> (-2 * a & 6)) : 0) o2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(o2);
+  return c;
+};
+function t(e2) {
+  var t2 = e2.replace(/-/g, "+").replace(/_/g, "/");
+  switch (t2.length % 4) {
+    case 0:
+      break;
+    case 2:
+      t2 += "==";
+      break;
+    case 3:
+      t2 += "=";
+      break;
+    default:
+      throw "Illegal base64url string!";
+  }
+  try {
+    return (function(e3) {
+      return decodeURIComponent(r(e3).replace(/(.)/g, (function(e4, r2) {
+        var t3 = r2.charCodeAt(0).toString(16).toUpperCase();
+        return t3.length < 2 && (t3 = "0" + t3), "%" + t3;
+      })));
+    })(t2);
+  } catch (e3) {
+    return r(t2);
+  }
+}
+function n(e2) {
+  this.message = e2;
+}
+function o(e2, r2) {
+  if ("string" != typeof e2) throw new n("Invalid token specified");
+  var o2 = true === (r2 = r2 || {}).header ? 0 : 1;
+  try {
+    return JSON.parse(t(e2.split(".")[o2]));
+  } catch (e3) {
+    throw new n("Invalid token specified: " + e3.message);
+  }
+}
+n.prototype = new Error(), n.prototype.name = "InvalidTokenError";
 class JwtToken {
   /**
    * Create a new JwtToken.
@@ -4443,26 +5621,39 @@ class JwtManager {
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-function buildServiceDescriptor(interceptors = { request: [], response: [] }, retryService) {
+function buildServiceDescriptor(interceptors = { request: [], response: [], finally: [] }, retryService) {
   return {
     type: "fetch",
     version: "1.0",
     service: function(...args) {
-      const { request: requestInterceptors = [], response: responseInterceptors = [] } = interceptors;
+      var _a;
+      const context = (_a = interceptors.createContext) == null ? void 0 : _a.call(interceptors);
+      const {
+        request: requestInterceptors = [],
+        response: responseInterceptors = [],
+        finally: finallyInterceptors = []
+      } = interceptors;
       const pending = requestInterceptors.reduce(
-        (previousPromise, interceptor) => previousPromise.then(interceptor),
-        resolvedPromiseLike$3(args)
+        (previousPromise, interceptor) => previousPromise.then((args2) => interceptor(args2, context)),
+        resolvedPromiseLike$2(args)
       );
-      return pending.then((args2) => {
+      return Promise.resolve(pending).then((args2) => {
         if (retryService) {
           return retryService.applyRetry(() => fetch(...args2));
         }
         return fetch(...args2);
       }).then((response) => {
         return responseInterceptors.reduce(
-          (previousPromise, interceptor) => previousPromise.then(interceptor),
-          resolvedPromiseLike$3(response)
+          (previousPromise, interceptor) => previousPromise.then((response2) => interceptor(response2, context)),
+          resolvedPromiseLike$2(response)
         );
+      }).finally(() => {
+        if (finallyInterceptors.length > 0) {
+          return finallyInterceptors.reduce(
+            (previousPromise, interceptor) => previousPromise.then(() => interceptor(context)),
+            Promise.resolve()
+          );
+        }
       });
     }
   };
@@ -4507,7 +5698,7 @@ function setHeaderAuthorization({ token }, fetchParams) {
 }
 function buildJwtRequestHeaderInterceptor(jwtManager, jwtRequestModifier = (_e, fetchArgs) => fetchArgs) {
   return (args) => {
-    return resolvedPromiseLike$3(jwtManager.getJwt()).then((token) => {
+    return resolvedPromiseLike$2(jwtManager.getJwt()).then((token) => {
       const fetchArgsWithRequestHeaderAuthorization = setHeaderAuthorization(token, args);
       return token.extraInfo ? jwtRequestModifier(token.extraInfo, fetchArgsWithRequestHeaderAuthorization) : fetchArgsWithRequestHeaderAuthorization;
     });
@@ -4557,7 +5748,7 @@ const METHODS_WITH_CSRF = ['POST', 'PATCH', 'PUT', 'DELETE'];
 async function webruntimeRequestInterceptor(args) {
     const [url, requestInit] = args;
     if (!(typeof url === 'string' || url instanceof URL)) {
-        return resolvedPromiseLike$3(args);
+        return resolvedPromiseLike$2(args);
     }
     const urlObj = buildApiBaseUrl(url, apiBasePath);
     urlObj.searchParams.append('language', language);
@@ -4568,7 +5759,7 @@ async function webruntimeRequestInterceptor(args) {
     if (requestInit?.method && METHODS_WITH_CSRF.includes(requestInit.method)) {
         await addCSRFToken(requestInit);
     }
-    return resolvedPromiseLike$3(args);
+    return resolvedPromiseLike$2(args);
 }
 function buildApiBaseUrl(url, apiBasePath) {
     // The URL constructor's second argument provides a base if the first argument is a relative URL.
@@ -4643,9 +5834,9 @@ function buildCopilotFetchServiceDescriptor(logger) {
                         requestInit.method !== 'POST' ||
                         !requestInit.body ||
                         typeof requestInit.body !== 'string') {
-                        return resolvedPromiseLike$3(args);
+                        return resolvedPromiseLike$2(args);
                     }
-                    return resolvedPromiseLike$3(sfapJwtManager.getJwt()).then((token) => {
+                    return resolvedPromiseLike$2(sfapJwtManager.getJwt()).then((token) => {
                         // replace the body's instanceConfig.endpoint with the JWT's iss value
                         const body = JSON.parse(requestInit.body);
                         if (!body || !token.decodedInfo || !token.decodedInfo.iss) {
@@ -4702,38 +5893,84 @@ function buildJwtRequestInterceptor(logger) {
     return jwtRequestHeaderInterceptor;
 }
 
-const loggerService = new ConsoleLogger$1('ERROR');
-const cacheServiceDescriptor = buildServiceDescriptor$9();
-const instrumentationServiceDescriptor = buildServiceDescriptor$a(loggerService);
+const loggerService = new ConsoleLogger('ERROR');
+const cacheServiceDescriptor = buildServiceDescriptor$g();
+const instrumentationServiceDescriptor = buildServiceDescriptor$h(loggerService);
 const inMemoryCacheInclusionPolicyServiceDescriptor = buildInMemoryCacheInclusionPolicyService(cacheServiceDescriptor.service);
-const featureFlagsServiceDescriptor = buildServiceDescriptor$6();
+const featureFlagsServiceDescriptor = buildServiceDescriptor$d();
 const featureFlagsService = featureFlagsServiceDescriptor.service;
-// This disables the OneStore GraphQL in this runtime,
-// we will enable this in the future, but while we do rollout, we disable it here
+// This disables the OneStore GraphQL mapping from lightning/uiGraphQLApi to lightning/graphql in this runtime,
+// The gate is likely NOT to rollout ever, but we keep it here for completeness
 featureFlagsService.set('useOneStoreGraphQL', false);
-const services = [
-    instrumentationServiceDescriptor,
-    buildDefaultFetchServiceDescriptor(),
-    buildJwtAuthorizedSfapFetchServiceDescriptor(loggerService),
-    buildCopilotFetchServiceDescriptor(loggerService),
-    buildServiceDescriptor$b(instrumentationServiceDescriptor.service),
-    buildServiceDescriptor$8(cacheServiceDescriptor.service, inMemoryCacheInclusionPolicyServiceDescriptor.service, instrumentationServiceDescriptor.service),
-    buildServiceDescriptor$i(),
-    buildServiceDescriptor$3(),
-    buildServiceDescriptor$e(),
-    buildServiceDescriptor$j(),
-    buildServiceDescriptor$d(),
-    buildServiceDescriptor$c(),
-    buildServiceDescriptor$h(),
-    buildServiceDescriptor$g(),
-    buildServiceDescriptor$f(),
-    buildServiceDescriptor$7(),
-    buildServiceDescriptor$5(),
-    buildServiceDescriptor$4(),
-    featureFlagsServiceDescriptor,
-    // Luvio service won't be used since we set the useOneStoreGraphQL flag to false
-    buildServiceDescriptor$2({}),
-    buildServiceDescriptor$1({}, {}),
-];
-setServices(services);
-// version: 1.401.0-b1adb82748
+// Hardcoding to avoid dependency on lds-adapters-uiapi
+const notifyUpdateAvailableFactory = (luvio) => {
+    return function notifyRecordUpdateAvailable(configs) {
+        if (process.env.NODE_ENV !== 'production') {
+            const requiredKeyParams = ['recordId'];
+            configs.forEach((config) => {
+                if (false === requiredKeyParams.every((req) => req in config)) {
+                    throw new Error(`one of the configs did not contain all required parameters`);
+                }
+            });
+        }
+        const keys = configs.map((c) => `UiApi::RecordRepresentation:${c.recordId}`); // Hardcoding to avoid dependency on lds-adapters-uiapi
+        return luvio.notifyStoreUpdateAvailable(keys);
+    };
+};
+function bindLuvioUiapiRecordsServiceDescriptor(luvio) {
+    return buildServiceDescriptor$8((configs) => {
+        return notifyUpdateAvailableFactory(luvio)(configs);
+    }, (recordId, reader) => {
+        const recordKey = `UiApi::RecordRepresentation:${recordId}`; // Hardcoding to avoid dependency on lds-adapters-uiapi
+        reader.markSeenId(recordKey);
+        const linkedData = reader.read({
+            recordId: recordKey,
+            node: {
+                kind: 'Fragment',
+                private: [],
+                opaque: true,
+                version: '98c5b18512e48ca8d28727549507e4ba', // Hardcoding to avoid dependency on lds-adapters-uiapi
+            },
+            variables: {},
+        });
+        // we don't want anything to be marked missing, since this results in an unfulfilled snapshot
+        reader.unMarkMissing();
+        return linkedData.data;
+    });
+}
+withDefaultLuvio((luvio) => {
+    const services = [
+        instrumentationServiceDescriptor,
+        buildDefaultFetchServiceDescriptor(),
+        buildJwtAuthorizedSfapFetchServiceDescriptor(loggerService),
+        buildCopilotFetchServiceDescriptor(loggerService),
+        buildServiceDescriptor$i(instrumentationServiceDescriptor.service),
+        buildServiceDescriptor$f(cacheServiceDescriptor.service, inMemoryCacheInclusionPolicyServiceDescriptor.service, instrumentationServiceDescriptor.service),
+        buildServiceDescriptor$p(),
+        buildServiceDescriptor$a(),
+        buildServiceDescriptor$l(),
+        buildServiceDescriptor$q(),
+        buildServiceDescriptor$k(),
+        buildServiceDescriptor$j(),
+        buildServiceDescriptor$o(),
+        buildServiceDescriptor$n(),
+        buildServiceDescriptor$m(),
+        buildServiceDescriptor$e(),
+        buildServiceDescriptor$c(),
+        buildServiceDescriptor$b(),
+        featureFlagsServiceDescriptor,
+        buildServiceDescriptor$9(luvio),
+        bindLuvioUiapiRecordsServiceDescriptor(luvio),
+        buildServiceDescriptor$6(),
+        buildServiceDescriptor$5(),
+        buildServiceDescriptor$4(),
+        buildServiceDescriptor$3(),
+        buildServiceDescriptor$2$1(),
+        buildServiceDescriptor$1$1(),
+        buildServiceDescriptor$7(),
+        buildServiceDescriptor$1(),
+        buildServiceDescriptor$2(),
+    ];
+    setServices(services);
+});
+// version: 1.402.0-bf9ae185ef